diff --git a/data_object/CMakeLists.txt b/data_object/CMakeLists.txt
index 318c5f41f10a7072076ac8d88a6ca110ac73b9c7..117034f620a220414c4fd9269668dc16d0ad9b8a 100644
--- a/data_object/CMakeLists.txt
+++ b/data_object/CMakeLists.txt
@@ -35,6 +35,7 @@ include(${KV_STORE_DIR}/interfaces/CMakeLists.txt OPTIONAL)
 set(links secure mock adapter distributeddb kvdb)
 add_library(data_object SHARED ${data_object_src})
 target_link_libraries(data_object ${links})
+target_include_directories(data_object PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/frameworks/innerkitsimpl/include)
 target_include_directories(data_object PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/frameworks/innerkitsimpl/include/common)
 target_include_directories(data_object PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/innerkits)
 target_include_directories(data_object PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../relational_store/interfaces/inner_api/common_type/include)
\ No newline at end of file
diff --git a/data_object/bundle.json b/data_object/bundle.json
index 146b70fc55c04f18355e1b7abc52d6735852bd12..26237616c8df80245469345c178c585fcf0c5c0f 100644
--- a/data_object/bundle.json
+++ b/data_object/bundle.json
@@ -61,10 +61,7 @@
                 "dmsfwk",
                 "hisysevent"
             ],
-            "third_party": [
-                "libuv",
-                "bounds_checking_function"
-            ]
+            "third_party": []
         },
         "build": {
             "sub_component": [
diff --git a/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h b/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h
index e549a1c32220265420f64ebbcdef62c804134ee2..d94ee1f1f9c986c02f6b6cc0c65193943fdf634b 100644
--- a/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h
+++ b/data_object/frameworks/innerkitsimpl/include/adaptor/flat_object_storage_engine.h
@@ -49,6 +49,7 @@ public:
     void NotifyStatus(const std::string &sessionId, const std::string &deviceId, const std::string &status);
     void NotifyChange(const std::string &sessionId, const std::map<std::string, std::vector<uint8_t>> &changedData);
 private:
+    constexpr static const char *DISTRIBUTED_DATASYNC = "ohos.permission.DISTRIBUTED_DATASYNC";
     std::mutex operationMutex_{};
     std::shared_ptr<DistributedDB::KvStoreDelegateManager> storeManager_;
     std::map<std::string, DistributedDB::KvStoreNbDelegate *> delegates_;
diff --git a/data_object/frameworks/innerkitsimpl/include/common/common_types.h b/data_object/frameworks/innerkitsimpl/include/common/common_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..67d4e2e7081f375eba0310428bbb7448ed7b69a7
--- /dev/null
+++ b/data_object/frameworks/innerkitsimpl/include/common/common_types.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DATA_OBJECT_COMMON_TYPES_H
+#define OHOS_DATA_OBJECT_COMMON_TYPES_H
+#include <map>
+#include <string>
+#include <variant>
+#include <vector>
+namespace OHOS::CommonType {
+struct AssetValue {
+    enum Status : int32_t {
+        STATUS_UNKNOWN,
+        STATUS_NORMAL,
+        STATUS_INSERT,
+        STATUS_UPDATE,
+        STATUS_DELETE,
+        STATUS_ABNORMAL,
+        STATUS_DOWNLOADING,
+        STATUS_BUTT
+    };
+    static constexpr uint64_t NO_EXPIRES_TIME = 0;
+    uint32_t version = 0;
+    mutable uint32_t status = STATUS_UNKNOWN;
+    uint64_t expiresTime = NO_EXPIRES_TIME;
+    std::string id;
+    std::string name;
+    std::string uri;
+    std::string createTime;
+    std::string modifyTime;
+    std::string size;
+    std::string hash;
+    std::string path;
+};
+using Bytes = std::vector<uint8_t>;
+using Asset = AssetValue;
+using Assets = std::vector<AssetValue>;
+using Value = std::variant<std::monostate, int64_t, double, std::string, bool, Bytes, Asset, Assets>;
+using ValuesBucket = std::map<std::string, Value>;
+}
+#endif // OHOS_DATA_OBJECT_COMMON_TYPES_H
\ No newline at end of file
diff --git a/data_object/frameworks/innerkitsimpl/include/common/logger.h b/data_object/frameworks/innerkitsimpl/include/common/logger.h
index 2d591b0f0c6af53740f088876c6dc3017f8c2ddb..63f2a1e771e19ff6b13790c674bbc1f33a116701 100644
--- a/data_object/frameworks/innerkitsimpl/include/common/logger.h
+++ b/data_object/frameworks/innerkitsimpl/include/common/logger.h
@@ -60,7 +60,7 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
         }                                                                                   \
     } while (0)
 
-#define LOG_FATAL(fmt, ...)                                                                           \
+#define LOG_FATAL(fmt, ...)                                                                 \
     do {                                                                                    \
         auto lable = LogLabel();                                                            \
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_FATAL)) {                \
@@ -73,14 +73,15 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
 #else
 #include <stdio.h>
 #include <stdlib.h>
+#define __FILE_NAME__ __FILE__
 
 #define LOG_DEBUG(fmt, ...) \
-    printf("[D][ObjectStore]%s:%d %s: " fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+    printf("[D][ObjectStore]%s:%d %s: " fmt "\n", __FILE_NAME__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
 #define LOG_ERROR(fmt, ...) \
-    printf("[E][ObjectStore]%s:%d %s: " fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+    printf("[E][ObjectStore]%s:%d %s: " fmt "\n", __FILE_NAME__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
 #define LOG_INFO(fmt, ...) \
-    printf("[I][ObjectStore]%s:%d %s: " fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+    printf("[I][ObjectStore]%s:%d %s: " fmt "\n", __FILE_NAME__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
 #define LOG_WARN(fmt, ...) \
-    printf("[W][ObjectStore]%s:%d %s: " fmt "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+    printf("[W][ObjectStore]%s:%d %s: " fmt "\n", __FILE_NAME__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
 #endif // #ifdef HILOG_ENABLE
 #endif // OBJECT_STORE_LOGGER_H
diff --git a/data_object/frameworks/innerkitsimpl/include/common/object_radar_reporter.h b/data_object/frameworks/innerkitsimpl/include/common/object_radar_reporter.h
index 95181502b7bc52420d111e9de342175e76d1c733..8c87673de6a8bc6853f3ce3ac5644fb04403ba4a 100644
--- a/data_object/frameworks/innerkitsimpl/include/common/object_radar_reporter.h
+++ b/data_object/frameworks/innerkitsimpl/include/common/object_radar_reporter.h
@@ -16,12 +16,15 @@
 #ifndef OBJECT_RADAR_REPORTER_H
 #define OBJECT_RADAR_REPORTER_H
 
-#include "hisysevent.h"
+#include "hisysevent_c.h"
+#include <string>
+#include "visibility.h"
 
 namespace OHOS::ObjectStore {
 enum BizScene {
     CREATE = 1,
     SAVE = 2,
+    DATA_RESTORE = 3,
 };
 enum CreateStage {
     INIT_STORE = 1,
@@ -33,6 +36,12 @@ enum SaveStage {
     SAVE_TO_SERVICE = 1,
     SAVE_TO_STORE = 2,
     PUSH_ASSETS = 3,
+    SYNC_DATA = 4,
+};
+enum DataRestoreStage {
+    DATA_RECV = 1,
+    ASSETS_RECV = 2,
+    NOTIFY = 3,
 };
 enum StageRes {
     IDLE = 0,
@@ -55,18 +64,21 @@ enum ErrorCode {
     GETKV_FAILED = OFFSET + 6,
     DB_NOT_INIT = OFFSET + 7,
 };
-static constexpr char DOMAIN[] = "DISTDATAMGR";
-const std::string EVENT_NAME = "DISTRIBUTED_DATA_OBJECT_BEHAVIOR";
-static constexpr HiviewDFX::HiSysEvent::EventType TYPE = HiviewDFX::HiSysEvent::EventType::BEHAVIOR;
-const std::string ORG_PKG = "distributeddata";
-const std::string ERROR_CODE = "ERROR_CODE";
-const std::string BIZ_STATE = "BIZ_STATE";
+constexpr char DOMAIN[] = "DISTDATAMGR";
+constexpr char EVENT_NAME[] = "DISTRIBUTED_DATA_OBJECT_BEHAVIOR";
+constexpr char ORG_PKG[] = "distributeddata";
 
-#define RADAR_REPORT(bizScene, bizStage, stageRes, ...)                                            \
-({                                                                                                 \
-    HiSysEventWrite(ObjectStore::DOMAIN, ObjectStore::EVENT_NAME, ObjectStore::TYPE,               \
-        "ORG_PKG", ObjectStore::ORG_PKG, "FUNC", __FUNCTION__,                                     \
-        "BIZ_SCENE", bizScene, "BIZ_STAGE", bizStage, "STAGE_RES", stageRes, ##__VA_ARGS__);       \
-})
+class API_EXPORT RadarReporter {
+public:
+    static void ReportStateStart(std::string func, int32_t scene, int32_t stage, int32_t stageRes,
+        int32_t state, std::string appCaller);
+    static void ReportStateFinished(std::string func, int32_t scene, int32_t stage,
+        int32_t stageRes, int32_t state);
+    static void ReportStateError(std::string func, int32_t scene, int32_t stage, int32_t stageRes,
+        int32_t errCode, int32_t state);
+    static void ReportStage(std::string func, int32_t scene, int32_t stage, int32_t stageRes);
+    static void ReportStageError(std::string func, int32_t scene, int32_t stage,
+        int32_t stageRes, int32_t errCode);
+};
 } // namespace OHOS::ObjectStore
 #endif // OBJECT_RADAR_REPORTER_H
diff --git a/data_object/frameworks/innerkitsimpl/include/communicator/softbus_adapter.h b/data_object/frameworks/innerkitsimpl/include/communicator/softbus_adapter.h
index 748697069f67a6c88820045a8f8aaa3876e1fe0f..bb3961e5e5b5abae9bde64b2ce9f79560b582603 100644
--- a/data_object/frameworks/innerkitsimpl/include/communicator/softbus_adapter.h
+++ b/data_object/frameworks/innerkitsimpl/include/communicator/softbus_adapter.h
@@ -67,7 +67,7 @@ public:
 
     int RemoveSessionServerAdapter(const std::string &sessionName) const;
 
-    void UpdateRelationship(const std::string &networkid, const DeviceChangeType &type);
+    void UpdateRelationship(const std::string &networkId, const DeviceChangeType &type);
 
     void NotifyDataListeners(const uint8_t *ptr, const int size, const std::string &deviceId, const PipeInfo &pipeInfo);
 
diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_impl.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_impl.cpp
index 17b7c15be97d405a39e3eed9f69f218b3c79d220..9bc4246e50965b644f168bbb35c31af78147c014 100644
--- a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_impl.cpp
+++ b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_impl.cpp
@@ -91,7 +91,6 @@ uint32_t DistributedObjectImpl::GetComplex(const std::string &key, std::vector<u
 
 uint32_t DistributedObjectImpl::Save(const std::string &deviceId)
 {
-    RADAR_REPORT(SAVE, SAVE_TO_SERVICE, IDLE, BIZ_STATE, START);
     uint32_t status = flatObjectStore_->Save(sessionId_, deviceId);
     if (status != SUCCESS) {
         LOG_ERROR("DistributedObjectImpl:Save failed. status = %{public}d", status);
diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp
index 8abff6e4abd586b8a439b631621931a1b5bcabf4..5904e83124874f7c3592537e8a89bded4c034a40 100644
--- a/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp
+++ b/data_object/frameworks/innerkitsimpl/src/adaptor/distributed_object_store_impl.cpp
@@ -257,17 +257,18 @@ void WatcherProxy::SetAssetChangeCallBack(const AssetChangeCallback &assetChange
 
 DistributedObjectStore *DistributedObjectStore::GetInstance(const std::string &bundleName)
 {
-    RADAR_REPORT(CREATE, INIT_STORE, IDLE, BIZ_STATE, START);
     static std::mutex instLock_;
     static DistributedObjectStore *instPtr = nullptr;
     if (instPtr == nullptr) {
         std::lock_guard<std::mutex> lock(instLock_);
         if (instPtr == nullptr && !bundleName.empty()) {
+            RadarReporter::ReportStateStart(std::string(__FUNCTION__), CREATE, INIT_STORE, IDLE, START, bundleName);
             LOG_INFO("new objectstore %{public}s", bundleName.c_str());
             FlatObjectStore *flatObjectStore = new (std::nothrow) FlatObjectStore(bundleName);
             if (flatObjectStore == nullptr) {
                 LOG_ERROR("no memory for FlatObjectStore malloc!");
-                RADAR_REPORT(CREATE, INIT_STORE, RADAR_FAILED, ERROR_CODE, NO_MEMORY, BIZ_STATE, FINISHED);
+                RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, INIT_STORE,
+                    RADAR_FAILED, NO_MEMORY, FINISHED);
                 return nullptr;
             }
             // Use instMemory to make sure this singleton not free before other object.
@@ -276,12 +277,13 @@ DistributedObjectStore *DistributedObjectStore::GetInstance(const std::string &b
             if (instPtr == nullptr) {
                 delete flatObjectStore;
                 LOG_ERROR("no memory for DistributedObjectStoreImpl malloc!");
-                RADAR_REPORT(CREATE, INIT_STORE, RADAR_FAILED, ERROR_CODE, NO_MEMORY, BIZ_STATE, FINISHED);
+                RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, INIT_STORE,
+                    RADAR_FAILED, NO_MEMORY, FINISHED);
                 return nullptr;
             }
+            RadarReporter::ReportStage(std::string(__FUNCTION__), CREATE, INIT_STORE, RADAR_SUCCESS);
         }
     }
-    RADAR_REPORT(CREATE, INIT_STORE, RADAR_SUCCESS);
     return instPtr;
 }
 
diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp
index 77fdee13fa7912085bff869bdd6b5742a22b9fe8..8f51a161bc26e905b643375a165de85a9480e2f6 100644
--- a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp
+++ b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_storage_engine.cpp
@@ -14,6 +14,8 @@
  */
 #include "flat_object_storage_engine.h"
 
+#include "accesstoken_kit.h"
+#include "ipc_skeleton.h"
 #include "logger.h"
 #include "objectstore_errors.h"
 #include "process_communicator_impl.h"
@@ -39,18 +41,21 @@ uint32_t FlatObjectStorageEngine::Open(const std::string &bundleName)
         LOG_INFO("FlatObjectDatabase: No need to reopen it");
         return SUCCESS;
     }
-    auto status = DistributedDB::KvStoreDelegateManager::SetProcessLabel("objectstoreDB", bundleName);
-    if (status != DistributedDB::DBStatus::OK) {
-        LOG_ERROR("delegate SetProcessLabel failed: %{public}d.", static_cast<int>(status));
-    }
-
-    auto communicator = std::make_shared<ProcessCommunicatorImpl>();
-    auto commStatus = DistributedDB::KvStoreDelegateManager::SetProcessCommunicator(communicator);
-    if (commStatus != DistributedDB::DBStatus::OK) {
-        LOG_ERROR("set distributed db communicator failed.");
+    auto tokenId = IPCSkeleton::GetSelfTokenID();
+    int32_t ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, DISTRIBUTED_DATASYNC);
+    LOG_INFO("bundleName:%{public}s, permission :%{public}d", bundleName.c_str(), ret);
+    if (ret == Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
+        auto status = DistributedDB::KvStoreDelegateManager::SetProcessLabel("objectstoreDB", bundleName);
+        if (status != DistributedDB::DBStatus::OK) {
+            LOG_ERROR("delegate SetProcessLabel failed: %{public}d.", static_cast<int>(status));
+        }
+        status = DistributedDB::KvStoreDelegateManager::SetProcessCommunicator(
+            std::make_shared<ProcessCommunicatorImpl>());
+        if (status != DistributedDB::DBStatus::OK) {
+            LOG_ERROR("set distributed db communicator failed: %{public}d.", static_cast<int>(status));
+        }
     }
     storeManager_ = std::make_shared<DistributedDB::KvStoreDelegateManager>(bundleName, "default");
-
     DistributedDB::KvStoreConfig config;
     config.dataDir = "/data/log";
     storeManager_->SetKvStoreConfig(config);
@@ -85,16 +90,18 @@ void FlatObjectStorageEngine::OnComplete(const std::string &key,
 
 uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key)
 {
-    RADAR_REPORT(CREATE, CREATE_TABLE, IDLE);
+    RadarReporter::ReportStage(std::string(__FUNCTION__), CREATE, CREATE_TABLE, IDLE);
     if (!isOpened_) {
-        RADAR_REPORT(CREATE, CREATE_TABLE, RADAR_FAILED, ERROR_CODE, DB_NOT_INIT, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, CREATE_TABLE,
+            RADAR_FAILED, DB_NOT_INIT, FINISHED);
         return ERR_DB_NOT_INIT;
     }
     {
         std::lock_guard<std::mutex> lock(operationMutex_);
         if (delegates_.count(key) != 0) {
             LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s already created", key.c_str());
-            RADAR_REPORT(CREATE, CREATE_TABLE, RADAR_FAILED, ERROR_CODE, DUPLICATE_CREATE, BIZ_STATE, FINISHED);
+            RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, CREATE_TABLE, RADAR_FAILED,
+                DUPLICATE_CREATE, FINISHED);
             return ERR_EXIST;
         }
     }
@@ -110,7 +117,8 @@ uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key)
         });
     if (status != DistributedDB::DBStatus::OK || kvStore == nullptr) {
         LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s getkvstore fail[%{public}d]", key.c_str(), status);
-        RADAR_REPORT(CREATE, CREATE_TABLE, RADAR_FAILED, ERROR_CODE, status, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, CREATE_TABLE,
+            RADAR_FAILED, status, FINISHED);
         return ERR_DB_GETKV_FAIL;
     }
     bool autoSync = true;
@@ -119,7 +127,8 @@ uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key)
     status = kvStore->Pragma(DistributedDB::AUTO_SYNC, data);
     if (status != DistributedDB::DBStatus::OK) {
         LOG_ERROR("FlatObjectStorageEngine::CreateTable %{public}s Pragma fail[%{public}d]", key.c_str(), status);
-        RADAR_REPORT(CREATE, CREATE_TABLE, RADAR_FAILED, ERROR_CODE, status, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), CREATE, CREATE_TABLE,
+            RADAR_FAILED, status, FINISHED);
         return ERR_DB_GETKV_FAIL;
     }
     LOG_INFO("create table %{public}s success", key.c_str());
@@ -136,7 +145,7 @@ uint32_t FlatObjectStorageEngine::CreateTable(const std::string &key)
         deviceIds.push_back(item.deviceId);
     }
     SyncAllData(key, deviceIds, onComplete);
-    RADAR_REPORT(CREATE, CREATE_TABLE, RADAR_SUCCESS);
+    RadarReporter::ReportStateFinished(std::string(__FUNCTION__), CREATE, CREATE_TABLE, RADAR_SUCCESS, FINISHED);
     return SUCCESS;
 }
 
diff --git a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_store.cpp b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_store.cpp
index 7ac84b788d4ecf2c62b1cbb850867429b1bfcbd4..c7b109a391a8f53acc10c29f2fc2e42cdd95d373 100644
--- a/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_store.cpp
+++ b/data_object/frameworks/innerkitsimpl/src/adaptor/flat_object_store.cpp
@@ -60,8 +60,8 @@ uint32_t FlatObjectStore::CreateObject(const std::string &sessionId)
         LOG_ERROR("FlatObjectStore::CreateObject createTable err %{public}d", status);
         return status;
     }
-    ResumeObject(sessionId);
     SubscribeDataChange(sessionId);
+    ResumeObject(sessionId);
     return SUCCESS;
 }
 
@@ -83,8 +83,8 @@ void FlatObjectStore::ResumeObject(const std::string &sessionId)
             std::lock_guard<std::mutex> lck(mutex_);
             if (find(retrievedCache_.begin(), retrievedCache_.end(), sessionId) == retrievedCache_.end()) {
                 retrievedCache_.push_back(sessionId);
+                storageEngine_->NotifyStatus(sessionId, "local", "restored");
             }
-            storageEngine_->NotifyStatus(sessionId, "local", "restored");
         }
     };
     cacheManager_->ResumeObject(bundleName_, sessionId, callback);
@@ -105,7 +105,11 @@ void FlatObjectStore::SubscribeDataChange(const std::string &sessionId)
                 storageEngine_->NotifyChange(sessionId, filteredData);
             }
             if (allReady) {
-                storageEngine_->NotifyStatus(sessionId, "local", "restored");
+                std::lock_guard<std::mutex> lck(mutex_);
+                if (find(retrievedCache_.begin(), retrievedCache_.end(), sessionId) == retrievedCache_.end()) {
+                    retrievedCache_.push_back(sessionId);
+                    storageEngine_->NotifyStatus(sessionId, "local", "restored");
+                }
             }
         };
     cacheManager_->SubscribeDataChange(bundleName_, sessionId, remoteResumeCallback);
@@ -182,6 +186,7 @@ uint32_t FlatObjectStore::SetStatusNotifier(std::shared_ptr<StatusWatcher> notif
 
 uint32_t FlatObjectStore::Save(const std::string &sessionId, const std::string &deviceId)
 {
+    RadarReporter::ReportStateStart(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE, IDLE, START, bundleName_);
     if (cacheManager_ == nullptr) {
         LOG_ERROR("FlatObjectStore::cacheManager_ is null");
         return ERR_NULL_PTR;
@@ -190,7 +195,8 @@ uint32_t FlatObjectStore::Save(const std::string &sessionId, const std::string &
     uint32_t status = storageEngine_->GetItems(sessionId, objectData);
     if (status != SUCCESS) {
         LOG_ERROR("FlatObjectStore::GetItems fail");
-        RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_FAILED, ERROR_CODE, status, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
+            RADAR_FAILED, status, FINISHED);
         return status;
     }
     return cacheManager_->Save(bundleName_, sessionId, deviceId, objectData);
@@ -390,9 +396,6 @@ uint32_t CacheManager::Save(const std::string &bundleName, const std::string &se
     LOG_INFO("CacheManager::start wait");
     auto [timeout, res] = block->GetValue();
     LOG_INFO("CacheManager::end wait, timeout: %{public}d, result: %{public}d", timeout, res);
-    if (timeout) {
-        RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_FAILED, ERROR_CODE, TIMEOUT, BIZ_STATE, FINISHED);
-    }
     return res;
 }
 
@@ -421,25 +424,26 @@ int32_t CacheManager::SaveObject(const std::string &bundleName, const std::strin
     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr.");
-        RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_FAILED, ERROR_CODE, SA_DIED, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
+            RADAR_FAILED, SA_DIED, FINISHED);
         return ERR_PROCESSING;
     }
     sptr<ObjectSaveCallbackBroker> objectSaveCallback = new (std::nothrow) ObjectSaveCallback(callback);
     if (objectSaveCallback == nullptr) {
         LOG_ERROR("CacheManager::SaveObject no memory for ObjectSaveCallback malloc!");
-        RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_FAILED, ERROR_CODE, NO_MEMORY, BIZ_STATE, FINISHED);
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
+            RADAR_FAILED, NO_MEMORY, FINISHED);
         return ERR_NULL_PTR;
     }
     int32_t status = proxy->ObjectStoreSave(
         bundleName, sessionId, deviceId, objectData, objectSaveCallback->AsObject().GetRefPtr());
     if (status != SUCCESS) {
         LOG_ERROR("object save failed code=%d.", static_cast<int>(status));
-        if (status == ERR_IPC) {
-            RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_FAILED, ERROR_CODE, IPC_ERROR, BIZ_STATE, FINISHED);
-        }
+        RadarReporter::ReportStateError(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE,
+            RADAR_FAILED, IPC_ERROR, FINISHED);
+    } else {
+        RadarReporter::ReportStage(std::string(__FUNCTION__), SAVE, SAVE_TO_SERVICE, RADAR_SUCCESS);
     }
-    LOG_INFO("object save successful");
-    RADAR_REPORT(SAVE, SAVE_TO_SERVICE, RADAR_SUCCESS);
     return status;
 }
 
@@ -469,24 +473,20 @@ int32_t CacheManager::RevokeSaveObject(
 int32_t CacheManager::ResumeObject(const std::string &bundleName, const std::string &sessionId,
     std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> &callback)
 {
-    RADAR_REPORT(CREATE, RESTORE, IDLE);
     sptr<OHOS::DistributedObject::IObjectService> proxy = ClientAdaptor::GetObjectService();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr.");
-        RADAR_REPORT(CREATE, RESTORE, RADAR_FAILED, ERROR_CODE, SA_DIED, BIZ_STATE, FINISHED);
         return ERR_NULL_PTR;
     }
     sptr<ObjectRetrieveCallbackBroker> objectRetrieveCallback = new (std::nothrow) ObjectRetrieveCallback(callback);
     if (objectRetrieveCallback == nullptr) {
         LOG_ERROR("CacheManager::ResumeObject no memory for ObjectRetrieveCallback malloc!");
-        RADAR_REPORT(CREATE, RESTORE, RADAR_FAILED, ERROR_CODE, NO_MEMORY, BIZ_STATE, FINISHED);
         return ERR_NULL_PTR;
     }
     int32_t status = proxy->ObjectStoreRetrieve(
         bundleName, sessionId, objectRetrieveCallback->AsObject().GetRefPtr());
     if (status != SUCCESS) {
         LOG_ERROR("object resume failed code=%d.", static_cast<int>(status));
-        RADAR_REPORT(CREATE, RESTORE, RADAR_FAILED, ERROR_CODE, IPC_ERROR, BIZ_STATE, FINISHED);
     }
     LOG_INFO("object resume successful");
     return status;
diff --git a/data_object/frameworks/innerkitsimpl/src/communicator/softbus_adapter_standard.cpp b/data_object/frameworks/innerkitsimpl/src/communicator/softbus_adapter_standard.cpp
index 1b2f7aef0216cc57cec6fa4e604c10a08b7aefc1..92f8339696196f3bbcadf6c19d4173d88c7c1ed3 100644
--- a/data_object/frameworks/innerkitsimpl/src/communicator/softbus_adapter_standard.cpp
+++ b/data_object/frameworks/innerkitsimpl/src/communicator/softbus_adapter_standard.cpp
@@ -245,20 +245,20 @@ std::vector<DeviceInfo> SoftBusAdapter::GetRemoteNodesBasicInfo() const
     return dis;
 }
 
-void SoftBusAdapter::UpdateRelationship(const std::string &networkid, const DeviceChangeType &type)
+void SoftBusAdapter::UpdateRelationship(const std::string &networkId, const DeviceChangeType &type)
 {
-    auto uuid = DevManager::GetInstance()->GetUuidByNodeId(networkid);
+    auto uuid = DevManager::GetInstance()->GetUuidByNodeId(networkId);
     lock_guard<mutex> lock(networkMutex_);
     switch (type) {
         case DeviceChangeType::DEVICE_OFFLINE: {
-            auto size = this->networkId2Uuid_.erase(networkid);
+            auto size = this->networkId2Uuid_.erase(networkId);
             if (size == 0) {
-                LOG_WARN("not found id:%{public}s.", networkid.c_str());
+                LOG_WARN("not found id:%{public}s.", Anonymous::Change(networkId).c_str());
             }
             break;
         }
         case DeviceChangeType::DEVICE_ONLINE: {
-            std::pair<std::string, std::string> value = { networkid, uuid };
+            std::pair<std::string, std::string> value = { networkId, uuid };
             auto res = this->networkId2Uuid_.insert(std::move(value));
             if (!res.second) {
                 LOG_WARN("insert failed.");
diff --git a/data_object/frameworks/innerkitsimpl/src/object_radar_reporter.cpp b/data_object/frameworks/innerkitsimpl/src/object_radar_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5d6db6247f070002cbc53bd4280f43489aea2b0d
--- /dev/null
+++ b/data_object/frameworks/innerkitsimpl/src/object_radar_reporter.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "object_radar_reporter.h"
+
+namespace OHOS::ObjectStore {
+    using namespace ObjectStore;
+void RadarReporter::ReportStateFinished(std::string func, int32_t scene, int32_t stage, int32_t stageRes, int32_t state)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "BIZ_STATE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = state },
+            .arraySize = 0 }
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporter::ReportStage(std::string func, int32_t scene, int32_t stage, int32_t stageRes)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporter::ReportStateStart(std::string func, int32_t scene, int32_t stage, int32_t stageRes,
+    int32_t state, std::string appCaller)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "BIZ_STATE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = state },
+            .arraySize = 0 },
+        { .name = { "APP_CALLER" },
+            .t = HISYSEVENT_INT32,
+            .v = { .s = const_cast<char *>(appCaller.c_str()) },
+            .arraySize = 0 },
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporter::ReportStateError(std::string func, int32_t scene, int32_t stage, int32_t stageRes,
+    int32_t errCode, int32_t state)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "ERROR_CODE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = errCode },
+            .arraySize = 0 },
+        { .name = { "BIZ_STATE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = state },
+            .arraySize = 0 },
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporter::ReportStageError(std::string func, int32_t scene, int32_t stage,
+    int32_t stageRes, int32_t errCode)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "ERROR_CODE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = errCode },
+            .arraySize = 0 },
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+}
diff --git a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn
index 8a8cd1bce93b3a950bbaaadb49317f97a2d53ab0..42477193be9047c17123d2975bc6a951aa3257af 100644
--- a/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn
+++ b/data_object/frameworks/innerkitsimpl/test/fuzztest/objectstore_fuzzer/BUILD.gn
@@ -22,7 +22,6 @@ config("module_private_config") {
     "../../../../../frameworks/innerkitsimpl/include/adaptor",
     "../../../../../frameworks/innerkitsimpl/include/common",
     "${data_object_base_path}/frameworks/innerkitsimpl/include",
-    "${relational_store_path}/interfaces/inner_api/common_type/include",
   ]
 }
 
diff --git a/data_object/frameworks/jskitsimpl/include/adaptor/js_object_wrapper.h b/data_object/frameworks/jskitsimpl/include/adaptor/js_object_wrapper.h
index ffb68c40f8cc41b74273fb75fd38e7ffd89ce8ce..0f8ea760c8d82748d4df8fab04d97ba4f61ee7d4 100644
--- a/data_object/frameworks/jskitsimpl/include/adaptor/js_object_wrapper.h
+++ b/data_object/frameworks/jskitsimpl/include/adaptor/js_object_wrapper.h
@@ -30,9 +30,9 @@ public:
     DistributedObject *GetObject();
     bool AddWatch(napi_env env, const char *type, napi_value handler);
     void DeleteWatch(napi_env env, const char *type, napi_value handler = nullptr);
-    bool isUndefined(char *value);
-    void AddUndefined(char *value);
-    void DeleteUndefined(char *value);
+    bool IsUndefined(const char *value);
+    void AddUndefined(const char *value);
+    void DeleteUndefined(const char *value);
     void DestroyObject();
     void SetObjectId(const std::string &objectId);
     std::string GetObjectId();
diff --git a/data_object/frameworks/jskitsimpl/include/common/uv_queue.h b/data_object/frameworks/jskitsimpl/include/common/uv_queue.h
index 3c90ddb502fcfeecc158ce95f616655ee0dc382a..d7fe19a6c614fbad370459321a402113b898e4d4 100644
--- a/data_object/frameworks/jskitsimpl/include/common/uv_queue.h
+++ b/data_object/frameworks/jskitsimpl/include/common/uv_queue.h
@@ -17,8 +17,8 @@
 #include <functional>
 #include <list>
 #include <map>
-#include <shared_mutex>
 #include <memory>
+#include <shared_mutex>
 #include "napi/native_api.h"
 #include "napi/native_node_api.h"
 #include "uv.h"
diff --git a/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobject.cpp b/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobject.cpp
index a603ac31c1cb0aa9c5b2b41506bcc875c8c7c185..c932c2fc3e7bb270aab22e886bc46f4233622121 100644
--- a/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobject.cpp
+++ b/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobject.cpp
@@ -58,7 +58,7 @@ napi_value JSDistributedObject::JSGet(napi_env env, napi_callback_info info)
     status = napi_unwrap(env, thisVar, (void **)&wrapper);
     NOT_MATCH_RETURN_NULL(status == napi_ok && wrapper != nullptr && wrapper->GetObject() != nullptr);
     napi_value result = nullptr;
-    if (wrapper->isUndefined(key)) {
+    if (wrapper->IsUndefined(key)) {
         napi_get_undefined(env, &result);
         return result;
     }
diff --git a/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobjectstore.cpp b/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobjectstore.cpp
index 6af72368f815d5eeace6a1351d22a6279c61201d..f18d2787d1415d1aaa0c405482cca5570a533b3e 100644
--- a/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobjectstore.cpp
+++ b/data_object/frameworks/jskitsimpl/src/adaptor/js_distributedobjectstore.cpp
@@ -20,6 +20,7 @@
 
 #include "ability_context.h"
 #include "accesstoken_kit.h"
+#include "anonymous.h"
 #include "application_context.h"
 #include "distributed_objectstore.h"
 #include "js_ability.h"
diff --git a/data_object/frameworks/jskitsimpl/src/adaptor/js_object_wrapper.cpp b/data_object/frameworks/jskitsimpl/src/adaptor/js_object_wrapper.cpp
index aa2be5ba745cf631a38c7a230990b411d966ed29..5f3436b67b6f054d2dd2a37424d532a024b0bd2e 100644
--- a/data_object/frameworks/jskitsimpl/src/adaptor/js_object_wrapper.cpp
+++ b/data_object/frameworks/jskitsimpl/src/adaptor/js_object_wrapper.cpp
@@ -65,7 +65,7 @@ void JSObjectWrapper::DeleteWatch(napi_env env, const char *type, napi_value han
     }
 }
 
-bool JSObjectWrapper::isUndefined(char *value)
+bool JSObjectWrapper::IsUndefined(const char *value)
 {
     std::string tmpStr = value;
     auto it = std::find(undefinedProperties.begin(), undefinedProperties.end(), tmpStr);
@@ -75,7 +75,7 @@ bool JSObjectWrapper::isUndefined(char *value)
     return true;
 }
 
-void JSObjectWrapper::AddUndefined(char *value)
+void JSObjectWrapper::AddUndefined(const char *value)
 {
     std::string tmpStr = value;
     if (std::find(undefinedProperties.begin(), undefinedProperties.end(), tmpStr) == undefinedProperties.end()) {
@@ -83,7 +83,7 @@ void JSObjectWrapper::AddUndefined(char *value)
     }
 }
 
-void JSObjectWrapper::DeleteUndefined(char *value)
+void JSObjectWrapper::DeleteUndefined(const char *value)
 {
     std::string tmpStr = value;
     auto it = std::find(undefinedProperties.begin(), undefinedProperties.end(), tmpStr);
diff --git a/data_object/interfaces/innerkits/BUILD.gn b/data_object/interfaces/innerkits/BUILD.gn
index f5b8ab1bd0ad4e192ea013185f7f602a009dff01..5c76f81ece1a439a3589e5add5aa0f4f136a3aff 100644
--- a/data_object/interfaces/innerkits/BUILD.gn
+++ b/data_object/interfaces/innerkits/BUILD.gn
@@ -23,7 +23,6 @@ config("objectstore_config") {
     "../../frameworks/innerkitsimpl/include/communicator",
     "../../frameworks/innerkitsimpl/include",
     "../../interfaces/innerkits",
-    "${relational_store_path}/interfaces/inner_api/common_type/include",
   ]
 
   ldflags = [ "-Wl,--exclude-libs,ALL" ]
@@ -53,11 +52,13 @@ object_source_config = [
   "../../frameworks/innerkitsimpl/src/communicator/process_communicator_impl.cpp",
   "../../frameworks/innerkitsimpl/src/communicator/softbus_adapter_standard.cpp",
   "../../frameworks/innerkitsimpl/src/object_callback_stub.cpp",
+  "../../frameworks/innerkitsimpl/src/object_radar_reporter.cpp",
   "../../frameworks/innerkitsimpl/src/object_service_proxy.cpp",
   "../../frameworks/innerkitsimpl/src/object_types_util.cpp",
 ]
 object_deps_config = []
 object_external_deps_config = [
+  "access_token:libaccesstoken_sdk",
   "bounds_checking_function:libsec_shared",
   "c_utils:utils",
   "device_manager:devicemanagersdk",
diff --git a/data_object/interfaces/jskits/BUILD.gn b/data_object/interfaces/jskits/BUILD.gn
index 64fdcd1844e7aee6a05398627612eab3a9364d62..7b4c7aafa384fd3f8090d418652ef6456ec39c00 100644
--- a/data_object/interfaces/jskits/BUILD.gn
+++ b/data_object/interfaces/jskits/BUILD.gn
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//arkcompiler/ets_frontend/es2panda/es2abc_config.gni")
+import("//build/config/components/ets_frontend/es2abc_config.gni")
 import("//build/ohos.gni")
 import("//build/ohos/ace/ace.gni")
 import("//foundation/distributeddatamgr/data_object/data_object.gni")
@@ -42,7 +42,6 @@ config("objectstore_config") {
     "../../frameworks/innerkitsimpl/include",
     "../../frameworks/innerkitsimpl/include/communicator",
     "../../interfaces/innerkits",
-    "${relational_store_path}/interfaces/inner_api/common_type/include",
   ]
 }
 
diff --git a/data_object/interfaces/jskits/distributed_data_object.js b/data_object/interfaces/jskits/distributed_data_object.js
index a7656331fba01eded0c39d3c27c9b7fd6c2e4141..2882265480f90f580bb74562ff1d67e2acf7d3d3 100644
--- a/data_object/interfaces/jskits/distributed_data_object.js
+++ b/data_object/interfaces/jskits/distributed_data_object.js
@@ -25,6 +25,8 @@ const ASSET_KEY_SEPARATOR = '.';
 const JS_ERROR = 1;
 const SDK_VERSION_8 = 8;
 const SDK_VERSION_9 = 9;
+const SESSION_ID_REGEX = /^\w+$/;
+const SESSION_ID_MAX_LENGTH = 128;
 
 class Distributed {
   constructor(obj) {
@@ -147,22 +149,18 @@ function getObjectValue(object, key) {
 }
 
 function setObjectValue(object, key, newValue) {
-  console.info('start set ' + key + ' ' + newValue);
+  console.info('start set ' + key);
   if (typeof newValue === 'object') {
     let value = COMPLEX_TYPE + JSON.stringify(newValue);
     object.put(key, value);
-    console.info('set ' + key + ' ' + value);
   } else if (typeof newValue === 'string') {
     let value = STRING_TYPE + newValue;
     object.put(key, value);
-    console.info('set ' + key + ' ' + value);
   } else if (newValue == null) {
     let value = NULL_TYPE;
     object.put(key, value);
-    console.info('set ' + key + ' ' + value);
   } else {
     object.put(key, newValue);
-    console.info('set ' + key + ' ' + newValue);
   }
 }
 
@@ -179,8 +177,7 @@ function isAsset(obj) {
     return false;
   }
   for (const key of ASSET_KEYS.slice(1)) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key) ||
-      (typeof obj[key] !== 'string' && typeof obj[key] !== 'undefined')) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key) || typeof obj[key] !== 'string') {
       return false;
     }
   }
@@ -200,7 +197,7 @@ function defineAsset(object, key, data) {
   });
   let asset = object[key];
   Object.keys(data).forEach(subKey => {
-    if (data[subKey] !== undefined) {
+    if (data[subKey] !== '') {
       asset[subKey] = data[subKey];
     }
   });
@@ -230,7 +227,7 @@ function setAssetValue(object, key, newValue) {
       message: 'cannot set ' + key + ' by non Asset type data'
     };
   }
-  Object.values(newValue).forEach(subKey => {
+  Object.keys(newValue).forEach(subKey => {
     setObjectValue(object, key + ASSET_KEY_SEPARATOR + subKey, newValue[subKey]);
   });
 }
@@ -375,6 +372,12 @@ class DistributedV9 {
       }
     }
     leaveSession(this.__sdkVersion, this.__proxy);
+    if (sessionId.length > SESSION_ID_MAX_LENGTH || !SESSION_ID_REGEX.test(sessionId)) {
+      throw {
+        code: 401,
+        message: 'The sessionId allows only letters, digits, and underscores(_), and cannot exceed 128 in length.'
+      };
+    }
     let object = joinSession(this.__sdkVersion, this.__proxy, this.__objectId, sessionId, this.__context);
     if (object != null) {
       this.__proxy = object;
diff --git a/data_share/OAT.xml b/data_share/OAT.xml
index 0e4aff54f26eb56df44cd206cbac3fb2a1e17023..0330ab10eb1bb7b729107c51ec6ccf38b0af81a9 100644
--- a/data_share/OAT.xml
+++ b/data_share/OAT.xml
@@ -52,15 +52,7 @@
             </filefilter>
             <filefilter name="binaryFileTypePolicyFilter" desc="Filters for binary file policies">
                 <filteritem type="filepath" name="figures/zh-cn_dataShare.png" desc="self developed image"/>
-                <filteritem type="filepath"
-                            name="test/native/resource/datashare_ext_bundle/entry/src/main/resources/base/media/icon.png"
-                            desc="self developed image"/>
-                <filteritem type="filepath"
-                            name="test/native/resource/datashareproxy_bundle/proxydatas_with_permission/entry/src/main/resources/base/media/icon.png"
-                            desc="self developed image"/>
-                <filteritem type="filepath"
-                            name="test/native/resource/errorcode_ext_bundle/entry/src/main/resources/base/media/icon.png"
-                            desc="self developed image"/>
+                <filteritem type="filepath" name="test/native/resource/.*.png" desc="self developed image"/>
             </filefilter>
         </filefilterlist>
     </oatconfig>
diff --git a/data_share/frameworks/js/napi/common/include/datashare_predicates_proxy.h b/data_share/frameworks/js/napi/common/include/datashare_predicates_proxy.h
index db22b37d8f9b46258acd19320cab6f8322520f54..be455506fae86ee6c363b547212769d46b14c465 100644
--- a/data_share/frameworks/js/napi/common/include/datashare_predicates_proxy.h
+++ b/data_share/frameworks/js/napi/common/include/datashare_predicates_proxy.h
@@ -72,6 +72,7 @@ private:
     static napi_value NotIn(napi_env env, napi_callback_info info);
     static napi_value PrefixKey(napi_env env, napi_callback_info info);
     static napi_value InKeys(napi_env env, napi_callback_info info);
+    static napi_value CreateConstructor(napi_env env);
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/frameworks/js/napi/common/src/datashare_predicates_proxy.cpp b/data_share/frameworks/js/napi/common/src/datashare_predicates_proxy.cpp
index ef9ccf25155626b1d417ebe9836f0111753678ee..1a68e8c597f93a11da44de9d5b9d42b4474b1e2e 100644
--- a/data_share/frameworks/js/napi/common/src/datashare_predicates_proxy.cpp
+++ b/data_share/frameworks/js/napi/common/src/datashare_predicates_proxy.cpp
@@ -15,6 +15,9 @@
 
 #include "datashare_predicates_proxy.h"
 
+#include <chrono>
+#include <cinttypes>
+
 #include "datashare_log.h"
 #include "datashare_js_utils.h"
 #include "datashare_predicates.h"
@@ -30,6 +33,12 @@ napi_value DataSharePredicatesProxy::GetConstructor(napi_env env)
         NAPI_CALL(env, napi_get_reference_value(env, constructor_, &cons));
         return cons;
     }
+    return CreateConstructor(env);
+}
+
+napi_value DataSharePredicatesProxy::CreateConstructor(napi_env env)
+{
+    napi_value cons;
     napi_property_descriptor descriptors[] = {
         DECLARE_NAPI_FUNCTION("equalTo", EqualTo),
         DECLARE_NAPI_FUNCTION("notEqualTo", NotEqualTo),
@@ -62,9 +71,17 @@ napi_value DataSharePredicatesProxy::GetConstructor(napi_env env)
         DECLARE_NAPI_FUNCTION("prefixKey", PrefixKey),
         DECLARE_NAPI_FUNCTION("inKeys", InKeys),
     };
+    int64_t start = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
     NAPI_CALL(env, napi_define_class(env, "DataSharePredicates", NAPI_AUTO_LENGTH, New, nullptr,
         sizeof(descriptors) / sizeof(napi_property_descriptor), descriptors, &cons));
+    int64_t middle = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
     NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
+    int64_t finish = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    LOG_INFO("Init predicates create reference, cost time: %{public}" PRIi64
+        "ms , cost time:%{public}" PRIi64 "ms", middle - start, finish - middle);
     return cons;
 }
 
@@ -74,7 +91,12 @@ void DataSharePredicatesProxy::Init(napi_env env, napi_value exports)
     // cause use-after-free.
     constructor_ = nullptr;
     napi_value cons = GetConstructor(env);
+    int64_t start = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "DataSharePredicates", cons));
+    int64_t end = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    LOG_INFO("Init predicates set named property, cost time:%{public}" PRIi64 "ms", end - start);
 }
 
 napi_value DataSharePredicatesProxy::New(napi_env env, napi_callback_info info)
diff --git a/data_share/frameworks/js/napi/dataShare/src/async_call.cpp b/data_share/frameworks/js/napi/dataShare/src/async_call.cpp
index a7e436802ac533ee856ae43e0070d02af335281e..b4e1bf9b6f461b326706cb47963915861327fc0a 100644
--- a/data_share/frameworks/js/napi/dataShare/src/async_call.cpp
+++ b/data_share/frameworks/js/napi/dataShare/src/async_call.cpp
@@ -19,8 +19,8 @@
 #include "napi_common_data.h"
 
 namespace OHOS::DataShare {
-AsyncCall::AsyncCall(napi_env env, napi_callback_info info, std::shared_ptr<Context> context)
-    : env_(env)
+__attribute__((no_sanitize("undefined"))) AsyncCall::AsyncCall(napi_env env, napi_callback_info info,
+    std::shared_ptr<Context> context) : env_(env)
 {
     context_ = new AsyncContext();
     size_t argc = ARGS_MAX_COUNT;
diff --git a/data_share/frameworks/js/napi/dataShare/src/napi_datashare_helper.cpp b/data_share/frameworks/js/napi/dataShare/src/napi_datashare_helper.cpp
index 11cf632c51a01d3de01e9cc49a41638c72d2629b..9e6c535795affb34b248a0414159134620ecb5be 100644
--- a/data_share/frameworks/js/napi/dataShare/src/napi_datashare_helper.cpp
+++ b/data_share/frameworks/js/napi/dataShare/src/napi_datashare_helper.cpp
@@ -16,6 +16,7 @@
 #include "napi_datashare_helper.h"
 
 #include "data_proxy_observer_stub.h"
+#include "datashare_errno.h"
 #include "datashare_helper.h"
 #include "datashare_log.h"
 #include "datashare_predicates_proxy.h"
@@ -31,6 +32,7 @@ using namespace OHOS::AppExecFwk;
 namespace OHOS {
 namespace DataShare {
 static constexpr int MAX_ARGC = 6;
+static __thread napi_ref constructor_ = nullptr;
 static bool GetSilentUri(napi_env env, napi_value jsValue, std::string &uri)
 {
     napi_valuetype valuetype = napi_undefined;
@@ -141,6 +143,10 @@ napi_value NapiDataShareHelper::Napi_CreateDataShareHelper(napi_env env, napi_ca
 napi_value NapiDataShareHelper::GetConstructor(napi_env env)
 {
     napi_value cons = nullptr;
+    if (constructor_ != nullptr) {
+        napi_get_reference_value(env, constructor_, &cons);
+        return cons;
+    }
     napi_property_descriptor clzDes[] = {
         DECLARE_NAPI_FUNCTION("on", Napi_On),
         DECLARE_NAPI_FUNCTION("off", Napi_Off),
@@ -161,6 +167,7 @@ napi_value NapiDataShareHelper::GetConstructor(napi_env env)
     };
     NAPI_CALL(env, napi_define_class(env, "DataShareHelper", NAPI_AUTO_LENGTH, Initialize, nullptr,
         sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons));
+    napi_create_reference(env, cons, 1, &constructor_);
     return cons;
 }
 
diff --git a/data_share/frameworks/js/napi/dataShare/src/native_datashare_predicates_module.cpp b/data_share/frameworks/js/napi/dataShare/src/native_datashare_predicates_module.cpp
index 27c39ed8afc03b98e2782388a8781bef1a5bca20..399ce1766e057cadf856bf213aebeb5cf8997b5f 100644
--- a/data_share/frameworks/js/napi/dataShare/src/native_datashare_predicates_module.cpp
+++ b/data_share/frameworks/js/napi/dataShare/src/native_datashare_predicates_module.cpp
@@ -13,11 +13,10 @@
  * limitations under the License.
  */
 
-#include "napi/native_api.h"
-#include "napi/native_node_api.h"
-
 #include "datashare_log.h"
 #include "datashare_predicates_proxy.h"
+#include "napi/native_api.h"
+#include "napi/native_node_api.h"
 
 namespace OHOS {
 namespace DataShare {
diff --git a/data_share/frameworks/js/napi/datashare_ext_ability/BUILD.gn b/data_share/frameworks/js/napi/datashare_ext_ability/BUILD.gn
index e7e8367d8e2b8a0ac2d261d197e35a1c2ac2b2ce..4c45fb80fcc97cf7e4d916d8ef3140458411137e 100644
--- a/data_share/frameworks/js/napi/datashare_ext_ability/BUILD.gn
+++ b/data_share/frameworks/js/napi/datashare_ext_ability/BUILD.gn
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//arkcompiler/ets_frontend/es2panda/es2abc_config.gni")
+import("//build/config/components/ets_frontend/es2abc_config.gni")
 import("//build/ohos.gni")
 
 es2abc_gen_abc("gen_datashare_ext_ability_abc") {
diff --git a/data_share/frameworks/js/napi/datashare_ext_ability/datashare_ext_ability.js b/data_share/frameworks/js/napi/datashare_ext_ability/datashare_ext_ability.js
index c58357dcac12cb269f68ee3c187c7fb9be9487c7..75f507f081017bc6a4064bdd64826fbb4b3280d4 100644
--- a/data_share/frameworks/js/napi/datashare_ext_ability/datashare_ext_ability.js
+++ b/data_share/frameworks/js/napi/datashare_ext_ability/datashare_ext_ability.js
@@ -16,6 +16,7 @@
 class DataShareExtensionAbility {
   onCreate(want, callback) {
     console.log('onCreate, want:' + want.abilityName);
+    callback(undefined);
   }
 
   getFileTypes(uri, mimeTypeFilter, callback) {
diff --git a/data_share/frameworks/js/napi/datashare_ext_ability_context/BUILD.gn b/data_share/frameworks/js/napi/datashare_ext_ability_context/BUILD.gn
index cce58b4315c67c52dab02d880089c7d61a141e88..31b9ac7190e63e9924daefc3a43ab5b20cff4163 100644
--- a/data_share/frameworks/js/napi/datashare_ext_ability_context/BUILD.gn
+++ b/data_share/frameworks/js/napi/datashare_ext_ability_context/BUILD.gn
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//arkcompiler/ets_frontend/es2panda/es2abc_config.gni")
+import("//build/config/components/ets_frontend/es2abc_config.gni")
 import("//build/ohos.gni")
 
 es2abc_gen_abc("gen_datashare_ext_ability_context_abc") {
diff --git a/data_share/frameworks/native/common/include/call_reporter.h b/data_share/frameworks/native/common/include/call_reporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..52b83e91c8285ffa09d36238939ed36ab70c76e3
--- /dev/null
+++ b/data_share/frameworks/native/common/include/call_reporter.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DATASHARE_CALL_REPORTER_H
+#define DATASHARE_CALL_REPORTER_H
+
+#include <concurrent_map.h>
+#include <string>
+
+namespace OHOS {
+namespace DataShare {
+class DataShareCallReporter {
+public:
+    DataShareCallReporter() = default;
+    struct CallInfo {
+        int count = 0;
+        std::chrono::system_clock::time_point firstTime;
+    };
+    void Count(const std::string &funcName, const std::string &uri);
+private:
+    ConcurrentMap<std::string, CallInfo> callCounts;
+    static constexpr int RESET_COUNT_THRESHOLD = 100;
+    static constexpr std::chrono::milliseconds TIME_THRESHOLD = std::chrono::milliseconds(30000);
+};
+} // namespace DataShare
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/data_share/frameworks/native/common/include/datashare_block_writer_impl.h b/data_share/frameworks/native/common/include/datashare_block_writer_impl.h
index dbe2dea9e98a6b2b6785a84d1e7bde6ddfa75dec..be0b9bc7394d58e7e4f644f47c7416ac95dec2c8 100644
--- a/data_share/frameworks/native/common/include/datashare_block_writer_impl.h
+++ b/data_share/frameworks/native/common/include/datashare_block_writer_impl.h
@@ -76,7 +76,7 @@ public:
     /**
      * Get Block
      */
-    AppDataFwk::SharedBlock *GetBlock() const;
+    std::shared_ptr<AppDataFwk::SharedBlock> GetBlock();
 
 private:
     /**
@@ -93,7 +93,7 @@ private:
     }
 
 private:
-    AppDataFwk::SharedBlock *shareBlock_;
+    std::shared_ptr<AppDataFwk::SharedBlock> shareBlock_;
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/frameworks/native/common/include/datashare_log.h b/data_share/frameworks/native/common/include/datashare_log.h
index 9b33a6e188eb51297256979c3c6ddd428cb564ce..24eb67c3d1f42fc3b3202707efe92bfafd55a3e8 100644
--- a/data_share/frameworks/native/common/include/datashare_log.h
+++ b/data_share/frameworks/native/common/include/datashare_log.h
@@ -16,6 +16,7 @@
 #ifndef DATASHARE_LOG_PRINT_H
 #define DATASHARE_LOG_PRINT_H
 
+#include <stdio.h>
 #include "hilog/log.h"
 
 namespace OHOS::DataShare {
@@ -25,15 +26,13 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
 }
 } // namespace OHOS::DataShare
 
-#define FILENAME (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__)
-
 #define LOG_DEBUG(fmt, ...)                                                               \
     do {                                                                                  \
         auto lable = LogLabel();                                                          \
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_DEBUG)) {              \
             ((void)HILOG_IMPL(lable.type, LogLevel::LOG_DEBUG, lable.domain, lable.tag,   \
                               "[%{public}s()-%{public}s:%{public}d]: " fmt, __FUNCTION__, \
-                              FILENAME, __LINE__, ##__VA_ARGS__));                        \
+                              __FILE_NAME__, __LINE__, ##__VA_ARGS__));                   \
         }                                                                                 \
     } while (0)
 
@@ -43,7 +42,7 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_INFO)) {               \
             ((void)HILOG_IMPL(lable.type, LogLevel::LOG_INFO, lable.domain, lable.tag,    \
                               "[%{public}s()-%{public}s:%{public}d]: " fmt, __FUNCTION__, \
-                              FILENAME, __LINE__, ##__VA_ARGS__));                        \
+                              __FILE_NAME__, __LINE__, ##__VA_ARGS__));                   \
         }                                                                                 \
     } while (0)
 
@@ -53,7 +52,7 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_WARN)) {               \
             ((void)HILOG_IMPL(lable.type, LogLevel::LOG_WARN, lable.domain, lable.tag,    \
                               "[%{public}s()-%{public}s:%{public}d]: " fmt, __FUNCTION__, \
-                              FILENAME, __LINE__, ##__VA_ARGS__));                        \
+                              __FILE_NAME__, __LINE__, ##__VA_ARGS__));                   \
         }                                                                                 \
     } while (0)
 
@@ -63,7 +62,7 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_ERROR)) {              \
             ((void)HILOG_IMPL(lable.type, LogLevel::LOG_ERROR, lable.domain, lable.tag,   \
                               "[%{public}s()-%{public}s:%{public}d]: " fmt, __FUNCTION__, \
-                              FILENAME, __LINE__, ##__VA_ARGS__));                        \
+                              __FILE_NAME__, __LINE__, ##__VA_ARGS__));                   \
         }                                                                                 \
     } while (0)
 
@@ -73,7 +72,7 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
         if (HiLogIsLoggable(lable.domain, lable.tag, LogLevel::LOG_FATAL)) {              \
             ((void)HILOG_IMPL(lable.type, LogLevel::LOG_FATAL, lable.domain, lable.tag,   \
                               "[%{public}s()-%{public}s:%{public}d]: " fmt, __FUNCTION__, \
-                              FILENAME, __LINE__, ##__VA_ARGS__));                        \
+                              __FILE_NAME__, __LINE__, ##__VA_ARGS__));                   \
         }                                                                                 \
     } while (0)
 
diff --git a/data_share/frameworks/native/common/include/datashare_string_utils.h b/data_share/frameworks/native/common/include/datashare_string_utils.h
index be6f7f9e843a54b5534bf4f3da0269fdd3e2cfdd..24b187e92731eefd90926e04730df80b56ebc1ce 100644
--- a/data_share/frameworks/native/common/include/datashare_string_utils.h
+++ b/data_share/frameworks/native/common/include/datashare_string_utils.h
@@ -30,6 +30,8 @@ public:
 
     static std::string Change(const std::string &name);
 
+    static int32_t GetRandomNumber(const int32_t min, const int32_t max);
+
 private:
     DataShareStringUtils();
     ~DataShareStringUtils();
diff --git a/data_share/frameworks/native/common/include/distributeddata_data_share_ipc_interface_code.h b/data_share/frameworks/native/common/include/distributeddata_data_share_ipc_interface_code.h
index b91a91f9b6618e646654c386faf5f69fa3e3699d..a2189936a095ce97a52319907dfecbfcbbfc3e8a 100644
--- a/data_share/frameworks/native/common/include/distributeddata_data_share_ipc_interface_code.h
+++ b/data_share/frameworks/native/common/include/distributeddata_data_share_ipc_interface_code.h
@@ -38,6 +38,9 @@ enum class IDataShareInterfaceCode {
     CMD_EXECUTE_BATCH,
     CMD_INSERT_EXT,
     CMD_BATCH_UPDATE,
+    CMD_INSERT_EX,
+    CMD_UPDATE_EX,
+    CMD_DELETE_EX,
 };
 
 enum class ISharedResultInterfaceCode {
@@ -71,9 +74,6 @@ enum class ISharedResultInterfaceCode {
 };
 
 enum class DataShareServiceInterfaceCode {
-    DATA_SHARE_SERVICE_CMD_INSERT,
-    DATA_SHARE_SERVICE_CMD_DELETE,
-    DATA_SHARE_SERVICE_CMD_UPDATE,
     DATA_SHARE_SERVICE_CMD_QUERY,
     DATA_SHARE_SERVICE_CMD_ADD_TEMPLATE,
     DATA_SHARE_SERVICE_CMD_DEL_TEMPLATE,
@@ -93,6 +93,9 @@ enum class DataShareServiceInterfaceCode {
     DATA_SHARE_SERVICE_CMD_GET_SILENT_PROXY_STATUS,
     DATA_SHARE_SERVICE_CMD_REGISTER_OBSERVER,
     DATA_SHARE_SERVICE_CMD_UNREGISTER_OBSERVER,
+    DATA_SHARE_SERVICE_CMD_INSERTEX,
+    DATA_SHARE_SERVICE_CMD_DELETEEX,
+    DATA_SHARE_SERVICE_CMD_UPDATEEX,
     DATA_SHARE_SERVICE_CMD_MAX
 };
 
diff --git a/data_share/frameworks/native/common/include/idata_share_service.h b/data_share/frameworks/native/common/include/idata_share_service.h
index a09d5ac92122a931a3f70fafb67d30f064fe0b98..538e1c0fcc2a0f1300b16d188c4263251c351bac 100644
--- a/data_share/frameworks/native/common/include/idata_share_service.h
+++ b/data_share/frameworks/native/common/include/idata_share_service.h
@@ -19,7 +19,7 @@
 #include <string>
 
 #include "iremote_broker.h"
-
+#include "datashare_errno.h"
 #include "data_proxy_observer.h"
 #include "datashare_business_error.h"
 #include "datashare_predicates.h"
@@ -34,19 +34,16 @@ class IDataShareService : public IRemoteBroker {
 public:
     DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.DataShare.IDataShareService");
 
-    enum {
-        DATA_SHARE_ERROR = -1,
-        DATA_SHARE_OK = 0,
-    };
-
-    virtual int Insert(const Uri &uri, const DataShareValuesBucket &value) = 0;
+    virtual int Insert(const Uri &uri, const Uri &extUri, const DataShareValuesBucket &value) = 0;
 
-    virtual int Update(const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) = 0;
+    virtual int Update(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicates,
+        const DataShareValuesBucket &value) = 0;
 
-    virtual int Delete(const Uri &uri, const DataSharePredicates &predicates) = 0;
+    virtual int Delete(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicates) = 0;
 
-    virtual std::shared_ptr<DataShareResultSet> Query(const Uri &uri, const DataSharePredicates &predicates,
-        std::vector<std::string> &columns, DatashareBusinessError &businessError) = 0;
+    virtual std::shared_ptr<DataShareResultSet> Query(const Uri &uri, const Uri &extUri,
+        const DataSharePredicates &predicates, std::vector<std::string> &columns,
+        DatashareBusinessError &businessError) = 0;
 
     virtual int AddQueryTemplate(const std::string &uri, int64_t subscriberId, Template &tpl) = 0;
 
@@ -91,6 +88,15 @@ public:
 
     virtual int UnRegisterObserver(const Uri &uri,
         const sptr<OHOS::IRemoteObject> &dataObserver) = 0;
+
+    virtual std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const Uri &extUri,
+        const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> UpdateEx(const Uri &uri, const Uri &extUri,
+        const DataSharePredicates &predicates, const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const Uri &extUri,
+        const DataSharePredicates &predicates) = 0;
 };
 } // namespace OHOS::DataShare
 #endif
diff --git a/data_share/frameworks/native/common/include/idatashare.h b/data_share/frameworks/native/common/include/idatashare.h
index eba1512869c2c51a2bee0d4390b49623727fb12d..24ba2bc5816fb4c3064fc8454750f57854829eb2 100644
--- a/data_share/frameworks/native/common/include/idatashare.h
+++ b/data_share/frameworks/native/common/include/idatashare.h
@@ -70,6 +70,13 @@ public:
     virtual Uri DenormalizeUri(const Uri &uri) = 0;
 
     virtual std::vector<std::string> GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter) = 0;
+
+    virtual std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> UpdateEx(
+        const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) = 0;
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/frameworks/native/common/include/ikvstore_data_service.h b/data_share/frameworks/native/common/include/ikvstore_data_service.h
index b18c292ea41ae33b047595bfcbe57bb4a9673dac..9bd0f6b4b96e5f239c8bbc41d908145567c468c2 100644
--- a/data_share/frameworks/native/common/include/ikvstore_data_service.h
+++ b/data_share/frameworks/native/common/include/ikvstore_data_service.h
@@ -19,17 +19,13 @@
 
 #include "iremote_broker.h"
 #include "iremote_proxy.h"
+#include "datashare_errno.h"
 #include "distributeddata_data_share_ipc_interface_code.h"
 
 namespace OHOS {
 namespace DataShare {
 class IKvStoreDataService : public IRemoteBroker {
 public:
-    enum {
-        DATA_SHARE_ERROR = -1,
-        DATA_SHARE_OK = 0,
-    };
-
     virtual sptr<IRemoteObject> GetFeatureInterface(const std::string &name) = 0;
 
     virtual uint32_t RegisterClientDeathObserver(const std::string &appId, sptr<IRemoteObject> observer) = 0;
diff --git a/data_share/frameworks/native/common/src/call_reporter.cpp b/data_share/frameworks/native/common/src/call_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af25b9e67725a1ad5ddd8575369371fbb8cbbd19
--- /dev/null
+++ b/data_share/frameworks/native/common/src/call_reporter.cpp
@@ -0,0 +1,60 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "call_reporter.h"
+
+#include <cinttypes>
+#include "datashare_log.h"
+#include "datashare_string_utils.h"
+
+namespace OHOS {
+namespace DataShare {
+void DataShareCallReporter::Count(const std::string &funcName, const std::string &uri)
+{
+    int overCount = 0;
+    int64_t firstCallTime = 0;
+    callCounts.Compute(funcName, [&overCount, &firstCallTime](auto &key, CallInfo &callInfo) {
+        auto callCount = callInfo.count;
+        if (callCount == 0) {
+            callInfo.firstTime = std::chrono::system_clock::now();
+        }
+        if (++callCount % RESET_COUNT_THRESHOLD == 0) {
+            int64_t first = std::chrono::duration_cast<std::chrono::milliseconds>(
+                callInfo.firstTime.time_since_epoch()).count();
+            int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::system_clock::now().time_since_epoch()).count();
+            ++overCount;
+            firstCallTime = first;
+            if (now - first <= TIME_THRESHOLD.count()) {
+                ++overCount;
+            }
+            callCount = 0;
+        }
+        callInfo.count = callCount;
+        return true;
+    });
+    int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    if (overCount > 0) {
+        LOG_WARN("Call the threshold, func: %{public}s, first:%{public}" PRIi64 "ms, now:%{public}" PRIi64
+            "ms, uri:%{public}s", funcName.c_str(), firstCallTime, now, DataShareStringUtils::Anonymous(uri).c_str());
+    }
+    if (overCount > 1) {
+        LOG_WARN("Call too frequently, func: %{public}s, first:%{public}" PRIi64 "ms, now:%{public}" PRIi64
+            "ms, uri:%{public}s", funcName.c_str(), firstCallTime, now, DataShareStringUtils::Anonymous(uri).c_str());
+    }
+}
+} // namespace DataShare
+} // namespace OHOS
\ No newline at end of file
diff --git a/data_share/frameworks/native/common/src/datashare_block_writer_impl.cpp b/data_share/frameworks/native/common/src/datashare_block_writer_impl.cpp
index 0bd75dce310da3c4aa22fdc734f741b4696a0f9e..c76c1d3bf621ca2ed0922a75bb2671e7d9cd46b2 100644
--- a/data_share/frameworks/native/common/src/datashare_block_writer_impl.cpp
+++ b/data_share/frameworks/native/common/src/datashare_block_writer_impl.cpp
@@ -25,7 +25,12 @@ DataShareBlockWriterImpl::DataShareBlockWriterImpl() : shareBlock_(nullptr)
 DataShareBlockWriterImpl::DataShareBlockWriterImpl(const std::string &name, size_t size)
     : shareBlock_(nullptr)
 {
-    AppDataFwk::SharedBlock::Create(name, size, shareBlock_);
+    AppDataFwk::SharedBlock *shareBlock = nullptr;
+    AppDataFwk::SharedBlock::Create(name, size, shareBlock);
+    if (shareBlock == nullptr) {
+        return;
+    }
+    shareBlock_ = std::shared_ptr<AppDataFwk::SharedBlock>(shareBlock);
 }
 
 DataShareBlockWriterImpl::~DataShareBlockWriterImpl()
@@ -34,75 +39,102 @@ DataShareBlockWriterImpl::~DataShareBlockWriterImpl()
 
 int DataShareBlockWriterImpl::AllocRow()
 {
-    if (shareBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("shareBlock_ is nullptr");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->AllocRow());
+    return ConvertErrorCode(block->AllocRow());
 }
 
 int DataShareBlockWriterImpl::Write(uint32_t column)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("shareBlock_ is nullptr");
+        return E_ERROR;
+    }
     uint32_t currentRowIndex = 0;
     if (!GetCurrentRowIndex(currentRowIndex)) {
         LOG_ERROR("Write null fail");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->PutNull(currentRowIndex, column));
+    return ConvertErrorCode(block->PutNull(currentRowIndex, column));
 }
 
 int DataShareBlockWriterImpl::Write(uint32_t column, int64_t value)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("shareBlock_ is nullptr");
+        return E_ERROR;
+    }
     uint32_t currentRowIndex = 0;
     if (!GetCurrentRowIndex(currentRowIndex)) {
         LOG_ERROR("Write long fail");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->PutLong(currentRowIndex, column, value));
+    return ConvertErrorCode(block->PutLong(currentRowIndex, column, value));
 }
 
 int DataShareBlockWriterImpl::Write(uint32_t column, double value)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("shareBlock_ is nullptr");
+        return E_ERROR;
+    }
     uint32_t currentRowIndex = 0;
     if (!GetCurrentRowIndex(currentRowIndex)) {
         LOG_ERROR("Write double fail");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->PutDouble(currentRowIndex, column, value));
+    return ConvertErrorCode(block->PutDouble(currentRowIndex, column, value));
 }
 
 int DataShareBlockWriterImpl::Write(uint32_t column, const uint8_t *value, size_t size)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("shareBlock_ is nullptr");
+        return E_ERROR;
+    }
     uint32_t currentRowIndex = 0;
     if (!GetCurrentRowIndex(currentRowIndex)) {
         LOG_ERROR("Write blob fail");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->PutBlob(currentRowIndex, column, value, size));
+    return ConvertErrorCode(block->PutBlob(currentRowIndex, column, value, size));
 }
 
 int DataShareBlockWriterImpl::Write(uint32_t column, const char *value, size_t sizeIncludingNull)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("shareBlock_ is nullptr");
+        return E_ERROR;
+    }
     uint32_t currentRowIndex = 0;
     if (!GetCurrentRowIndex(currentRowIndex)) {
         LOG_ERROR("Write string fail");
         return E_ERROR;
     }
-    return ConvertErrorCode(shareBlock_->PutString(currentRowIndex, column, value, sizeIncludingNull));
+    return ConvertErrorCode(block->PutString(currentRowIndex, column, value, sizeIncludingNull));
 }
 
-AppDataFwk::SharedBlock *DataShareBlockWriterImpl::GetBlock() const
+std::shared_ptr<AppDataFwk::SharedBlock> DataShareBlockWriterImpl::GetBlock()
 {
     return shareBlock_;
 }
 
 bool DataShareBlockWriterImpl::GetCurrentRowIndex(uint32_t &rowIndex)
 {
-    if (shareBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("shareBlock_ is nullptr");
         return false;
     }
-    uint32_t rowNum = shareBlock_->GetRowNum();
+    uint32_t rowNum = block->GetRowNum();
     if (rowNum > 0) {
         rowIndex = rowNum - 1;
         return true;
diff --git a/data_share/frameworks/native/common/src/datashare_result_set.cpp b/data_share/frameworks/native/common/src/datashare_result_set.cpp
index d65ecd83050c88ca6a4bba41a047bccf11955e5e..196741830dfc67ea1cf5daa2c7f6781c731515da 100644
--- a/data_share/frameworks/native/common/src/datashare_result_set.cpp
+++ b/data_share/frameworks/native/common/src/datashare_result_set.cpp
@@ -16,6 +16,8 @@
 
 #include <securec.h>
 #include <sstream>
+#include <shared_mutex>
+#include <mutex>
 
 #include "adaptor.h"
 #include "datashare_block_writer_impl.h"
@@ -46,9 +48,6 @@ DataShareResultSet::DataShareResultSet(std::shared_ptr<ResultSetBridge> &bridge)
         return;
     }
     sharedBlock_ = blockWriter_->GetBlock();
-    if (sharedBlock_ == nullptr) {
-        return;
-    }
 }
 
 DataShareResultSet::~DataShareResultSet()
@@ -58,33 +57,37 @@ DataShareResultSet::~DataShareResultSet()
 
 int DataShareResultSet::GetAllColumnNames(std::vector<std::string> &columnNames)
 {
-    if (bridge_ == nullptr) {
+    auto bridge = GetBridge();
+    if (bridge == nullptr) {
         LOG_ERROR("bridge_ is null!");
         return E_ERROR;
     }
-    return bridge_->GetAllColumnNames(columnNames);
+    return bridge->GetAllColumnNames(columnNames);
 }
 
 int DataShareResultSet::GetRowCount(int &count)
 {
-    if (bridge_ == nullptr) {
+    auto bridge = GetBridge();
+    if (bridge == nullptr) {
         LOG_ERROR("bridge_ is null!");
         return E_ERROR;
     }
-    return bridge_->GetRowCount(count);
+    return bridge->GetRowCount(count);
 }
 
 bool DataShareResultSet::OnGo(int startRowIndex, int targetRowIndex, int *cachedIndex)
 {
-    if (bridge_ == nullptr || blockWriter_ == nullptr || sharedBlock_ == nullptr) {
+    auto block = GetBlock();
+    auto bridge = GetBridge();
+    if (bridge == nullptr || blockWriter_ == nullptr || block == nullptr) {
         LOG_ERROR("bridge_ or blockWriter_ or sharedBlock_ is null!");
         return false;
     }
     std::vector<std::string> columnNames;
     GetAllColumnNames(columnNames);
-    sharedBlock_->Clear();
-    sharedBlock_->SetColumnNum(columnNames.size());
-    int result = bridge_->OnGo(startRowIndex, targetRowIndex, *blockWriter_);
+    block->Clear();
+    block->SetColumnNum(columnNames.size());
+    int result = bridge->OnGo(startRowIndex, targetRowIndex, *blockWriter_);
     if (cachedIndex != nullptr) {
         *cachedIndex = result;
     }
@@ -99,20 +102,35 @@ void DataShareResultSet::FillBlock(int startRowIndex, AppDataFwk::SharedBlock *b
     return;
 }
 
+/**
+ * Get current bridge
+ */
+std::shared_ptr<ResultSetBridge> DataShareResultSet::GetBridge()
+{
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    return bridge_;
+}
+
 /**
  * Get current shared block
  */
-AppDataFwk::SharedBlock *DataShareResultSet::GetBlock() const
+std::shared_ptr<AppDataFwk::SharedBlock> DataShareResultSet::GetBlock()
 {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
     return sharedBlock_;
 }
 
 int DataShareResultSet::GetDataType(int columnIndex, DataType &dataType)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("sharedBlock is null!");
+        return E_ERROR;
+    }
     int rowCount = 0;
     GetRowCount(rowCount);
     AppDataFwk::SharedBlock::CellUnit *cellUnit =
-        sharedBlock_->GetCellUnit(static_cast<uint32_t>(rowPos_) - startRowPos_, static_cast<uint32_t>(columnIndex));
+        block->GetCellUnit(static_cast<uint32_t>(rowPos_) - startRowPos_, static_cast<uint32_t>(columnIndex));
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -122,8 +140,9 @@ int DataShareResultSet::GetDataType(int columnIndex, DataType &dataType)
 
 int DataShareResultSet::GoToRow(int position)
 {
-    if (sharedBlock_ == nullptr) {
-        LOG_ERROR("sharedBlock_ is null!");
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("sharedBlock is null!");
         return E_ERROR;
     }
     int rowCnt = 0;
@@ -162,12 +181,17 @@ int DataShareResultSet::GoToRow(int position)
 
 int DataShareResultSet::GetBlob(int columnIndex, std::vector<uint8_t> &value)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("sharedBlock is null!");
+        return E_ERROR;
+    }
     int errorCode = CheckState(columnIndex);
     if (errorCode != E_OK) {
         return errorCode;
     }
 
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -177,7 +201,7 @@ int DataShareResultSet::GetBlob(int columnIndex, std::vector<uint8_t> &value)
     if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_BLOB
         || type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING) {
         size_t size;
-        const auto *blob = static_cast<const uint8_t *>(sharedBlock_->GetCellUnitValueBlob(cellUnit, &size));
+        const auto *blob = static_cast<const uint8_t *>(block->GetCellUnitValueBlob(cellUnit, &size));
         if (size == 0 || blob == nullptr) {
             LOG_WARN("blob data is empty!");
         } else {
@@ -199,18 +223,19 @@ int DataShareResultSet::GetBlob(int columnIndex, std::vector<uint8_t> &value)
 
 int DataShareResultSet::GetString(int columnIndex, std::string &value)
 {
-    if (sharedBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("sharedBlock is null!");
         return E_ERROR;
     }
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
     int type = cellUnit->type;
     if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING) {
         size_t sizeIncludingNull;
-        value = std::string(sharedBlock_->GetCellUnitValueString(cellUnit, &sizeIncludingNull));
+        value = std::string(block->GetCellUnitValueString(cellUnit, &sizeIncludingNull));
         return E_OK;
     } else if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_NULL) {
         return E_OK;
@@ -235,11 +260,12 @@ int DataShareResultSet::GetString(int columnIndex, std::string &value)
 
 int DataShareResultSet::GetInt(int columnIndex, int &value)
 {
-    if (sharedBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("sharedBlock is null!");
         return E_ERROR;
     }
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -249,11 +275,12 @@ int DataShareResultSet::GetInt(int columnIndex, int &value)
 
 int DataShareResultSet::GetLong(int columnIndex, int64_t &value)
 {
-    if (sharedBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("sharedBlock is null!");
         return E_ERROR;
     }
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -265,7 +292,7 @@ int DataShareResultSet::GetLong(int columnIndex, int64_t &value)
         return E_OK;
     } else if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING) {
         size_t sizeIncludingNull;
-        const char *tempValue = sharedBlock_->GetCellUnitValueString(cellUnit, &sizeIncludingNull);
+        const char *tempValue = block->GetCellUnitValueString(cellUnit, &sizeIncludingNull);
         value = ((sizeIncludingNull > 1) && (tempValue != nullptr)) ? long(strtoll(tempValue, nullptr, 0)) : 0L;
         return E_OK;
     } else if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_FLOAT) {
@@ -285,11 +312,16 @@ int DataShareResultSet::GetLong(int columnIndex, int64_t &value)
 
 int DataShareResultSet::GetDouble(int columnIndex, double &value)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("sharedBlock is null!");
+        return E_ERROR;
+    }
     int errorCode = CheckState(columnIndex);
     if (errorCode != E_OK) {
         return errorCode;
     }
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -299,7 +331,7 @@ int DataShareResultSet::GetDouble(int columnIndex, double &value)
         return E_OK;
     } else if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING) {
         size_t sizeIncludingNull;
-        const char *tempValue = sharedBlock_->GetCellUnitValueString(cellUnit, &sizeIncludingNull);
+        const char *tempValue = block->GetCellUnitValueString(cellUnit, &sizeIncludingNull);
         value = ((sizeIncludingNull > 1) && (tempValue != nullptr)) ? strtod(tempValue, nullptr) : 0.0;
         return E_OK;
     } else if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_INTEGER) {
@@ -320,11 +352,16 @@ int DataShareResultSet::GetDouble(int columnIndex, double &value)
 
 int DataShareResultSet::IsColumnNull(int columnIndex, bool &isNull)
 {
+    auto block = GetBlock();
+    if (block == nullptr) {
+        LOG_ERROR("sharedBlock is null!");
+        return E_ERROR;
+    }
     int errorCode = CheckState(columnIndex);
     if (errorCode != E_OK) {
         return errorCode;
     }
-    AppDataFwk::SharedBlock::CellUnit *cellUnit = sharedBlock_->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
+    AppDataFwk::SharedBlock::CellUnit *cellUnit = block->GetCellUnit(rowPos_ - startRowPos_, columnIndex);
     if (!cellUnit) {
         return E_ERROR;
     }
@@ -340,8 +377,7 @@ int DataShareResultSet::Close()
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
     DataShareAbsResultSet::Close();
-    ClosedBlock();
-    bridge_ = nullptr;
+    ClosedBlockAndBridge();
     return E_OK;
 }
 
@@ -350,29 +386,34 @@ int DataShareResultSet::Close()
  */
 void DataShareResultSet::SetBlock(AppDataFwk::SharedBlock *block)
 {
-    if (sharedBlock_ != block) {
-        ClosedBlock();
-        sharedBlock_ = block;
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    if (sharedBlock_ != nullptr) {
+        if (sharedBlock_.get() != block) {
+            sharedBlock_ = std::shared_ptr<AppDataFwk::SharedBlock>(block);
+        }
+    } else {
+        if (block != nullptr) {
+            sharedBlock_ = std::shared_ptr<AppDataFwk::SharedBlock>(block);
+        }
     }
 }
 
 /**
  * Checks whether an {@code DataShareResultSet} object contains shared blocks
  */
-bool DataShareResultSet::HasBlock() const
+bool DataShareResultSet::HasBlock()
 {
-    return sharedBlock_ != nullptr;
+    return GetBlock() != nullptr;
 }
 
 /**
  * Closes a shared block that is not empty in this {@code DataShareResultSet} object
  */
-void DataShareResultSet::ClosedBlock()
+void DataShareResultSet::ClosedBlockAndBridge()
 {
-    if (sharedBlock_ != nullptr) {
-        delete sharedBlock_;
-        sharedBlock_ = nullptr;
-    }
+    std::unique_lock<std::shared_mutex> lock(mutex_);
+    sharedBlock_ = nullptr;
+    bridge_ = nullptr;
 }
 
 void DataShareResultSet::Finalize()
@@ -385,10 +426,6 @@ void DataShareResultSet::Finalize()
  */
 int DataShareResultSet::CheckState(int columnIndex)
 {
-    if (sharedBlock_ == nullptr) {
-        LOG_ERROR("sharedBlock is null!");
-        return E_ERROR;
-    }
     int cnt = 0;
     GetColumnCount(cnt);
     if (columnIndex >= cnt || columnIndex < 0) {
@@ -402,19 +439,24 @@ int DataShareResultSet::CheckState(int columnIndex)
 
 bool DataShareResultSet::Marshalling(MessageParcel &parcel)
 {
-    if (sharedBlock_ == nullptr) {
+    auto block = GetBlock();
+    if (block == nullptr) {
         LOG_ERROR("sharedBlock is null.");
         return false;
     }
-    return sharedBlock_->WriteMessageParcel(parcel);
+    return block->WriteMessageParcel(parcel);
 }
 
 bool DataShareResultSet::Unmarshalling(MessageParcel &parcel)
 {
-    if (sharedBlock_ != nullptr) {
+    auto block = GetBlock();
+    if (block != nullptr) {
+        LOG_ERROR("sharedBlock is not null.");
         return false;
     }
-    int result = AppDataFwk::SharedBlock::ReadMessageParcel(parcel, sharedBlock_);
+    AppDataFwk::SharedBlock *sharedBlock = nullptr;
+    int result = AppDataFwk::SharedBlock::ReadMessageParcel(parcel, sharedBlock);
+    SetBlock(sharedBlock);
     if (result < 0) {
         LOG_ERROR("create from parcel error is %{public}d.", result);
     }
diff --git a/data_share/frameworks/native/common/src/datashare_string_utils.cpp b/data_share/frameworks/native/common/src/datashare_string_utils.cpp
index 94d33047c74b98aa12bf47edd96c987f4c7edd36..604843ff94a72b2c444e6652c57899491297f7cd 100644
--- a/data_share/frameworks/native/common/src/datashare_string_utils.cpp
+++ b/data_share/frameworks/native/common/src/datashare_string_utils.cpp
@@ -14,6 +14,8 @@
  */
 
 #include "datashare_string_utils.h"
+#include <cstdint>
+#include <random>
 
 namespace OHOS {
 namespace DataShare {
@@ -45,6 +47,14 @@ std::string DataShareStringUtils::Change(const std::string &name)
     }
     return DEFAULT_ANONYMOUS + name.substr(ANONYMOUS_SIZE);
 }
+
+int32_t DataShareStringUtils::GetRandomNumber(const int32_t min, const int32_t max)
+{
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dis(min, max);
+    return dis(gen);
+}
 DataShareStringUtils::DataShareStringUtils() {}
 DataShareStringUtils::~DataShareStringUtils() {}
 } // namespace DataShare
diff --git a/data_share/frameworks/native/consumer/controller/common/general_controller.h b/data_share/frameworks/native/consumer/controller/common/general_controller.h
index c8f7ee857073d836dbdb3fc64fee7fed92d2a014..3a1f6fd7a3ce8a1c28fe757994c6d8eb7d8feb00 100644
--- a/data_share/frameworks/native/consumer/controller/common/general_controller.h
+++ b/data_share/frameworks/native/consumer/controller/common/general_controller.h
@@ -20,6 +20,7 @@
 #include <string_ex.h>
 
 #include "datashare_business_error.h"
+#include "datashare_errno.h"
 #include "datashare_predicates.h"
 #include "datashare_result_set.h"
 #include "datashare_values_bucket.h"
@@ -49,6 +50,13 @@ public:
     virtual void UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver) = 0;
 
     virtual void NotifyChange(const Uri &uri) = 0;
+
+    virtual std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> UpdateEx(
+        const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) = 0;
+
+    virtual std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) = 0;
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/frameworks/native/consumer/controller/provider/include/general_controller_provider_impl.h b/data_share/frameworks/native/consumer/controller/provider/include/general_controller_provider_impl.h
index 1f75d74ce09037eb87a8199879b6ec5e19506348..e6c5c93166aa3974612df14e8772ddce097b4170 100644
--- a/data_share/frameworks/native/consumer/controller/provider/include/general_controller_provider_impl.h
+++ b/data_share/frameworks/native/consumer/controller/provider/include/general_controller_provider_impl.h
@@ -46,6 +46,14 @@ public:
     void UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver) override;
 
     void NotifyChange(const Uri &uri) override;
+
+    std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> UpdateEx(
+        const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) override;
+
 private:
     std::shared_ptr<DataShareConnection> connection_ = nullptr;
     sptr<IRemoteObject> token_ = {};
diff --git a/data_share/frameworks/native/consumer/controller/provider/src/general_controller_provider_impl.cpp b/data_share/frameworks/native/consumer/controller/provider/src/general_controller_provider_impl.cpp
index e7b1c812693888b2dc1aa8f17dc108922f8a006f..6c3420f4c2ef8fd2ab522f29a5217b35445d423e 100644
--- a/data_share/frameworks/native/consumer/controller/provider/src/general_controller_provider_impl.cpp
+++ b/data_share/frameworks/native/consumer/controller/provider/src/general_controller_provider_impl.cpp
@@ -20,18 +20,17 @@
 
 namespace OHOS {
 namespace DataShare {
-constexpr int INVALID_VALUE = -1;
 int GeneralControllerProviderImpl::Insert(const Uri &uri, const DataShareValuesBucket &value)
 {
     auto connection = connection_;
     if (connection == nullptr) {
         LOG_ERROR("connection is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     auto proxy = connection->GetDataShareProxy(uri_, token_);
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return proxy->Insert(uri, value);
 }
@@ -42,12 +41,12 @@ int GeneralControllerProviderImpl::Update(const Uri &uri, const DataSharePredica
     auto connection = connection_;
     if (connection == nullptr) {
         LOG_ERROR("connection is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     auto proxy = connection->GetDataShareProxy(uri_, token_);
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return proxy->Update(uri, predicates, value);
 }
@@ -57,16 +56,64 @@ int GeneralControllerProviderImpl::Delete(const Uri &uri, const DataSharePredica
     auto connection = connection_;
     if (connection == nullptr) {
         LOG_ERROR("connection is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     auto proxy = connection->GetDataShareProxy(uri_, token_);
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return proxy->Delete(uri, predicates);
 }
 
+std::pair<int32_t, int32_t> GeneralControllerProviderImpl::InsertEx(const Uri &uri,
+    const DataShareValuesBucket &value)
+{
+    auto connection = connection_;
+    if (connection == nullptr) {
+        LOG_ERROR("connection is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto proxy = connection->GetDataShareProxy(uri_, token_);
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    return proxy->InsertEx(uri, value);
+}
+
+std::pair<int32_t, int32_t> GeneralControllerProviderImpl::UpdateEx(
+    const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value)
+{
+    auto connection = connection_;
+    if (connection == nullptr) {
+        LOG_ERROR("connection is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto proxy = connection->GetDataShareProxy(uri_, token_);
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    return proxy->UpdateEx(uri, predicates, value);
+}
+
+std::pair<int32_t, int32_t> GeneralControllerProviderImpl::DeleteEx(const Uri &uri,
+    const DataSharePredicates &predicates)
+{
+    auto connection = connection_;
+    if (connection == nullptr) {
+        LOG_ERROR("connection is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto proxy = connection->GetDataShareProxy(uri_, token_);
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    return proxy->DeleteEx(uri, predicates);
+}
+
 std::shared_ptr<DataShareResultSet> GeneralControllerProviderImpl::Query(const Uri &uri,
     const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
 {
diff --git a/data_share/frameworks/native/consumer/controller/service/include/general_controller_service_impl.h b/data_share/frameworks/native/consumer/controller/service/include/general_controller_service_impl.h
index 6d3ac96934263d9fd693fe2c2988e62156d4e3b0..a6d26e32f0786aba483df28569e433bfe77f2295 100644
--- a/data_share/frameworks/native/consumer/controller/service/include/general_controller_service_impl.h
+++ b/data_share/frameworks/native/consumer/controller/service/include/general_controller_service_impl.h
@@ -31,7 +31,7 @@ class IDataAbilityObserver;
 namespace DataShare {
 class GeneralControllerServiceImpl : public GeneralController {
 public:
-    GeneralControllerServiceImpl() = default;
+    GeneralControllerServiceImpl(const std::string &ext);
 
     virtual ~GeneralControllerServiceImpl();
 
@@ -49,12 +49,28 @@ public:
     void UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver) override;
 
     void NotifyChange(const Uri &uri) override;
+
+    std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> UpdateEx(
+        const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) override;
+
 private:
     void ReRegisterObserver();
 
     void SetRegisterCallback();
 
     ConcurrentMap<sptr<AAFwk::IDataAbilityObserver>, std::list<Uri>> observers_;
+
+    std::string extUri_;
+
+    static constexpr int MAX_RETRY_COUNT = 3;
+
+    static constexpr int RANDOM_MIN = 50;
+
+    static constexpr int RANDOM_MAX = 150;
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/frameworks/native/consumer/controller/service/src/general_controller_service_impl.cpp b/data_share/frameworks/native/consumer/controller/service/src/general_controller_service_impl.cpp
index 4605e9595a7f5f4793be0acd64d4a63d38ce2108..fa26bc1a58a6e2812be3b9e60797462ccb8a0c73 100644
--- a/data_share/frameworks/native/consumer/controller/service/src/general_controller_service_impl.cpp
+++ b/data_share/frameworks/native/consumer/controller/service/src/general_controller_service_impl.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "general_controller_service_impl.h"
+#include <thread>
 
 #include "dataobs_mgr_client.h"
 #include "dataobs_mgr_errors.h"
@@ -22,7 +23,11 @@
 
 namespace OHOS {
 namespace DataShare {
-constexpr int INVALID_VALUE = -1;
+GeneralControllerServiceImpl::GeneralControllerServiceImpl(const std::string &ext)
+{
+    extUri_ = ext;
+}
+
 GeneralControllerServiceImpl::~GeneralControllerServiceImpl()
 {
     auto manager = DataShareManagerImpl::GetInstance();
@@ -31,49 +36,137 @@ GeneralControllerServiceImpl::~GeneralControllerServiceImpl()
 
 int GeneralControllerServiceImpl::Insert(const Uri &uri, const DataShareValuesBucket &value)
 {
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return DATA_SHARE_ERROR;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     auto proxy = DataShareManagerImpl::GetServiceProxy();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
-    return proxy->Insert(uri, value);
+    return proxy->Insert(uri, Uri(extUri_), value);
 }
 
 int GeneralControllerServiceImpl::Update(const Uri &uri, const DataSharePredicates &predicates,
     const DataShareValuesBucket &value)
 {
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return DATA_SHARE_ERROR;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     auto proxy = DataShareManagerImpl::GetServiceProxy();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
-    return proxy->Update(uri, predicates, value);
+    return proxy->Update(uri, Uri(extUri_), predicates, value);
 }
 
 int GeneralControllerServiceImpl::Delete(const Uri &uri, const DataSharePredicates &predicates)
 {
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return DATA_SHARE_ERROR;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
+    auto proxy = DataShareManagerImpl::GetServiceProxy();
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return DATA_SHARE_ERROR;
+    }
+    return proxy->Delete(uri, Uri(extUri_), predicates);
+}
+
+std::pair<int32_t, int32_t> GeneralControllerServiceImpl::InsertEx(const Uri &uri, const DataShareValuesBucket &value)
+{
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     auto proxy = DataShareManagerImpl::GetServiceProxy();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return std::make_pair(DATA_SHARE_ERROR, 0);
     }
-    return proxy->Delete(uri, predicates);
+    return proxy->InsertEx(uri, Uri(extUri_), value);
+}
+
+std::pair<int32_t, int32_t> GeneralControllerServiceImpl::UpdateEx(
+    const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value)
+{
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
+    auto proxy = DataShareManagerImpl::GetServiceProxy();
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    return proxy->UpdateEx(uri, Uri(extUri_), predicates, value);
+}
+
+std::pair<int32_t, int32_t> GeneralControllerServiceImpl::DeleteEx(const Uri &uri,
+    const DataSharePredicates &predicates)
+{
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
+    auto proxy = DataShareManagerImpl::GetServiceProxy();
+    if (proxy == nullptr) {
+        LOG_ERROR("proxy is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    return proxy->DeleteEx(uri, Uri(extUri_), predicates);
 }
 
 std::shared_ptr<DataShareResultSet> GeneralControllerServiceImpl::Query(const Uri &uri,
     const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
 {
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return nullptr;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     auto proxy = DataShareManagerImpl::GetServiceProxy();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
         return nullptr;
     }
-    return proxy->Query(uri, predicates, columns, businessError);
+    auto resultSet = proxy->Query(uri, Uri(extUri_), predicates, columns, businessError);
+    int retryCount = 0;
+    while (resultSet == nullptr && businessError.GetCode() == E_RESULTSET_BUSY && retryCount++ < MAX_RETRY_COUNT) {
+        LOG_ERROR("resultSet busy retry, uri: %{public}s", DataShareStringUtils::Anonymous(uri.ToString()).c_str());
+        std::this_thread::sleep_for(std::chrono::milliseconds(
+            DataShareStringUtils::GetRandomNumber(RANDOM_MIN, RANDOM_MAX)));
+        resultSet = proxy->Query(uri, Uri(extUri_), predicates, columns, businessError);
+    }
+    return resultSet;
 }
 
 void GeneralControllerServiceImpl::RegisterObserver(const Uri &uri,
     const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
 {
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     auto obsMgrClient = OHOS::AAFwk::DataObsMgrClient::GetInstance();
     if (obsMgrClient == nullptr) {
         LOG_ERROR("get DataObsMgrClient failed");
diff --git a/data_share/frameworks/native/consumer/include/datashare_connection.h b/data_share/frameworks/native/consumer/include/datashare_connection.h
index 7326345cd921776ae9b13d6cb5525ce9dfc6721e..6e1fa9965c1b9e57e76517f4cd32ef3adce0f05f 100644
--- a/data_share/frameworks/native/consumer/include/datashare_connection.h
+++ b/data_share/frameworks/native/consumer/include/datashare_connection.h
@@ -23,14 +23,17 @@
 #include "ability_connect_callback_stub.h"
 #include "datashare_proxy.h"
 #include "event_handler.h"
+#include "executor_pool.h"
 #include "want.h"
 
 namespace OHOS {
 namespace DataShare {
 using namespace AppExecFwk;
-class DataShareConnection : public AAFwk::AbilityConnectionStub {
+class DataShareConnection : public AAFwk::AbilityConnectionStub,
+    public std::enable_shared_from_this<DataShareConnection> {
 public:
-    DataShareConnection(const Uri &uri, const sptr<IRemoteObject> &token) : uri_(uri), token_(token) {}
+    DataShareConnection(const Uri &uri, const sptr<IRemoteObject> &token, int32_t waitTime = 2) : uri_(uri),
+        token_(token), waitTime_(waitTime) {}
     virtual ~DataShareConnection();
 
     /**
@@ -71,18 +74,34 @@ public:
     void SetConnectInvalid();
 
 private:
+    struct DataShareConnectionInfo {
+        int count = 0;
+        int64_t firstTime = 0;
+        int64_t prevTime = 0;
+    };
     struct ConnectCondition {
         std::condition_variable condition;
         std::mutex mutex;
     };
     std::shared_ptr<DataShareProxy> ConnectDataShareExtAbility(const Uri &uri, const sptr<IRemoteObject> &token);
+    std::shared_ptr<DataShareProxy> GetDataShareProxy();
     ErrCode Disconnect();
+    void ReconnectExtAbility(const std::string &uri);
+    void DelayConnectExtAbility(const std::string &uri);
     std::mutex mutex_{};
     std::shared_ptr<DataShareProxy> dataShareProxy_;
     ConnectCondition condition_;
     Uri uri_;
     sptr<IRemoteObject> token_ = {};
     std::atomic<bool> isInvalid_ = false;
+    static constexpr int MAX_THREADS = 2;
+    static constexpr int MIN_THREADS = 0;
+    static constexpr int MAX_RECONNECT = 6;
+    static constexpr std::chrono::milliseconds RECONNECT_TIME_INTERVAL = std::chrono::milliseconds(10000);
+    static constexpr std::chrono::milliseconds MAX_RECONNECT_TIME_INTERVAL = std::chrono::milliseconds(70000);
+    std::shared_ptr<ExecutorPool> pool_;
+    DataShareConnectionInfo reConnects_;
+    int32_t waitTime_ = 0;
 };
 }  // namespace DataShare
 }  // namespace OHOS
diff --git a/data_share/frameworks/native/consumer/include/datashare_helper_impl.h b/data_share/frameworks/native/consumer/include/datashare_helper_impl.h
index 6bd3aac2bc376f992d4588f531b115fa4d33e632..d71e4c1ccc30e3c5da88c175813d0561ed8568fa 100644
--- a/data_share/frameworks/native/consumer/include/datashare_helper_impl.h
+++ b/data_share/frameworks/native/consumer/include/datashare_helper_impl.h
@@ -27,7 +27,7 @@ class DataShareHelperImpl : public DataShareHelper {
 public:
     DataShareHelperImpl(const Uri &uri, const sptr<IRemoteObject> &token,
         std::shared_ptr<DataShareConnection> connection);
-    DataShareHelperImpl();
+    DataShareHelperImpl(std::string extUri = "");
 
     ~DataShareHelperImpl() override;
 
@@ -98,6 +98,13 @@ public:
 
     std::vector<OperationResult> DisablePubSubs(const std::vector<std::string> &uris, int64_t subscriberId) override;
 
+    std::pair<int32_t, int32_t> InsertEx(Uri &uri, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> UpdateEx(
+        Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> DeleteEx(Uri &uri, const DataSharePredicates &predicates) override;
+
 private:
     std::shared_ptr<ExtSpecialController> extSpCtl_ = nullptr;
     std::shared_ptr<GeneralController> generalCtl_ = nullptr;
diff --git a/data_share/frameworks/native/consumer/include/datashare_proxy.h b/data_share/frameworks/native/consumer/include/datashare_proxy.h
index ee79de3b974527a8141056a1a36a3b632cc41188..7c5fad2af42ca21aa675e45d36832d73c929df97 100644
--- a/data_share/frameworks/native/consumer/include/datashare_proxy.h
+++ b/data_share/frameworks/native/consumer/include/datashare_proxy.h
@@ -65,6 +65,13 @@ public:
 
     virtual Uri DenormalizeUri(const Uri &uri) override;
 
+    virtual std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) override;
+
+    virtual std::pair<int32_t, int32_t> UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+        const DataShareValuesBucket &value) override;
+
+    virtual std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) override;
+
 private:
     bool CheckSize(const UpdateOperations &operations);
     static inline BrokerDelegator<DataShareProxy> delegator_;
diff --git a/data_share/frameworks/native/consumer/src/datashare_connection.cpp b/data_share/frameworks/native/consumer/src/datashare_connection.cpp
index 55d8efba6d96d737f89bf07960fd47be2eccac86..84f2953365951dd9ced043705044ffd584dd6adc 100644
--- a/data_share/frameworks/native/consumer/src/datashare_connection.cpp
+++ b/data_share/frameworks/native/consumer/src/datashare_connection.cpp
@@ -25,7 +25,6 @@
 namespace OHOS {
 namespace DataShare {
 using namespace AppExecFwk;
-constexpr int WAIT_TIME = 2;
 /**
  * @brief This method is called back to receive the connection result after an ability calls the
  * ConnectAbility method to connect it to an extension ability.
@@ -83,14 +82,78 @@ void DataShareConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName
     if (uri.empty()) {
         return;
     }
-    AmsMgrProxy* instance = AmsMgrProxy::GetInstance();
-    if (instance == nullptr) {
-        LOG_ERROR("get proxy failed uri:%{public}s", DataShareStringUtils::Change(uri_.ToString()).c_str());
+    if (pool_ == nullptr) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (pool_ == nullptr) {
+            pool_ = std::make_shared<ExecutorPool>(MAX_THREADS, MIN_THREADS);
+        }
+    }
+    ReconnectExtAbility(uri);
+}
+
+void DataShareConnection::ReconnectExtAbility(const std::string &uri)
+{
+    if (reConnects_.count == 0) {
+        AmsMgrProxy* instance = AmsMgrProxy::GetInstance();
+        if (instance == nullptr) {
+            LOG_ERROR("get proxy failed uri:%{public}s", DataShareStringUtils::Change(uri_.ToString()).c_str());
+            return;
+        }
+        ErrCode ret = instance->Connect(uri, this, token_);
+        LOG_INFO("reconnect ability, uri:%{public}s, ret = %{public}d",
+            DataShareStringUtils::Change(uri).c_str(), ret);
+        if (ret == E_OK) {
+            auto curr = std::chrono::system_clock::now().time_since_epoch();
+            reConnects_.count = 1;
+            reConnects_.firstTime = std::chrono::duration_cast<std::chrono::milliseconds>(curr).count();
+            reConnects_.prevTime = std::chrono::duration_cast<std::chrono::milliseconds>(curr).count();
+        }
+        return;
+    }
+    return DelayConnectExtAbility(uri);
+}
+
+void DataShareConnection::DelayConnectExtAbility(const std::string &uri)
+{
+    int64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+    if (now - reConnects_.prevTime >= MAX_RECONNECT_TIME_INTERVAL.count()) {
+        reConnects_.count = 0;
+        reConnects_.firstTime = now;
+        reConnects_.prevTime = now;
+    }
+    if (reConnects_.count >= MAX_RECONNECT) {
         return;
     }
-    ErrCode ret = instance->Connect(uri, this, token_);
-    LOG_INFO("reconnect ability, uri:%{public}s, ret = %{public}d",
-        DataShareStringUtils::Change(uri_.ToString()).c_str(), ret);
+    auto delay = RECONNECT_TIME_INTERVAL;
+    if (now - reConnects_.prevTime >= RECONNECT_TIME_INTERVAL.count()) {
+        delay = std::chrono::seconds(0);
+    }
+    std::weak_ptr<DataShareConnection> self = weak_from_this();
+    auto taskid = pool_->Schedule(delay, [uri, self]() {
+        auto selfSharedPtr = self.lock();
+        if (selfSharedPtr) {
+            AmsMgrProxy* instance = AmsMgrProxy::GetInstance();
+            if (instance == nullptr) {
+                LOG_ERROR("get proxy failed uri:%{public}s", DataShareStringUtils::Change(uri).c_str());
+                return;
+            }
+            ErrCode ret = instance->Connect(uri, selfSharedPtr.get(), selfSharedPtr->token_);
+            LOG_INFO("reconnect ability, uri:%{public}s, ret = %{public}d",
+                DataShareStringUtils::Change(uri).c_str(), ret);
+            if (ret == E_OK) {
+                selfSharedPtr->reConnects_.count++;
+                selfSharedPtr->reConnects_.prevTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+                    std::chrono::system_clock::now().time_since_epoch()).count();
+            }
+        }
+    });
+    if (taskid == ExecutorPool::INVALID_TASK_ID) {
+        LOG_ERROR("create scheduler failed, over the max capacity");
+        return;
+    }
+    LOG_DEBUG("create scheduler success");
+    return;
 }
 
 /**
@@ -119,22 +182,22 @@ std::shared_ptr<DataShareProxy> DataShareConnection::ConnectDataShareExtAbility(
         return nullptr;
     }
     std::unique_lock<std::mutex> condLock(condition_.mutex);
-    if (condition_.condition.wait_for(condLock, std::chrono::seconds(WAIT_TIME),
+    if (condition_.condition.wait_for(condLock, std::chrono::seconds(waitTime_),
         [this] { return dataShareProxy_ != nullptr; })) {
         LOG_DEBUG("connect ability ended successfully uri:%{public}s", DataShareStringUtils::Change(reqUri).c_str());
         RADAR_REPORT(__FUNCTION__, RadarReporter::CREATE_DATASHARE_HELPER,
             RadarReporter::CONNECT_EXT, RadarReporter::SUCCESS,
             RadarReporter::LOCAL_SESS_NAME, Str16ToStr8(token->GetObjectDescriptor()),
-            RadarReporter::PEER_SESS_NAME, reqUri);
+            RadarReporter::PEER_SESS_NAME, DataShareStringUtils::Change(reqUri));
     } else {
         LOG_WARN("connect timeout uri:%{public}s", DataShareStringUtils::Change(reqUri).c_str());
         RADAR_REPORT(__FUNCTION__, RadarReporter::CREATE_DATASHARE_HELPER,
             RadarReporter::CONNECT_EXT, RadarReporter::FAILED,
             RadarReporter::ERROR_CODE, RadarReporter::EXT_CONNECT_TIMEOUT_ERROR,
             RadarReporter::LOCAL_SESS_NAME, Str16ToStr8(token->GetObjectDescriptor()),
-            RadarReporter::PEER_SESS_NAME, reqUri);
+            RadarReporter::PEER_SESS_NAME, DataShareStringUtils::Change(reqUri));
     }
-    return dataShareProxy_;
+    return GetDataShareProxy();
 }
 
 /**
@@ -158,14 +221,14 @@ void DataShareConnection::DisconnectDataShareExtAbility()
         RADAR_REPORT(__FUNCTION__, RadarReporter::CREATE_DATASHARE_HELPER,
             RadarReporter::DIS_CONNECT_EXT, RadarReporter::SUCCESS,
             RadarReporter::LOCAL_SESS_NAME, Str16ToStr8(token_->GetObjectDescriptor()),
-            RadarReporter::PEER_SESS_NAME, uri);
+            RadarReporter::PEER_SESS_NAME, DataShareStringUtils::Change(uri));
         return;
     }
     RADAR_REPORT(__FUNCTION__, RadarReporter::CREATE_DATASHARE_HELPER,
         RadarReporter::DIS_CONNECT_EXT, RadarReporter::FAILED,
         RadarReporter::ERROR_CODE, RadarReporter::EXT_DIS_CONNECT_ERROR,
         RadarReporter::LOCAL_SESS_NAME, Str16ToStr8(token_->GetObjectDescriptor()),
-        RadarReporter::PEER_SESS_NAME, uri);
+        RadarReporter::PEER_SESS_NAME, DataShareStringUtils::Change(uri));
 }
 
 DataShareConnection::~DataShareConnection()
@@ -191,5 +254,11 @@ ErrCode DataShareConnection::Disconnect()
     }
     return instance->DisConnect(this);
 }
+
+std::shared_ptr<DataShareProxy> DataShareConnection::GetDataShareProxy()
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    return dataShareProxy_;
+}
 }  // namespace DataShare
 }  // namespace OHOS
\ No newline at end of file
diff --git a/data_share/frameworks/native/consumer/src/datashare_helper.cpp b/data_share/frameworks/native/consumer/src/datashare_helper.cpp
index 1fed4972386d5c1bedce55b17eaa308bea783959..7f11998b2172e19910862480751c021fe492466b 100644
--- a/data_share/frameworks/native/consumer/src/datashare_helper.cpp
+++ b/data_share/frameworks/native/consumer/src/datashare_helper.cpp
@@ -24,7 +24,6 @@
 #include "dataobs_mgr_client.h"
 #include "datashare_errno.h"
 #include "datashare_log.h"
-#include "datashare_radar_reporter.h"
 #include "datashare_string_utils.h"
 
 namespace OHOS {
@@ -34,7 +33,6 @@ namespace {
 static constexpr const char *DATA_SHARE_PREFIX = "datashare:///";
 static constexpr const char *FILE_PREFIX = "file://";
 } // namespace
-constexpr int INVALID_VALUE = -1;
 class ObserverImpl : public AAFwk::DataAbilityObserverStub {
 public:
     explicit ObserverImpl(const std::shared_ptr<DataShareObserver> dataShareObserver)
@@ -77,13 +75,10 @@ std::string DataShareHelper::TransferUriPrefix(const std::string &originPrefix,
  * @return Returns the created DataShareHelper instance.
  */
 std::shared_ptr<DataShareHelper> DataShareHelper::Creator(
-    const sptr<IRemoteObject> &token, const std::string &strUri, const std::string &extUri)
+    const sptr<IRemoteObject> &token, const std::string &strUri, const std::string &extUri, const int waitTime)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
-    RadarReporter::RadarReport report(RadarReporter::CREATE_DATASHARE_HELPER,
-        RadarReporter::CREATE_HELPER, __FUNCTION__);
     if (token == nullptr) {
-        report.SetError(RadarReporter::INVALID_PARAM_ERROR);
         LOG_ERROR("token == nullptr");
         return nullptr;
     }
@@ -92,12 +87,11 @@ std::shared_ptr<DataShareHelper> DataShareHelper::Creator(
     Uri uri(replacedUriStr);
     std::shared_ptr<DataShareHelper> helper = nullptr;
     if (uri.GetQuery().find("Proxy=true") != std::string::npos) {
-        auto result = CreateServiceHelper();
+        auto result = CreateServiceHelper(extUri, "");
         if (result != nullptr && GetSilentProxyStatus(strUri) == E_OK) {
             return result;
         }
         if (extUri.empty()) {
-            report.SetError(RadarReporter::INVALID_PARAM_ERROR);
             return nullptr;
         }
         Uri ext(extUri);
@@ -105,55 +99,44 @@ std::shared_ptr<DataShareHelper> DataShareHelper::Creator(
     } else {
         helper = CreateExtHelper(uri, token);
     }
-    if (helper == nullptr) {
-        report.SetError(RadarReporter::CREATE_HELPER_ERROR);
-    }
     return helper;
 }
 
 std::shared_ptr<DataShareHelper> DataShareHelper::Creator(const string &strUri, const CreateOptions &options,
-    const std::string &bundleName)
+    const std::string &bundleName, const int waitTime)
 {
-    RadarReporter::RadarReport report(RadarReporter::CREATE_DATASHARE_HELPER,
-        RadarReporter::CREATE_HELPER, __FUNCTION__);
     DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
     Uri uri(strUri);
     if (!options.isProxy_ && options.token_ == nullptr) {
         LOG_ERROR("token is nullptr");
-        report.SetError(RadarReporter::INVALID_PARAM_ERROR);
         return nullptr;
     }
-    auto helper = options.isProxy_ ? CreateServiceHelper(bundleName) : CreateExtHelper(uri, options.token_);
-    if (helper == nullptr) {
-        report.SetError(RadarReporter::CREATE_HELPER_ERROR);
-    }
-    return helper;
+    return options.isProxy_ ? CreateServiceHelper("", bundleName) : CreateExtHelper(uri, options.token_);
 }
 
 std::pair<int, std::shared_ptr<DataShareHelper>> DataShareHelper::Create(const sptr<IRemoteObject> &token,
-    const std::string &strUri, const std::string &extUri)
+    const std::string &strUri, const std::string &extUri, const int waitTime)
 {
-    RadarReporter::RadarReport report(RadarReporter::CREATE_DATASHARE_HELPER,
-        RadarReporter::CREATE_HELPER, __FUNCTION__);
     DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
     if (token == nullptr) {
         LOG_ERROR("Create helper failed, err: %{public}d", E_TOKEN_EMPTY);
-        report.SetError(RadarReporter::INVALID_PARAM_ERROR);
         return std::make_pair(E_TOKEN_EMPTY, nullptr);
     }
     Uri uri(strUri);
     if (IsProxy(uri)) {
-        auto [ret, helper] = CreateProxyHelper(strUri);
+        auto [ret, helper] = CreateProxyHelper(strUri, extUri);
         if (helper != nullptr) {
             return std::make_pair(E_OK, helper);
         }
         if (ret == E_BMS_NOT_READY) {
-            report.SetError(RadarReporter::GET_BMS_FAILED);
-            LOG_ERROR("BMS not ready, err: %{public}d", E_BMS_NOT_READY);
+            LOG_ERROR("BMS not ready, uri:%{publish}s", DataShareStringUtils::Change(strUri).c_str());
             return std::make_pair(E_DATA_SHARE_NOT_READY, nullptr);
         }
+        if (ret == E_BUNDLE_NAME_NOT_EXIST) {
+            LOG_ERROR("BundleName not exist, uri:%{publish}s", DataShareStringUtils::Change(strUri).c_str());
+            return std::make_pair(E_BUNDLE_NAME_NOT_EXIST, nullptr);
+        }
         if (extUri.empty()) {
-            report.SetError(RadarReporter::INVALID_PARAM_ERROR);
             LOG_ERROR("Ext uri empty, err: %{public}d", E_EXT_URI_INVALID);
             return std::make_pair(E_EXT_URI_INVALID, nullptr);
         }
@@ -163,11 +146,11 @@ std::pair<int, std::shared_ptr<DataShareHelper>> DataShareHelper::Create(const s
     if (helper != nullptr) {
         return std::make_pair(E_OK, helper);
     }
-    report.SetError(RadarReporter::CREATE_HELPER_ERROR);
     return std::make_pair(E_ERROR, nullptr);
 }
 
-std::shared_ptr<DataShareHelper> DataShareHelper::CreateServiceHelper(const std::string &bundleName)
+std::shared_ptr<DataShareHelper> DataShareHelper::CreateServiceHelper(const std::string &extUri,
+    const std::string &bundleName)
 {
     auto manager = DataShareManagerImpl::GetInstance();
     if (manager == nullptr) {
@@ -179,7 +162,7 @@ std::shared_ptr<DataShareHelper> DataShareHelper::CreateServiceHelper(const std:
         LOG_ERROR("Service proxy is nullptr.");
         return nullptr;
     }
-    return std::make_shared<DataShareHelperImpl>();
+    return std::make_shared<DataShareHelperImpl>(extUri);
 }
 
 int DataShareHelper::GetSilentProxyStatus(const std::string &uri)
@@ -192,9 +175,10 @@ int DataShareHelper::GetSilentProxyStatus(const std::string &uri)
     return proxy->GetSilentProxyStatus(uri);
 }
 
-std::shared_ptr<DataShareHelper> DataShareHelper::CreateExtHelper(Uri &uri, const sptr<IRemoteObject> &token)
+std::shared_ptr<DataShareHelper> DataShareHelper::CreateExtHelper(Uri &uri, const sptr<IRemoteObject> &token,
+    const int waitTime)
 {
-    sptr<DataShareConnection> connection = new (std::nothrow) DataShareConnection(uri, token);
+    sptr<DataShareConnection> connection = new (std::nothrow) DataShareConnection(uri, token, waitTime);
     if (connection == nullptr) {
         LOG_ERROR("Create DataShareConnection failed.");
         return nullptr;
@@ -204,6 +188,12 @@ std::shared_ptr<DataShareHelper> DataShareHelper::CreateExtHelper(Uri &uri, cons
             holder->SetConnectInvalid();
             holder->DisconnectDataShareExtAbility();
         });
+    auto manager = DataShareManagerImpl::GetInstance();
+    if (manager == nullptr) {
+        LOG_ERROR("Manager is nullptr");
+        return nullptr;
+    }
+    manager->SetCallCount(__FUNCTION__, uri.ToString());
     if (dataShareConnection->GetDataShareProxy(uri, token) == nullptr) {
         LOG_ERROR("connect failed");
         return nullptr;
@@ -374,7 +364,7 @@ int DataShareHelper::SetSilentSwitch(Uri &uri, bool enable)
     auto proxy = DataShareManagerImpl::GetServiceProxy();
     if (proxy == nullptr) {
         LOG_ERROR("proxy is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return proxy->SetSilentSwitch(uri, enable);
 }
@@ -384,11 +374,29 @@ bool DataShareHelper::IsProxy(Uri &uri)
     return (uri.GetQuery().find("Proxy=true") != std::string::npos || uri.GetScheme() == "datashareproxy");
 }
 
-std::pair<int, std::shared_ptr<DataShareHelper>> DataShareHelper::CreateProxyHelper(const std::string &strUri)
+std::pair<int, std::shared_ptr<DataShareHelper>> DataShareHelper::CreateProxyHelper(const std::string &strUri,
+    const std::string &extUri)
 {
     int ret = GetSilentProxyStatus(strUri);
-    auto helper = ret == E_OK ? CreateServiceHelper() : nullptr;
+    auto helper = ret == E_OK ? CreateServiceHelper(extUri) : nullptr;
     return std::make_pair(ret, helper);
 }
+
+std::pair<int32_t, int32_t> DataShareHelper::InsertEx(Uri &uri, const DataShareValuesBucket &value)
+{
+    return std::make_pair(0, 0);
+}
+
+std::pair<int32_t, int32_t> DataShareHelper::DeleteEx(Uri &uri, const DataSharePredicates &predicates)
+{
+    return std::make_pair(0, 0);
+}
+
+std::pair<int32_t, int32_t> DataShareHelper::UpdateEx(Uri &uri, const DataSharePredicates &predicates,
+    const DataShareValuesBucket &value)
+{
+    return std::make_pair(0, 0);
+}
+
 } // namespace DataShare
 } // namespace OHOS
\ No newline at end of file
diff --git a/data_share/frameworks/native/consumer/src/datashare_helper_impl.cpp b/data_share/frameworks/native/consumer/src/datashare_helper_impl.cpp
index f92398d165b2f6c4ef3c91a074b59e3900c2d211..bbf76e1250fe242ce00ade91699b761d6d411d2b 100644
--- a/data_share/frameworks/native/consumer/src/datashare_helper_impl.cpp
+++ b/data_share/frameworks/native/consumer/src/datashare_helper_impl.cpp
@@ -30,7 +30,6 @@
 namespace OHOS {
 namespace DataShare {
 using namespace AppExecFwk;
-constexpr int INVALID_VALUE = -1;
 DataShareHelperImpl::DataShareHelperImpl(const Uri &uri, const sptr<IRemoteObject> &token,
     std::shared_ptr<DataShareConnection> connection)
 {
@@ -39,10 +38,10 @@ DataShareHelperImpl::DataShareHelperImpl(const Uri &uri, const sptr<IRemoteObjec
     extSpCtl_ = std::make_shared<ExtSpecialController>(connection, uri, token);
 }
 
-DataShareHelperImpl::DataShareHelperImpl()
+DataShareHelperImpl::DataShareHelperImpl(std::string extUri)
 {
     LOG_DEBUG("starts");
-    generalCtl_ = std::make_shared<GeneralControllerServiceImpl>();
+    generalCtl_ = std::make_shared<GeneralControllerServiceImpl>(extUri);
     persistentDataCtl_ = std::make_shared<PersistentDataController>();
     publishedDataCtl_ = std::make_shared<PublishedDataController>();
 }
@@ -77,7 +76,7 @@ int DataShareHelperImpl::OpenFile(Uri &uri, const std::string &mode)
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("extSpCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->OpenFile(uri, mode);
 }
@@ -87,7 +86,7 @@ int DataShareHelperImpl::OpenRawFile(Uri &uri, const std::string &mode)
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("extSpCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->OpenRawFile(uri, mode);
 }
@@ -98,7 +97,7 @@ int DataShareHelperImpl::Insert(Uri &uri, const DataShareValuesBucket &value)
     auto generalCtl = generalCtl_;
     if (generalCtl == nullptr) {
         LOG_ERROR("generalCtl_ is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return generalCtl->Insert(uri, value);
 }
@@ -109,7 +108,7 @@ int DataShareHelperImpl::InsertExt(Uri &uri, const DataShareValuesBucket &value,
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("providerSpCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->InsertExt(uri, value, result);
 }
@@ -120,7 +119,7 @@ int DataShareHelperImpl::Update(Uri &uri, const DataSharePredicates &predicates,
     auto generalCtl = generalCtl_;
     if (generalCtl == nullptr) {
         LOG_ERROR("generalCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return generalCtl->Update(uri, predicates, value);
 }
@@ -130,7 +129,7 @@ int DataShareHelperImpl::BatchUpdate(const UpdateOperations &operations, std::ve
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("extSpCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->BatchUpdate(operations, results);
 }
@@ -141,11 +140,57 @@ int DataShareHelperImpl::Delete(Uri &uri, const DataSharePredicates &predicates)
     auto generalCtl = generalCtl_;
     if (generalCtl == nullptr) {
         LOG_ERROR("generalCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return generalCtl->Delete(uri, predicates);
 }
 
+std::pair<int32_t, int32_t> DataShareHelperImpl::InsertEx(Uri &uri, const DataShareValuesBucket &value)
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
+    auto generalCtl = generalCtl_;
+    if (generalCtl == nullptr) {
+        LOG_ERROR("generalCtl_ is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto [errCode, status] = generalCtl->InsertEx(uri, value);
+    if (errCode != E_OK) {
+        LOG_ERROR("generalCtl insert failed, errCode = %{public}d", errCode);
+    }
+    return std::make_pair(errCode, status);
+}
+
+std::pair<int32_t, int32_t> DataShareHelperImpl::UpdateEx(
+    Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value)
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
+    auto generalCtl = generalCtl_;
+    if (generalCtl == nullptr) {
+        LOG_ERROR("generalCtl is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto [errCode, status] = generalCtl->UpdateEx(uri, predicates, value);
+    if (errCode != E_OK) {
+        LOG_ERROR("generalCtl update failed, errCode = %{public}d", errCode);
+    }
+    return std::make_pair(errCode, status);
+}
+
+std::pair<int32_t, int32_t> DataShareHelperImpl::DeleteEx(Uri &uri, const DataSharePredicates &predicates)
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__));
+    auto generalCtl = generalCtl_;
+    if (generalCtl == nullptr) {
+        LOG_ERROR("generalCtl is nullptr");
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+    auto [errCode, status] = generalCtl->DeleteEx(uri, predicates);
+    if (errCode != E_OK) {
+        LOG_ERROR("generalCtl delete failed, errCode = %{public}d", errCode);
+    }
+    return std::make_pair(errCode, status);
+}
+
 std::shared_ptr<DataShareResultSet> DataShareHelperImpl::Query(Uri &uri, const DataSharePredicates &predicates,
     std::vector<std::string> &columns, DatashareBusinessError *businessError)
 {
@@ -179,7 +224,7 @@ int DataShareHelperImpl::BatchInsert(Uri &uri, const std::vector<DataShareValues
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("providerSepOperator is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->BatchInsert(uri, values);
 }
@@ -189,7 +234,7 @@ int DataShareHelperImpl::ExecuteBatch(const std::vector<OperationStatement> &sta
     auto extSpCtl = extSpCtl_;
     if (extSpCtl == nullptr) {
         LOG_ERROR("extSpCtl is nullptr");
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return extSpCtl->ExecuteBatch(statements, result);
 }
@@ -271,7 +316,7 @@ int DataShareHelperImpl::AddQueryTemplate(const std::string &uri, int64_t subscr
     if (persistentDataCtl == nullptr) {
         LOG_ERROR("persistentDataCtl is nullptr");
         report.SetError(RadarReporter::DATA_SHARE_DIED_ERROR);
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return persistentDataCtl->AddQueryTemplate(uri, subscriberId, tpl);
 }
@@ -284,7 +329,7 @@ int DataShareHelperImpl::DelQueryTemplate(const std::string &uri, int64_t subscr
     if (persistentDataCtl == nullptr) {
         LOG_ERROR("persistentDataCtl is nullptr");
         report.SetError(RadarReporter::DATA_SHARE_DIED_ERROR);
-        return INVALID_VALUE;
+        return DATA_SHARE_ERROR;
     }
     return persistentDataCtl->DelQueryTemplate(uri, subscriberId);
 }
@@ -326,8 +371,8 @@ std::vector<OperationResult> DataShareHelperImpl::SubscribeRdbData(const std::ve
     return persistentDataCtl->SubscribeRdbData(this, uris, templateId, callback);
 }
 
-std::vector<OperationResult> DataShareHelperImpl::UnsubscribeRdbData(const std::vector<std::string> &uris,
-    const TemplateId &templateId)
+__attribute__((no_sanitize("cfi"))) std::vector<OperationResult> DataShareHelperImpl::UnsubscribeRdbData(
+    const std::vector<std::string> &uris, const TemplateId &templateId)
 {
     LOG_DEBUG("Start UnsubscribeRdbData");
     RadarReporter::RadarReport report(RadarReporter::TEMPLATE_DATA_MANAGER,
diff --git a/data_share/frameworks/native/consumer/src/datashare_proxy.cpp b/data_share/frameworks/native/consumer/src/datashare_proxy.cpp
index 29bba953cd037b1a634989f1f70c0823e7f227ce..11f9c7a9bda7fd17eba09c25f1b8f3ee80f5955a 100644
--- a/data_share/frameworks/native/consumer/src/datashare_proxy.cpp
+++ b/data_share/frameworks/native/consumer/src/datashare_proxy.cpp
@@ -56,7 +56,7 @@ std::vector<std::string> DataShareProxy::GetFileTypes(const Uri &uri, const std:
 
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_GET_FILE_TYPES), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("GetFileTypes fail to SendRequest. err: %{public}d", err);
     }
 
@@ -90,7 +90,7 @@ int DataShareProxy::OpenFile(const Uri &uri, const std::string &mode)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_OPEN_FILE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("OpenFile fail to SendRequest. err: %{public}d", err);
         return fd;
     }
@@ -127,7 +127,7 @@ int DataShareProxy::OpenRawFile(const Uri &uri, const std::string &mode)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_OPEN_RAW_FILE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("OpenRawFile fail to SendRequest. err: %{public}d", err);
         return fd;
     }
@@ -157,7 +157,7 @@ int DataShareProxy::Insert(const Uri &uri, const DataShareValuesBucket &value)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_INSERT), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("Insert fail to SendRequest. err: %{public}d", err);
         return err == PERMISSION_ERR ? PERMISSION_ERR_CODE : index;
     }
@@ -186,7 +186,7 @@ int DataShareProxy::InsertExt(const Uri &uri, const DataShareValuesBucket &value
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_INSERT_EXT), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("Insert fail to SendRequest. err: %{public}d", err);
         return index;
     }
@@ -214,7 +214,7 @@ int DataShareProxy::Update(const Uri &uri, const DataSharePredicates &predicates
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_UPDATE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("Update fail to SendRequest. err: %{public}d", err);
         return err == PERMISSION_ERR ? PERMISSION_ERR_CODE : index;
     }
@@ -245,7 +245,7 @@ int DataShareProxy::BatchUpdate(const UpdateOperations &operations, std::vector<
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_BATCH_UPDATE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("fail to SendRequest. err: %{public}d", err);
         return err;
     }
@@ -274,7 +274,7 @@ int DataShareProxy::Delete(const Uri &uri, const DataSharePredicates &predicates
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_DELETE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("Delete fail to SendRequest. err: %{public}d", err);
         return err == PERMISSION_ERR ? PERMISSION_ERR_CODE : index;
     }
@@ -285,6 +285,100 @@ int DataShareProxy::Delete(const Uri &uri, const DataSharePredicates &predicates
     return index;
 }
 
+std::pair<int32_t, int32_t> DataShareProxy::InsertEx(const Uri &uri, const DataShareValuesBucket &value)
+{
+    MessageParcel data;
+    data.SetMaxCapacity(MTU_SIZE);
+    if (!data.WriteInterfaceToken(DataShareProxy::GetDescriptor())) {
+        LOG_ERROR("WriteInterfaceToken failed");
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
+    }
+    if (!ITypesUtil::Marshal(data, uri, value)) {
+        LOG_ERROR("fail to Marshal value");
+        return std::make_pair(E_MARSHAL_ERROR, 0);
+    }
+
+    int32_t errCode = -1;
+    int32_t result = -1;
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = Remote()->SendRequest(
+        static_cast<uint32_t>(IDataShareInterfaceCode::CMD_INSERT_EX), data, reply, option);
+    if (err != E_OK) {
+        LOG_ERROR("InsertEx fail to SendRequest. err: %{public}d", err);
+        return std::make_pair((err == PERMISSION_ERR ? PERMISSION_ERR_CODE : errCode), 0);
+    }
+
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
+}
+
+std::pair<int32_t, int32_t> DataShareProxy::UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+    const DataShareValuesBucket &value)
+{
+    MessageParcel data;
+    data.SetMaxCapacity(MTU_SIZE);
+    if (!data.WriteInterfaceToken(DataShareProxy::GetDescriptor())) {
+        LOG_ERROR("WriteInterfaceToken failed");
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
+    }
+    if (!ITypesUtil::Marshal(data, uri, predicates, value)) {
+        LOG_ERROR("fail to Marshal value");
+        return std::make_pair(E_MARSHAL_ERROR, 0);
+    }
+
+    int32_t errCode = -1;
+    int32_t result = -1;
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = Remote()->SendRequest(
+        static_cast<uint32_t>(IDataShareInterfaceCode::CMD_UPDATE_EX), data, reply, option);
+    if (err != E_OK) {
+        LOG_ERROR("UpdateEx fail to SendRequest. err: %{public}d", err);
+        return std::make_pair((err == PERMISSION_ERR ? PERMISSION_ERR_CODE : errCode), 0);
+    }
+
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
+}
+
+std::pair<int32_t, int32_t> DataShareProxy::DeleteEx(const Uri &uri, const DataSharePredicates &predicates)
+{
+    MessageParcel data;
+    data.SetMaxCapacity(MTU_SIZE);
+    if (!data.WriteInterfaceToken(DataShareProxy::GetDescriptor())) {
+        LOG_ERROR("WriteInterfaceToken failed");
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
+    }
+    if (!ITypesUtil::Marshal(data, uri, predicates)) {
+        LOG_ERROR("fail to Marshalling predicates");
+        return std::make_pair(E_MARSHAL_ERROR, 0);
+    }
+
+    int32_t errCode = -1;
+    int32_t result = -1;
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = Remote()->SendRequest(
+        static_cast<uint32_t>(IDataShareInterfaceCode::CMD_DELETE_EX), data, reply, option);
+    if (err != E_OK) {
+        LOG_ERROR("DeleteEx fail to SendRequest. err: %{public}d", err);
+        return std::make_pair((err == PERMISSION_ERR ? PERMISSION_ERR_CODE : errCode), 0);
+    }
+
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
+}
+
 std::shared_ptr<DataShareResultSet> DataShareProxy::Query(const Uri &uri, const DataSharePredicates &predicates,
     std::vector<std::string> &columns, DatashareBusinessError &businessError)
 {
@@ -304,7 +398,7 @@ std::shared_ptr<DataShareResultSet> DataShareProxy::Query(const Uri &uri, const
     auto result = ISharedResultSet::ReadFromParcel(reply);
     businessError.SetCode(reply.ReadInt32());
     businessError.SetMessage(reply.ReadString());
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("Query fail to SendRequest. err: %{public}d", err);
         return nullptr;
     }
@@ -329,7 +423,7 @@ std::string DataShareProxy::GetType(const Uri &uri)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_GET_TYPE), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("GetFileTypes fail to SendRequest. err: %{public}d", err);
         return type;
     }
@@ -363,7 +457,7 @@ int DataShareProxy::BatchInsert(const Uri &uri, const std::vector<DataShareValue
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_BATCH_INSERT), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("fail to SendRequest. err: %{public}d", err);
         return err == PERMISSION_ERR ? PERMISSION_ERR_CODE : ret;
     }
@@ -391,7 +485,7 @@ int DataShareProxy::ExecuteBatch(const std::vector<OperationStatement> &statemen
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_EXECUTE_BATCH), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("fail to SendRequest. err: %{public}d", err);
         return -1;
     }
@@ -488,7 +582,7 @@ Uri DataShareProxy::NormalizeUri(const Uri &uri)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_NORMALIZE_URI), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("NormalizeUri fail to SendRequest. err: %{public}d", err);
         return Uri("");
     }
@@ -517,7 +611,7 @@ Uri DataShareProxy::DenormalizeUri(const Uri &uri)
     MessageOption option;
     int32_t err = Remote()->SendRequest(
         static_cast<uint32_t>(IDataShareInterfaceCode::CMD_DENORMALIZE_URI), data, reply, option);
-    if (err != DATA_SHARE_NO_ERROR) {
+    if (err != E_OK) {
         LOG_ERROR("DenormalizeUri fail to SendRequest. err: %{public}d", err);
         return Uri("");
     }
diff --git a/data_share/frameworks/native/provider/include/datashare_stub.h b/data_share/frameworks/native/provider/include/datashare_stub.h
index b4d71b43bb2252af7f76b4777b4f2f0866751eaf..6bd397537fa8eeed4246bb49e20dbb7516895dec 100644
--- a/data_share/frameworks/native/provider/include/datashare_stub.h
+++ b/data_share/frameworks/native/provider/include/datashare_stub.h
@@ -20,6 +20,7 @@
 #include <map>
 
 #include "datashare_business_error.h"
+#include "datashare_errno.h"
 #include "idatashare.h"
 
 namespace OHOS {
@@ -48,10 +49,17 @@ private:
     ErrCode CmdExecuteBatch(MessageParcel &data, MessageParcel &reply);
     ErrCode CmdInsertExt(MessageParcel &data, MessageParcel &reply);
     ErrCode CmdBatchUpdate(MessageParcel &data, MessageParcel &reply);
+    ErrCode CmdInsertEx(MessageParcel &data, MessageParcel &reply);
+    ErrCode CmdUpdateEx(MessageParcel &data, MessageParcel &reply);
+    ErrCode CmdDeleteEx(MessageParcel &data, MessageParcel &reply);
 
     virtual int ExecuteBatch(const std::vector<OperationStatement> &statements, ExecResultSet &result) override;
     virtual int InsertExt(const Uri &uri, const DataShareValuesBucket &value, std::string &result) override;
     virtual int BatchUpdate(const UpdateOperations &operations, std::vector<BatchUpdateResult> &results) override;
+    virtual std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) override;
+    virtual std::pair<int32_t, int32_t> UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+        const DataShareValuesBucket &value) override;
+    virtual std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) override;
 
     using RequestFuncType = int (DataShareStub::*)(MessageParcel &data, MessageParcel &reply);
     std::map<uint32_t, RequestFuncType> stubFuncMap_;
diff --git a/data_share/frameworks/native/provider/include/datashare_stub_impl.h b/data_share/frameworks/native/provider/include/datashare_stub_impl.h
index f0c3e358f562ab9a7af41a3ee3e3afc586cdae63..42b4cc32e16c7ce2a04e0ca885ca4dabea89979d 100644
--- a/data_share/frameworks/native/provider/include/datashare_stub_impl.h
+++ b/data_share/frameworks/native/provider/include/datashare_stub_impl.h
@@ -67,6 +67,13 @@ public:
 
     Uri DenormalizeUri(const Uri &uri) override;
 
+    std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+        const DataShareValuesBucket &value) override;
+
+    std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const DataSharePredicates &predicates) override;
+
 private:
     std::shared_ptr<JsDataShareExtAbility> GetOwner();
     bool CheckCallingPermission(const std::string &permission);
diff --git a/data_share/frameworks/native/provider/src/datashare_stub.cpp b/data_share/frameworks/native/provider/src/datashare_stub.cpp
index 50c48eaa3119e76e0dfe07f5b572d2bf224772a7..0ebf16736af26ac1acd56295082a18eb67885700 100644
--- a/data_share/frameworks/native/provider/src/datashare_stub.cpp
+++ b/data_share/frameworks/native/provider/src/datashare_stub.cpp
@@ -55,6 +55,9 @@ DataShareStub::DataShareStub()
     stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_EXECUTE_BATCH)] = &DataShareStub::CmdExecuteBatch;
     stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_INSERT_EXT)] = &DataShareStub::CmdInsertExt;
     stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_BATCH_UPDATE)] = &DataShareStub::CmdBatchUpdate;
+    stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_INSERT_EX)] = &DataShareStub::CmdInsertEx;
+    stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_UPDATE_EX)] = &DataShareStub::CmdUpdateEx;
+    stubFuncMap_[static_cast<uint32_t>(IDataShareInterfaceCode::CMD_DELETE_EX)] = &DataShareStub::CmdDeleteEx;
 }
 
 DataShareStub::~DataShareStub()
@@ -109,7 +112,7 @@ ErrCode DataShareStub::CmdGetFileTypes(MessageParcel &data, MessageParcel &reply
         LOG_ERROR("Marshal value is nullptr");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply)
@@ -134,7 +137,7 @@ ErrCode DataShareStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply)
         return ERR_INVALID_VALUE;
     }
     close(fd);
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdOpenRawFile(MessageParcel &data, MessageParcel &reply)
@@ -150,7 +153,7 @@ ErrCode DataShareStub::CmdOpenRawFile(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("Marshal value is nullptr");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdInsert(MessageParcel &data, MessageParcel &reply)
@@ -173,7 +176,7 @@ ErrCode DataShareStub::CmdInsert(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to WriteInt32 index");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdUpdate(MessageParcel &data, MessageParcel &reply)
@@ -197,7 +200,7 @@ ErrCode DataShareStub::CmdUpdate(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to WriteInt32 index");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdBatchUpdate(OHOS::MessageParcel &data, OHOS::MessageParcel &reply)
@@ -217,7 +220,7 @@ ErrCode DataShareStub::CmdBatchUpdate(OHOS::MessageParcel &data, OHOS::MessagePa
         LOG_ERROR("marshalling updateOperations is failed");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdDelete(MessageParcel &data, MessageParcel &reply)
@@ -240,7 +243,81 @@ ErrCode DataShareStub::CmdDelete(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to WriteInt32 index");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
+}
+
+ErrCode DataShareStub::CmdInsertEx(MessageParcel &data, MessageParcel &reply)
+{
+    Uri uri("");
+    DataShareValuesBucket value;
+    if (!ITypesUtil::Unmarshal(data, uri, value)) {
+        LOG_ERROR("Unmarshalling value is nullptr");
+        return E_UNMARSHAL_ERROR;
+    }
+
+    auto [errCode, result] = InsertEx(uri, value);
+    if (errCode == DEFAULT_NUMBER) {
+        LOG_ERROR("Insert inner error");
+        return ERR_INVALID_VALUE;
+    } else if (errCode == PERMISSION_ERROR_NUMBER) {
+        LOG_ERROR("Insert permission error");
+        return ERR_PERMISSION_DENIED;
+    }
+
+    if (!ITypesUtil::Marshal(reply, errCode, result)) {
+        LOG_ERROR("Marshal value is nullptr");
+        return E_MARSHAL_ERROR;
+    }
+    return E_OK;
+}
+
+ErrCode DataShareStub::CmdUpdateEx(MessageParcel &data, MessageParcel &reply)
+{
+    Uri uri("");
+    DataSharePredicates predicates;
+    DataShareValuesBucket value;
+    if (!ITypesUtil::Unmarshal(data, uri, predicates, value)) {
+        LOG_ERROR("Unmarshalling predicates is nullptr");
+        return E_UNMARSHAL_ERROR;
+    }
+
+    auto [errCode, result] = UpdateEx(uri, predicates, value);
+    if (errCode == DEFAULT_NUMBER) {
+        LOG_ERROR("Update inner error");
+        return ERR_INVALID_VALUE;
+    } else if (errCode == PERMISSION_ERROR_NUMBER) {
+        LOG_ERROR("Update permission error");
+        return ERR_PERMISSION_DENIED;
+    }
+
+    if (!ITypesUtil::Marshal(reply, errCode, result)) {
+        LOG_ERROR("Marshal value is nullptr");
+        return E_MARSHAL_ERROR;
+    }
+    return E_OK;
+}
+
+ErrCode DataShareStub::CmdDeleteEx(MessageParcel &data, MessageParcel &reply)
+{
+    Uri uri("");
+    DataSharePredicates predicates;
+    if (!ITypesUtil::Unmarshal(data, uri, predicates)) {
+        LOG_ERROR("Unmarshalling predicates is nullptr");
+        return E_UNMARSHAL_ERROR;
+    }
+    auto [errCode, result] = DeleteEx(uri, predicates);
+    if (errCode == DEFAULT_NUMBER) {
+        LOG_ERROR("Delete inner error");
+        return ERR_INVALID_VALUE;
+    } else if (errCode == PERMISSION_ERROR_NUMBER) {
+        LOG_ERROR("Delete permission error");
+        return ERR_PERMISSION_DENIED;
+    }
+    if (!ITypesUtil::Marshal(reply, errCode, result)) {
+        LOG_ERROR("Marshal value is nullptr");
+        return E_MARSHAL_ERROR;
+    }
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdQuery(MessageParcel &data, MessageParcel &reply)
@@ -261,7 +338,7 @@ ErrCode DataShareStub::CmdQuery(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("!resultSet->Marshalling(reply)");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdGetType(MessageParcel &data, MessageParcel &reply)
@@ -276,7 +353,7 @@ ErrCode DataShareStub::CmdGetType(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to WriteString type");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdBatchInsert(MessageParcel &data, MessageParcel &reply)
@@ -300,7 +377,7 @@ ErrCode DataShareStub::CmdBatchInsert(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to WriteInt32 ret");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdRegisterObserver(MessageParcel &data, MessageParcel &reply)
@@ -322,7 +399,7 @@ ErrCode DataShareStub::CmdRegisterObserver(MessageParcel &data, MessageParcel &r
         LOG_ERROR("fail to WriteInt32 ret");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdUnregisterObserver(MessageParcel &data, MessageParcel &reply)
@@ -344,7 +421,7 @@ ErrCode DataShareStub::CmdUnregisterObserver(MessageParcel &data, MessageParcel
         LOG_ERROR("fail to WriteInt32 ret");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdNotifyChange(MessageParcel &data, MessageParcel &reply)
@@ -360,7 +437,7 @@ ErrCode DataShareStub::CmdNotifyChange(MessageParcel &data, MessageParcel &reply
         LOG_ERROR("fail to WriteInt32 ret");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdNormalizeUri(MessageParcel &data, MessageParcel &reply)
@@ -375,7 +452,7 @@ ErrCode DataShareStub::CmdNormalizeUri(MessageParcel &data, MessageParcel &reply
         LOG_ERROR("Write to message parcel failed!");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdDenormalizeUri(MessageParcel &data, MessageParcel &reply)
@@ -391,7 +468,7 @@ ErrCode DataShareStub::CmdDenormalizeUri(MessageParcel &data, MessageParcel &rep
         LOG_ERROR("Write to message parcel failed!");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdExecuteBatch(MessageParcel &data, MessageParcel &reply)
@@ -411,7 +488,7 @@ ErrCode DataShareStub::CmdExecuteBatch(MessageParcel &data, MessageParcel &reply
         LOG_ERROR("fail to write result");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 ErrCode DataShareStub::CmdInsertExt(MessageParcel &data, MessageParcel &reply)
@@ -432,7 +509,7 @@ ErrCode DataShareStub::CmdInsertExt(MessageParcel &data, MessageParcel &reply)
         LOG_ERROR("fail to write result");
         return ERR_INVALID_VALUE;
     }
-    return DATA_SHARE_NO_ERROR;
+    return E_OK;
 }
 
 int DataShareStub::ExecuteBatch(const std::vector<OperationStatement> &statements, ExecResultSet &result)
@@ -449,5 +526,19 @@ int DataShareStub::BatchUpdate(const UpdateOperations &operations, std::vector<B
 {
     return 0;
 }
+std::pair<int32_t, int32_t> DataShareStub::InsertEx(const Uri &uri, const DataShareValuesBucket &value)
+{
+    return std::make_pair(0, 0);
+}
+std::pair<int32_t, int32_t> DataShareStub::UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+    const DataShareValuesBucket &value)
+{
+    return std::make_pair(0, 0);
+}
+std::pair<int32_t, int32_t> DataShareStub::DeleteEx(const Uri &uri, const DataSharePredicates &predicates)
+{
+    return std::make_pair(0, 0);
+}
+
 } // namespace DataShare
 } // namespace OHOS
\ No newline at end of file
diff --git a/data_share/frameworks/native/provider/src/datashare_stub_impl.cpp b/data_share/frameworks/native/provider/src/datashare_stub_impl.cpp
index 1246d09972d156106c45ca05c8ec80472369ed7e..bee637f5292604c1b0ad0f9fbc2a473141707974 100644
--- a/data_share/frameworks/native/provider/src/datashare_stub_impl.cpp
+++ b/data_share/frameworks/native/provider/src/datashare_stub_impl.cpp
@@ -247,6 +247,106 @@ int DataShareStubImpl::Delete(const Uri &uri, const DataSharePredicates &predica
     return ret;
 }
 
+std::pair<int32_t, int32_t> DataShareStubImpl::InsertEx(const Uri &uri, const DataShareValuesBucket &value)
+{
+    CallingInfo info;
+    GetCallingInfo(info);
+
+    auto client = sptr<DataShareStubImpl>(this);
+    auto extension = client->GetOwner();
+    if (extension == nullptr) {
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+
+    if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
+        LOG_ERROR("Check calling permission failed.");
+        return std::make_pair(PERMISSION_ERROR_NUMBER, 0);
+    }
+
+    int ret = 0;
+    std::function<void()> syncTaskFunc = [extension, info, uri, value]() {
+        extension->SetCallingInfo(info);
+        extension->Insert(uri, value);
+    };
+    std::function<bool()> getRetFunc = [extension, &ret]() -> bool {
+        if (extension == nullptr) {
+            return false;
+        }
+        extension->GetResult(ret);
+        return extension->GetRecvReply();
+    };
+    std::lock_guard<std::mutex> lock(mutex_);
+    uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
+    return std::make_pair(E_OK, ret);
+}
+
+std::pair<int32_t, int32_t> DataShareStubImpl::UpdateEx(const Uri &uri, const DataSharePredicates &predicates,
+    const DataShareValuesBucket &value)
+{
+    CallingInfo info;
+    GetCallingInfo(info);
+
+    auto client = sptr<DataShareStubImpl>(this);
+    auto extension = client->GetOwner();
+    if (extension == nullptr) {
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+
+    if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
+        LOG_ERROR("Check calling permission failed.");
+        return std::make_pair(PERMISSION_ERROR_NUMBER, 0);
+    }
+
+    int ret = 0;
+    std::function<void()> syncTaskFunc = [extension, info, uri, predicates, value]() {
+        extension->SetCallingInfo(info);
+        extension->Update(uri, predicates, value);
+    };
+    std::function<bool()> getRetFunc = [extension, &ret]() -> bool {
+        if (extension == nullptr) {
+            return false;
+        }
+        extension->GetResult(ret);
+        return extension->GetRecvReply();
+    };
+    std::lock_guard<std::mutex> lock(mutex_);
+    uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
+    return std::make_pair(E_OK, ret);
+}
+
+std::pair<int32_t, int32_t> DataShareStubImpl::DeleteEx(const Uri &uri, const DataSharePredicates &predicates)
+{
+    CallingInfo info;
+    GetCallingInfo(info);
+
+    auto client = sptr<DataShareStubImpl>(this);
+    auto extension = client->GetOwner();
+    if (extension == nullptr) {
+        return std::make_pair(DATA_SHARE_ERROR, 0);
+    }
+
+    if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
+        LOG_ERROR("Check calling permission failed.");
+        return std::make_pair(PERMISSION_ERROR_NUMBER, 0);
+    }
+
+    int ret = 0;
+    std::function<void()> syncTaskFunc = [extension, info, uri, predicates]() {
+        extension->SetCallingInfo(info);
+        extension->Delete(uri, predicates);
+    };
+    std::function<bool()> getRetFunc = [extension, &ret]() -> bool {
+        if (extension == nullptr) {
+            return false;
+        }
+        extension->GetResult(ret);
+        return extension->GetRecvReply();
+    };
+    std::lock_guard<std::mutex> lock(mutex_);
+    uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
+    return std::make_pair(E_OK, ret);
+}
+
 std::shared_ptr<DataShareResultSet> DataShareStubImpl::Query(const Uri &uri,
     const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
 {
@@ -273,9 +373,10 @@ std::shared_ptr<DataShareResultSet> DataShareStubImpl::Query(const Uri &uri,
         if (extension == nullptr) {
             return false;
         }
+        auto isRecvReply = extension->GetRecvReply();
         extension->GetResultSet(resultSet);
         extension->GetBusinessError(businessError);
-        return extension->GetRecvReply();
+        return isRecvReply;
     };
     std::lock_guard<std::mutex> lock(mutex_);
     uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
diff --git a/data_share/frameworks/native/proxy/include/ams_mgr_proxy.h b/data_share/frameworks/native/proxy/include/ams_mgr_proxy.h
index 3a4fdac873aa6e21646564fb5fa585111636d502..080f428b7ec3a80117b0ba75d9d091d8f99308d5 100644
--- a/data_share/frameworks/native/proxy/include/ams_mgr_proxy.h
+++ b/data_share/frameworks/native/proxy/include/ams_mgr_proxy.h
@@ -24,15 +24,16 @@ namespace OHOS::DataShare {
 class AmsMgrProxy {
 public:
     ~AmsMgrProxy();
-    static AmsMgrProxy* GetInstance();
+    static AmsMgrProxy *GetInstance();
     int Connect(const std::string &uri, const sptr<IRemoteObject> &connect, const sptr<IRemoteObject> &callerToken);
     int DisConnect(sptr<IRemoteObject> connect);
+
 private:
     using Proxy = AAFwk::ExtensionManagerProxy;
     AmsMgrProxy() = default;
     class ServiceDeathRecipient : public IRemoteObject::DeathRecipient {
     public:
-        explicit ServiceDeathRecipient(AmsMgrProxy* owner) : owner_(owner)
+        explicit ServiceDeathRecipient(AmsMgrProxy *owner) : owner_(owner)
         {
         }
         void OnRemoteDied(const wptr<IRemoteObject> &object) override
@@ -43,7 +44,7 @@ private:
         }
 
     private:
-        AmsMgrProxy* owner_;
+        AmsMgrProxy *owner_;
     };
     void OnProxyDied();
     bool ConnectSA();
diff --git a/data_share/frameworks/native/proxy/include/data_share_manager_impl.h b/data_share/frameworks/native/proxy/include/data_share_manager_impl.h
index dcb38fe99dd81dd038f90d3dcae13e208aac3f8f..8ff96ca25dd5ebc997e7168e915f41f476127c10 100644
--- a/data_share/frameworks/native/proxy/include/data_share_manager_impl.h
+++ b/data_share/frameworks/native/proxy/include/data_share_manager_impl.h
@@ -16,13 +16,17 @@
 #ifndef DATASHARESERVICE_DATA_SHARE_MANAGER_IMPL_H
 #define DATASHARESERVICE_DATA_SHARE_MANAGER_IMPL_H
 
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
+#include <string>
+#include <vector>
 
+#include "call_reporter.h"
 #include "concurrent_map.h"
 #include "data_share_service_proxy.h"
-#include "data_share_errno.h"
+#include "datashare_errno.h"
 #include "idata_share_client_death_observer.h"
 #include "iremote_object.h"
 #include "refbase.h"
@@ -85,6 +89,8 @@ public:
     void RemoveRegisterCallback(GeneralControllerServiceImpl* ptr);
 
     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId);
+
+    void SetCallCount(const std::string &funcName, const std::string &uri);
         
 private:
     DataShareManagerImpl();
@@ -108,13 +114,10 @@ private:
     sptr<DataShareKvServiceProxy> dataMgrService_;
     std::shared_ptr<DataShareServiceProxy> dataShareService_;
     std::string bundleName_;
-    static constexpr int WAIT_TIME = 2;
-    static constexpr int MAX_THREADS = 2;
-    static constexpr int MIN_THREADS = 0;
-    std::shared_ptr<ExecutorPool> pool_;
     std::function<void(std::shared_ptr<DataShareServiceProxy>)> deathCallback_ = {};
     sptr<IRemoteObject> clientDeathObserverPtr_;
     ConcurrentMap<GeneralControllerServiceImpl*, std::function<void()>> observers_;
+    DataShareCallReporter dataShareCallReporter_;
 };
 }
 } // namespace OHOS::DataShare
diff --git a/data_share/frameworks/native/proxy/include/data_share_service_proxy.h b/data_share/frameworks/native/proxy/include/data_share_service_proxy.h
index 5b7658cac1cfb61ea5b21d9a6254daccc87876d9..ab1028ee6c0b112318c8e46e5d09b355b72d9de5 100644
--- a/data_share/frameworks/native/proxy/include/data_share_service_proxy.h
+++ b/data_share/frameworks/native/proxy/include/data_share_service_proxy.h
@@ -26,14 +26,14 @@ namespace OHOS::DataShare {
 class DataShareServiceProxy final : public IRemoteProxy<IDataShareService> {
 public:
     explicit DataShareServiceProxy(const sptr<IRemoteObject> &object);
-    int Insert(const Uri &uri, const DataShareValuesBucket &valuesBucket) override;
+    int Insert(const Uri &uri, const Uri &extUri, const DataShareValuesBucket &valuesBucket) override;
 
-    int Update(const Uri &uri, const DataSharePredicates &predicate,
+    int Update(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate,
         const DataShareValuesBucket &valuesBucket) override;
 
-    int Delete(const Uri &uri, const DataSharePredicates &predicate) override;
+    int Delete(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate) override;
 
-    std::shared_ptr<DataShareResultSet> Query(const Uri &uri, const DataSharePredicates &predicates,
+    std::shared_ptr<DataShareResultSet> Query(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicates,
         std::vector<std::string> &columns, DatashareBusinessError &businessError) override;
 
     int AddQueryTemplate(const std::string &uri, int64_t subscriberId, Template &tpl) override;
@@ -79,6 +79,15 @@ public:
     int UnRegisterObserver(const Uri &uri,
         const sptr<OHOS::IRemoteObject> &dataObserver) override;
 
+    std::pair<int32_t, int32_t> InsertEx(const Uri &uri, const Uri &extUri,
+        const DataShareValuesBucket &valuesBucket) override;
+
+    std::pair<int32_t, int32_t> UpdateEx(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate,
+        const DataShareValuesBucket &valuesBucket) override;
+
+    std::pair<int32_t, int32_t> DeleteEx(const Uri &uri, const Uri &extUri,
+        const DataSharePredicates &predicate) override;
+
 private:
     static inline BrokerDelegator<DataShareServiceProxy> delegator_;
 };
diff --git a/data_share/frameworks/native/proxy/src/ams_mgr_proxy.cpp b/data_share/frameworks/native/proxy/src/ams_mgr_proxy.cpp
index 73bdba459e004207901043bbbc14363be903e5c8..0ae950daa5dad90c07b4975750c1b5e9c1b63c47 100644
--- a/data_share/frameworks/native/proxy/src/ams_mgr_proxy.cpp
+++ b/data_share/frameworks/native/proxy/src/ams_mgr_proxy.cpp
@@ -45,11 +45,8 @@ AmsMgrProxy::~AmsMgrProxy()
 
 AmsMgrProxy* AmsMgrProxy::GetInstance()
 {
-    static AmsMgrProxy* proxy = nullptr;
-    if (proxy != nullptr) {
-        return proxy;
-    }
     std::lock_guard<std::mutex> lock(pmutex_);
+    static AmsMgrProxy* proxy = nullptr;
     if (proxy != nullptr) {
         return proxy;
     }
diff --git a/data_share/frameworks/native/proxy/src/data_share_manager_impl.cpp b/data_share/frameworks/native/proxy/src/data_share_manager_impl.cpp
index 8395eb12c388d68e0e476a69d945eaa7b32e281d..df392164097bf685a14fbfd883d79e0ad8514721 100644
--- a/data_share/frameworks/native/proxy/src/data_share_manager_impl.cpp
+++ b/data_share/frameworks/native/proxy/src/data_share_manager_impl.cpp
@@ -23,7 +23,6 @@
 #include "ipc_skeleton.h"
 #include "iservice_registry.h"
 #include "system_ability_definition.h"
-#include "executor_pool.h"
 #include "rdb_subscriber_manager.h"
 #include "published_data_subscriber_manager.h"
 
@@ -35,9 +34,6 @@ DataShareManagerImpl* DataShareManagerImpl::manager_ = nullptr;
 
 DataShareManagerImpl* DataShareManagerImpl::GetInstance()
 {
-    if (manager_ != nullptr) {
-        return manager_;
-    }
     std::lock_guard<std::mutex> lock(pmutex_);
     if (manager_ != nullptr) {
         return manager_;
@@ -133,7 +129,6 @@ void DataShareManagerImpl::RegisterClientDeathObserver()
 
 DataShareManagerImpl::DataShareManagerImpl()
 {
-    pool_ = std::make_shared<ExecutorPool>(MAX_THREADS, MIN_THREADS);
     SetDeathCallback([](std::shared_ptr<DataShareServiceProxy> proxy) {
         LOG_INFO("RecoverObs start");
         RdbSubscriberManager::GetInstance().RecoverObservers(proxy);
@@ -147,10 +142,6 @@ DataShareManagerImpl::~DataShareManagerImpl()
 
 std::shared_ptr<DataShareServiceProxy> DataShareManagerImpl::GetProxy()
 {
-    if (dataShareService_ != nullptr) {
-        return dataShareService_;
-    }
-
     std::lock_guard<std::mutex> lock(mutex_);
     if (dataShareService_ != nullptr) {
         return dataShareService_;
@@ -199,16 +190,6 @@ void DataShareManagerImpl::OnRemoteDied()
 {
     LOG_INFO("#######datashare service has dead");
     ResetServiceHandle();
-    auto taskid = pool_->Schedule(std::chrono::seconds(WAIT_TIME), [this]() {
-        if (GetServiceProxy() != nullptr) {
-            deathCallback_(dataShareService_);
-        }
-    });
-    if (taskid == ExecutorPool::INVALID_TASK_ID) {
-        LOG_ERROR("create scheduler failed, over the max capacity");
-        return;
-    }
-    LOG_DEBUG("create scheduler success");
 }
 
 void DataShareManagerImpl::SetRegisterCallback(GeneralControllerServiceImpl* ptr,
@@ -235,6 +216,15 @@ void DataShareManagerImpl::OnAddSystemAbility(int32_t systemAbilityId, const std
         callback();
         return false;
     });
+    auto serviceProxy = GetServiceProxy();
+    if (serviceProxy != nullptr) {
+        deathCallback_(serviceProxy);
+    }
+}
+
+void DataShareManagerImpl::SetCallCount(const std::string &funcName, const std::string &uri)
+{
+    dataShareCallReporter_.Count(funcName, uri);
 }
 }
 }
diff --git a/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp b/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp
index bc14154c1bae9063fe13e64d9f350486aea4beb3..66ae66a06f02c75540d000182c59a34574681c34 100644
--- a/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp
+++ b/data_share/frameworks/native/proxy/src/data_share_service_proxy.cpp
@@ -25,90 +25,146 @@
 namespace OHOS {
 namespace DataShare {
 using InterfaceCode = OHOS::DistributedShare::DataShare::DataShareServiceInterfaceCode;
-
 DataShareServiceProxy::DataShareServiceProxy(const sptr<IRemoteObject> &object)
     : IRemoteProxy<IDataShareService>(object)
 {
 }
 
-int32_t DataShareServiceProxy::Insert(const Uri &uri, const DataShareValuesBucket &value)
+int32_t DataShareServiceProxy::Insert(const Uri &uri, const Uri &extUri, const DataShareValuesBucket &value)
+{
+    auto [errCode, status] = InsertEx(uri, extUri, value);
+    if (errCode == NO_ERROR) {
+        return status;
+    } else if (errCode < NO_ERROR) {
+        return errCode;
+    }
+    LOG_ERROR("DataShareServiceProxy insert failed, errCode = %{public}d", errCode);
+    return DATA_SHARE_ERROR;
+}
+
+int32_t DataShareServiceProxy::Update(const Uri &uri, const Uri &extUri,
+    const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
+{
+    auto [errCode, status] = UpdateEx(uri, extUri, predicate, valuesBucket);
+    if (errCode == NO_ERROR) {
+        return status;
+    } else if (errCode < NO_ERROR) {
+        return errCode;
+    }
+    LOG_ERROR("DataShareServiceProxy update failed, errCode = %{public}d", errCode);
+    return DATA_SHARE_ERROR;
+}
+
+int32_t DataShareServiceProxy::Delete(const Uri &uri, const Uri &extUri, const DataSharePredicates &predicate)
+{
+    auto [errCode, status] = DeleteEx(uri, extUri, predicate);
+    if (errCode == NO_ERROR) {
+        return status;
+    } else if (errCode < NO_ERROR) {
+        return errCode;
+    }
+    LOG_ERROR("DataShareServiceProxy delete failed, errCode = %{public}d", errCode);
+    return DATA_SHARE_ERROR;
+}
+
+std::pair<int32_t, int32_t> DataShareServiceProxy::InsertEx(const Uri &uri, const Uri &extUri,
+    const DataShareValuesBucket &value)
 {
     const std::string &uriStr = uri.ToString();
     MessageParcel data;
     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
         LOG_ERROR("Write descriptor failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
     }
-    if (!ITypesUtil::Marshal(data, uriStr, value)) {
+    if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), value)) {
         LOG_ERROR("Write to message parcel failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_MARSHAL_ERROR, 0);
     }
 
+    int32_t result = -1;
+    int32_t errCode = -1;
     MessageParcel reply;
     MessageOption option;
     int32_t err = Remote()->SendRequest(
-        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_INSERT), data, reply, option);
+        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_INSERTEX), data, reply, option);
     if (err != NO_ERROR) {
-        LOG_ERROR("Insert fail to sendRequest. uri: %{public}s, err: %{public}d",
+        LOG_ERROR("InsertEx fail to sendRequest. uri: %{public}s, err: %{public}d",
             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
-        return DATA_SHARE_ERROR;
+        return std::make_pair(DATA_SHARE_ERROR, 0);
     }
-    return reply.ReadInt32();
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
 }
 
-int32_t DataShareServiceProxy::Update(const Uri &uri,
+std::pair<int32_t, int32_t> DataShareServiceProxy::UpdateEx(const Uri &uri, const Uri &extUri,
     const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
 {
     const std::string &uriStr = uri.ToString();
     MessageParcel data;
     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
         LOG_ERROR("Write descriptor failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
     }
-    if (!ITypesUtil::Marshal(data, uriStr, predicate, valuesBucket)) {
+    if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicate, valuesBucket)) {
         LOG_ERROR("Write to message parcel failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_MARSHAL_ERROR, 0);
     }
 
+    int32_t result = -1;
+    int32_t errCode = -1;
     MessageParcel reply;
     MessageOption option;
     int32_t err = Remote()->SendRequest(
-        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UPDATE), data, reply, option);
+        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_UPDATEEX), data, reply, option);
     if (err != NO_ERROR) {
-        LOG_ERROR("Update fail to sendRequest. uri: %{public}s, err: %{public}d",
+        LOG_ERROR("UpdateEx fail to sendRequest. uri: %{public}s, err: %{public}d",
             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
-        return DATA_SHARE_ERROR;
+        return std::make_pair(DATA_SHARE_ERROR, 0);
     }
-    return reply.ReadInt32();
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
 }
 
-int32_t DataShareServiceProxy::Delete(const Uri &uri, const DataSharePredicates &predicate)
+std::pair<int32_t, int32_t> DataShareServiceProxy::DeleteEx(const Uri &uri, const Uri &extUri,
+    const DataSharePredicates &predicate)
 {
     const std::string &uriStr = uri.ToString();
     MessageParcel data;
     if (!data.WriteInterfaceToken(IDataShareService::GetDescriptor())) {
         LOG_ERROR("Write descriptor failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_WRITE_TO_PARCE_ERROR, 0);
     }
-    if (!ITypesUtil::Marshal(data, uriStr, predicate)) {
+    if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicate)) {
         LOG_ERROR("Write to message parcel failed!");
-        return DATA_SHARE_ERROR;
+        return std::make_pair(E_MARSHAL_ERROR, 0);
     }
 
+    int32_t result = -1;
+    int32_t errCode = -1;
     MessageParcel reply;
     MessageOption option;
     int32_t err = Remote()->SendRequest(
-        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DELETE), data, reply, option);
+        static_cast<uint32_t>(InterfaceCode::DATA_SHARE_SERVICE_CMD_DELETEEX), data, reply, option);
     if (err != NO_ERROR) {
-        LOG_ERROR("Delete fail to sendRequest. uri: %{public}s, err: %{public}d",
+        LOG_ERROR("DeleteEx fail to sendRequest. uri: %{public}s, err: %{public}d",
             DataShareStringUtils::Anonymous(uriStr).c_str(), err);
-        return DATA_SHARE_ERROR;
+        return std::make_pair(DATA_SHARE_ERROR, 0);
     }
-    return reply.ReadInt32();
+    if (!ITypesUtil::Unmarshal(reply, errCode, result)) {
+        LOG_ERROR("fail to Unmarshal");
+        return std::make_pair(E_UNMARSHAL_ERROR, 0);
+    }
+    return std::make_pair(errCode, result);
 }
 
-std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri, const DataSharePredicates &predicates,
-    std::vector<std::string> &columns, DatashareBusinessError &businessError)
+std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri, const Uri &extUri,
+    const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
 {
     const std::string &uriStr = uri.ToString();
     MessageParcel data;
@@ -117,7 +173,7 @@ std::shared_ptr<DataShareResultSet> DataShareServiceProxy::Query(const Uri &uri,
         return nullptr;
     }
 
-    if (!ITypesUtil::Marshal(data, uriStr, predicates, columns)) {
+    if (!ITypesUtil::Marshal(data, uriStr, extUri.ToString(), predicates, columns)) {
         LOG_ERROR("Write to message parcel failed!");
         return nullptr;
     }
diff --git a/data_share/interfaces/inner_api/BUILD.gn b/data_share/interfaces/inner_api/BUILD.gn
index fabe3a7cddbf334ee22da7e3fb34f10cc525b8c8..bb9b3dcef9173b1d4aa74ab49d956fa12cb62b3e 100644
--- a/data_share/interfaces/inner_api/BUILD.gn
+++ b/data_share/interfaces/inner_api/BUILD.gn
@@ -48,6 +48,7 @@ config("datashare_public_config") {
 }
 
 datashare_consumer_sources = [
+  "${datashare_common_native_path}/src/call_reporter.cpp",
   "${datashare_common_native_path}/src/datashare_string_utils.cpp",
   "${datashare_native_consumer_path}/controller/provider/src/ext_special_controller.cpp",
   "${datashare_native_consumer_path}/controller/provider/src/general_controller_provider_impl.cpp",
diff --git a/data_share/interfaces/inner_api/common/include/datashare_errno.h b/data_share/interfaces/inner_api/common/include/datashare_errno.h
index 3bdf68dc2f24b54e29900d41f68ad5e88501227f..0c58659ef56431820f2923b700447579cc6567a3 100644
--- a/data_share/interfaces/inner_api/common/include/datashare_errno.h
+++ b/data_share/interfaces/inner_api/common/include/datashare_errno.h
@@ -18,6 +18,10 @@
 
 namespace OHOS {
 namespace DataShare {
+/**
+* @brief The error code in the data share error case.
+*/
+constexpr int DATA_SHARE_ERROR = -1;
 
 /**
 * @brief The error code in the correct case.
@@ -99,22 +103,56 @@ constexpr int E_BMS_NOT_READY = (E_BASE + 50);
 * @brief metaData not exists
 */
 constexpr int E_METADATA_NOT_EXISTS = (E_BASE + 51);
+
 /**
 * @brief silent proxy is disable
 */
 constexpr int E_SILENT_PROXY_DISABLE = (E_BASE + 52);
+
 /**
 * @brief token is empty
 */
 constexpr int E_TOKEN_EMPTY = (E_BASE + 53);
+
 /**
 * @brief ext uri is empty
 */
 constexpr int E_EXT_URI_INVALID = (E_BASE + 54);
+
 /**
 * @brief DataShare not ready
 */
 constexpr int E_DATA_SHARE_NOT_READY = (E_BASE + 55);
+
+/**
+* @brief The error code for db error.
+*/
+constexpr int E_DB_ERROR = (E_BASE + 56);
+
+/**
+* @brief The error code for data supplier error
+*/
+constexpr int E_DATA_SUPPLIER_ERROR = (E_BASE + 57);
+
+/**
+* @brief The error code for marshal error.
+*/
+constexpr int E_MARSHAL_ERROR = (E_BASE + 58);
+
+/**
+* @brief The error code for unmarshal error.
+*/
+constexpr int E_UNMARSHAL_ERROR = (E_BASE + 59);
+
+/**
+* @brief The error code for write interface token to data error.
+*/
+constexpr int E_WRITE_TO_PARCE_ERROR = (E_BASE + 60);
+
+/**
+* @brief The error code for resultSet busy error.
+*/
+constexpr int E_RESULTSET_BUSY = (E_BASE + 61);
 } // namespace DataShare
 } // namespace OHOS
 
diff --git a/data_share/interfaces/inner_api/consumer/include/datashare_helper.h b/data_share/interfaces/inner_api/consumer/include/datashare_helper.h
index 7e7efc9ac5ef6688ec0cdc1adae5804bda7f74f3..c2450aa2baf6882b33ced33d6f81b64a61bfdba1 100644
--- a/data_share/interfaces/inner_api/consumer/include/datashare_helper.h
+++ b/data_share/interfaces/inner_api/consumer/include/datashare_helper.h
@@ -24,6 +24,7 @@
 
 #include "data_ability_observer_interface.h"
 #include "datashare_business_error.h"
+#include "datashare_errno.h"
 #include "datashare_observer.h"
 #include "datashare_operation_statement.h"
 #include "datashare_predicates.h"
@@ -56,22 +57,28 @@ public:
      *
      * @param token Indicates the System token.
      * @param strUri Indicates the database table or disk file to operate.
+     * @param waitTime connect extension waiting time.
      *
      * @return Returns the created DataShareHelper instance.
      */
-    static std::shared_ptr<DataShareHelper> Creator(
-        const sptr<IRemoteObject> &token, const std::string &strUri, const std::string &extUri = "");
+    [[deprecated(
+        "Use Create(const sptr<IRemoteObject> &, const std::string &, const std::string &, const int &) instead.")]]
+    static std::shared_ptr<DataShareHelper> Creator(const sptr<IRemoteObject> &token,
+        const std::string &strUri, const std::string &extUri = "", const int waitTime = 2);
 
     /**
      * @brief Creates a DataShareHelper instance with the Uri and {@link #CreateOptions} .
      *
      * @param strUri Indicates the database table or disk file to operate.
      * @param options Indicates the optional config.
+     * @param waitTime connect extension waiting time.
      *
      * @return Returns the created DataShareHelper instance with a specified Uri.
      */
+    [[deprecated(
+        "Use Create(const sptr<IRemoteObject> &, const std::string &,const std::string &, const int &) instead.")]]
     static std::shared_ptr<DataShareHelper> Creator(const std::string &strUri, const CreateOptions &options,
-        const std::string &bundleName = "");
+        const std::string &bundleName = "", const int waitTime = 2);
 
     /**
      * @brief Creates a DataShareHelper instance, priority silent access, use non-silent access when silent is not
@@ -80,11 +87,12 @@ public:
      * @param token Indicates the System token.
      * @param strUri Indicates the database table or disk file to operate for silent access.
      * @param extUri Indicates the database table or disk file to operate for non silent access.
+     * @param waitTime connect extension waiting time.
      *
      * @return Returns the created DataShareHelper instance with a specified Uri.
      */
     static std::pair<int, std::shared_ptr<DataShareHelper>> Create(const sptr<IRemoteObject> &token,
-        const std::string &strUri, const std::string &extUri);
+        const std::string &strUri, const std::string &extUri, const int waitTime = 2);
 
     /**
      * @brief Releases the client resource of the Data share.
@@ -139,6 +147,7 @@ public:
      *
      * @return Returns the index of the inserted data record.
      */
+    [[deprecated("Use InsertEx(Uri &, const DataShareValuesBucket &) instead.")]]
     virtual int Insert(Uri &uri, const DataShareValuesBucket &value) = 0;
 
     /**
@@ -161,6 +170,7 @@ public:
      *
      * @return Returns the number of data records updated.
      */
+    [[deprecated("Use UpdateEx(Uri &, const DataSharePredicates &, const DataShareValuesBucket &) instead.")]]
     virtual int Update(Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value) = 0;
 
     /**
@@ -181,6 +191,7 @@ public:
      *
      * @return Returns the number of data records deleted.
      */
+    [[deprecated("Use DeleteEx(Uri &, const DataSharePredicates &) instead.")]]
     virtual int Delete(Uri &uri, const DataSharePredicates &predicates) = 0;
 
     /**
@@ -413,19 +424,54 @@ public:
      */
     static int SetSilentSwitch(Uri &uri, bool enable);
 
+    /**
+     * @brief Inserts a single data record into the database.
+     *
+     * @param uri Indicates the path of the data to operate.
+     * @param value  Indicates the data record to insert. If this parameter is null, a blank row will be inserted.
+     *
+     * @return Returns pair<int32_t errCode, int32_t index>, the errCode and the index of the inserted data record.
+     */
+    virtual std::pair<int32_t, int32_t> InsertEx(Uri &uri, const DataShareValuesBucket &value);
+
+    /**
+     * @brief Updates data records in the database.
+     *
+     * @param uri Indicates the path of data to update.
+     * @param predicates Indicates filter criteria. You should define the processing logic when this parameter is null.
+     * @param value Indicates the data to update. This parameter can be null.
+     *
+     * @return Returns pair<int32_t errCode, int32_t index>, the errCode and the index of data records updated.
+     */
+    virtual std::pair<int32_t, int32_t> UpdateEx(
+        Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value);
+
+    /**
+     * @brief Deletes one or more data records from the database.
+     *
+     * @param uri Indicates the path of the data to operate.
+     * @param predicates Indicates filter criteria. You should define the processing logic when this parameter is null.
+     *
+     * @return Returns pair<int32_t errCode, int32_t index>, the errCode and the index of data records deleted.
+     */
+    virtual std::pair<int32_t, int32_t> DeleteEx(Uri &uri, const DataSharePredicates &predicates);
+
 private:
-    static std::shared_ptr<DataShareHelper> CreateServiceHelper(const std::string &bundleName = "");
+    static std::shared_ptr<DataShareHelper> CreateServiceHelper(const std::string &extUri = "",
+        const std::string &bundleName = "");
 
     static int GetSilentProxyStatus(const std::string &uri);
 
-    static std::shared_ptr<DataShareHelper> CreateExtHelper(Uri &uri, const sptr<IRemoteObject> &token);
+    static std::shared_ptr<DataShareHelper> CreateExtHelper(Uri &uri, const sptr<IRemoteObject> &token,
+        const int waitTime = 2);
 
     static std::string TransferUriPrefix(const std::string &originPrefix, const std::string &replacedPrefix,
         const std::string &originUriStr);
 
     static bool IsProxy(Uri &uri);
 
-    static std::pair<int, std::shared_ptr<DataShareHelper>> CreateProxyHelper(const std::string &strUri);
+    static std::pair<int, std::shared_ptr<DataShareHelper>> CreateProxyHelper(const std::string &strUri,
+        const std::string &extUri);
 };
 } // namespace DataShare
 } // namespace OHOS
diff --git a/data_share/interfaces/inner_api/consumer/include/datashare_result_set.h b/data_share/interfaces/inner_api/consumer/include/datashare_result_set.h
index 29983c73f577e161e254f534ba9d747e358723d9..9a2a94d4979c71c7063cb29180274ac791edfc4c 100644
--- a/data_share/interfaces/inner_api/consumer/include/datashare_result_set.h
+++ b/data_share/interfaces/inner_api/consumer/include/datashare_result_set.h
@@ -17,6 +17,7 @@
 #define DATASHARE_RESULT_SET_H
 
 #include <memory>
+#include <shared_mutex>
 #include <string>
 #include <thread>
 #include <vector>
@@ -134,7 +135,7 @@ public:
     /**
      * Obtains a block from the SharedResultSet.
      */
-    AppDataFwk::SharedBlock *GetBlock() const override;
+    std::shared_ptr<AppDataFwk::SharedBlock> GetBlock() override;
 
     /**
      * Called when the position of the result set changes.
@@ -159,11 +160,12 @@ public:
     /**
      * Checks whether an DataShareResultSet object contains shared blocks.
      */
-    bool HasBlock() const;
+    bool HasBlock();
 
+    std::shared_ptr<ResultSetBridge> GetBridge();
 protected:
     int CheckState(int columnIndex);
-    void ClosedBlock();
+    void ClosedBlockAndBridge();
     virtual void Finalize();
 
     friend class ISharedResultSetStub;
@@ -178,7 +180,8 @@ private:
     // The actual position of the last row of data in the shareblock
     int endRowPos_ = -1;
     // The SharedBlock owned by this DataShareResultSet
-    AppDataFwk::SharedBlock *sharedBlock_  = nullptr;
+    std::shared_mutex mutex_;
+    std::shared_ptr<AppDataFwk::SharedBlock> sharedBlock_  = nullptr;
     std::shared_ptr<DataShareBlockWriterImpl> blockWriter_ = nullptr;
     std::shared_ptr<ResultSetBridge> bridge_ = nullptr;
 };
diff --git a/data_share/interfaces/inner_api/consumer/include/datashare_shared_result_set.h b/data_share/interfaces/inner_api/consumer/include/datashare_shared_result_set.h
index 2b5aaafd342c955e10810ef5dc902dcc1fa06290..8335aca7f56587e183f8744e20107cb32b357f37 100644
--- a/data_share/interfaces/inner_api/consumer/include/datashare_shared_result_set.h
+++ b/data_share/interfaces/inner_api/consumer/include/datashare_shared_result_set.h
@@ -30,7 +30,7 @@ public:
     /**
      * Obtains a block from the {@link SharedResultSet}
      */
-    virtual AppDataFwk::SharedBlock *GetBlock() const = 0;
+    virtual std::shared_ptr<AppDataFwk::SharedBlock> GetBlock() = 0;
     /**
      * Adds the data of a {@code SharedResultSet} to a {@link SharedBlock}
      */
diff --git a/data_share/test/native/BUILD.gn b/data_share/test/native/BUILD.gn
index f2ac1cffbedce19111e03be77be4dfe07b84af15..1fc9557d8e92e5861d2914ef626694171b778cba 100644
--- a/data_share/test/native/BUILD.gn
+++ b/data_share/test/native/BUILD.gn
@@ -404,6 +404,7 @@ ohos_unittest("ValueProxyTest") {
   deps = [ "${datashare_innerapi_path}/common:datashare_common_static" ]
 
   external_deps = [
+    "ability_base:zuri",
     "c_utils:utils",
     "hilog:libhilog",
     "ipc:ipc_single",
diff --git a/data_share/test/native/resource/datashare_ext_bundle/entry/src/main/ets/DataShareExtAbility/DataShareExtAbility.ts b/data_share/test/native/resource/datashare_ext_bundle/entry/src/main/ets/DataShareExtAbility/DataShareExtAbility.ts
index 82bf0301fca42055b311dd8657f8fff726bf0674..ea35214f1d5666bec1d8bc543b70782d687eb057 100644
--- a/data_share/test/native/resource/datashare_ext_bundle/entry/src/main/ets/DataShareExtAbility/DataShareExtAbility.ts
+++ b/data_share/test/native/resource/datashare_ext_bundle/entry/src/main/ets/DataShareExtAbility/DataShareExtAbility.ts
@@ -13,7 +13,8 @@
  * limitations under the License.
  */
 
-import Extension from '@ohos.application.DataShareExtensionAbility'
+import Extension from '@ohos.application.DataShareExtensionAbility';
+import { UpdateOperation } from '@ohos.application.DataShareExtensionAbility';
 import rdb from '@ohos.data.relationalStore';
 import rpc from '@ohos.rpc';
 
@@ -68,6 +69,25 @@ extends Extension {
         console.info('[ttt] [DataShareTest] [insert] leave');
     }
 
+    async batchUpdate(operations, callback) {
+        let recordOps : Record<string, Array<UpdateOperation>> = operations;
+        let results : Record<string, Array<number>> = {};
+        for (const [key, values] of Object.entries(recordOps)) {
+            let result : number[] = [];
+            for (const value of values) {
+                await rdbStore.update(TBL_NAME, value.values, value.predicates).then(async (rows) => {
+                    console.info('[ttt] [DataShareTest] [batchUpdate] row count is ' + rows);
+                    result.push(rows);
+                }).catch((err) => {
+                    console.info("[ttt] [DataShareTest] [batchUpdate] failed, err is " + err);
+                    result.push(-1)
+                })
+            }
+            results[key] = result;
+        }
+        callback(null, results);
+    }
+
     async update(uri, predicates, value, callback) {
         console.info('[ttt] [DataShareTest] [update] enter');
         if (predicates == null || predicates == undefined) {
diff --git a/data_share/test/native/unittest/datashareproxy_test/proxydatas_with_permission_test.cpp b/data_share/test/native/unittest/datashareproxy_test/proxydatas_with_permission_test.cpp
index adabe3e696c83e31ccc8bb6c38085d129fea0951..4ef42d23eef1df47b6228d1d715e3447def57ce4 100644
--- a/data_share/test/native/unittest/datashareproxy_test/proxydatas_with_permission_test.cpp
+++ b/data_share/test/native/unittest/datashareproxy_test/proxydatas_with_permission_test.cpp
@@ -141,11 +141,9 @@ HWTEST_F(ProxyDatasTest, ProxyDatasTest_ResultSet_Test_001, TestSize.Level0)
     resultSet->GetRowCount(result);
     EXPECT_EQ(result, 1);
 
-    AppDataFwk::SharedBlock *block = nullptr;
     bool hasBlock = resultSet->HasBlock();
     EXPECT_EQ(hasBlock, true);
-    block = resultSet->GetBlock();
-    EXPECT_NE(block, nullptr);
+    EXPECT_NE(resultSet->GetBlock(), nullptr);
 
     std::vector<uint8_t> blob;
     int err = resultSet->GetBlob(-1, blob);
diff --git a/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp b/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp
index 2b466b0ad0dfbab0efff4039761e94c97c6b62ff..2eb0d0129bc4d9a25947aae0a03214daf780dfa6 100644
--- a/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp
+++ b/data_share/test/native/unittest/mediadatashare_test/src/mediadatashare_unit_test.cpp
@@ -899,13 +899,12 @@ HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ResultSet_Test_003, TestSize.Lev
 
     bool hasBlock = resultSet->HasBlock();
     EXPECT_EQ(hasBlock, true);
-    block = resultSet->GetBlock();
-    EXPECT_NE(block, nullptr);
-
+    EXPECT_NE(resultSet->GetBlock(), nullptr);
+    block = (resultSet->GetBlock()).get();
     resultSet->SetBlock(block);
-    EXPECT_EQ(block, resultSet->GetBlock());
+    EXPECT_EQ(block, (resultSet->GetBlock()).get());
     resultSet->FillBlock(0, block);
-    EXPECT_EQ(block, resultSet->GetBlock());
+    EXPECT_EQ(block, (resultSet->GetBlock()).get());
     LOG_INFO("MediaDataShare_ResultSet_Test_003, End");
 }
 
@@ -1073,7 +1072,44 @@ HWTEST_F(MediaDataShareUnitTest, MediaDataShare_CRUD_Test_001, TestSize.Level0)
     LOG_INFO("MediaDataShare_CRUD_Test_001, End");
 }
 
-HWTEST_F(MediaDataShareUnitTest, MediaDataShare_NotImplPredicates_Test_zyp, TestSize.Level0)
+HWTEST_F(MediaDataShareUnitTest, MediaDataShare_CRUDEX_Test_001, TestSize.Level0)
+{
+    LOG_INFO("MediaDataShare_CRUDEX_Test_001::Start");
+    std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
+    ASSERT_TRUE(helper != nullptr);
+    Uri uri(MEDIALIBRARY_DATA_URI);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put("name", "Datashare_CRUDEX_Test001");
+    auto [errCode, retVal] = helper->InsertEx(uri, valuesBucket);
+    EXPECT_EQ((errCode == 0), true);
+    EXPECT_EQ((retVal >= 0), true);
+    DataShare::DataSharePredicates predicates;
+    predicates.EqualTo("name", "Datashare_CRUDEX_Test001");
+
+    valuesBucket.Clear();
+    valuesBucket.Put("name", "Datashare_CRUDEX_Test002");
+    auto [errCode1, retVal1] = helper->UpdateEx(uri, predicates, valuesBucket);
+    EXPECT_EQ((errCode1 == 0), true);
+    EXPECT_EQ((retVal1 >= 0), true);
+    DataShare::DataSharePredicates queryPredicates;
+    queryPredicates.EqualTo("name", "Datashare_CRUDEX_Test002");
+    vector<string> columns;
+    auto resultSet = helper->Query(uri, queryPredicates, columns);
+    int result = 0;
+    if (resultSet != nullptr) {
+        resultSet->GetRowCount(result);
+    }
+    EXPECT_EQ(result, 1);
+
+    DataShare::DataSharePredicates deletePredicates;
+    deletePredicates.EqualTo("name", "Datashare_CRUDEX_Test002'");
+    auto [errCode2, retVal2] = helper->DeleteEx(uri, deletePredicates);
+    EXPECT_EQ((errCode2 == 0), true);
+    EXPECT_EQ((retVal2 >= 0), true);
+    LOG_INFO("MediaDataShare_CRUDEX_Test_001, End");
+}
+
+HWTEST_F(MediaDataShareUnitTest, MediaDataShare_ImplPredicates_Test_001, TestSize.Level0)
 {
     LOG_INFO("MediaDataShare_ImplPredicates_Test_001::Start");
     DataShare::DataSharePredicates predicates;
@@ -1574,5 +1610,68 @@ HWTEST_F(MediaDataShareUnitTest, MediaDataShare_UnregisterObserverExt_002, TestS
     dataObserver->Clear();
     LOG_INFO("MediaDataShare_UnregisterObserverExt_002 end");
 }
+
+HWTEST_F(MediaDataShareUnitTest, MediaDataShare_BatchUpdate_Test_001, TestSize.Level0)
+{
+    LOG_INFO("MediaDataShare_BatchUpdate_Test_001::Start");
+    std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
+    ASSERT_TRUE(helper != nullptr);
+    Uri uri(MEDIALIBRARY_DATA_URI);
+    DataShare::DataShareValuesBucket valuesBucket;
+    valuesBucket.Put("name", "batchUpdateTest");
+    int ret = helper->Insert(uri, valuesBucket);
+    EXPECT_GT(ret, 0);
+
+    DataShare::UpdateOperations operations;
+    std::vector<DataShare::UpdateOperation> updateOperations1;
+    DataShare::UpdateOperation updateOperation1;
+    updateOperation1.valuesBucket.Put("name", "batchUpdateTested");
+    updateOperation1.predicates.EqualTo("name", "batchUpdateTest");
+    updateOperations1.push_back(updateOperation1);
+
+    std::vector<DataShare::UpdateOperation> updateOperations2;
+    DataShare::UpdateOperation updateOperation2;
+    updateOperation2.valuesBucket.Put("name", "undefined1");
+    updateOperation2.predicates.EqualTo("name", "undefined");
+    updateOperations1.push_back(updateOperation2);
+    updateOperations2.push_back(updateOperation2);
+
+    operations.emplace("uri1", updateOperations1);
+    operations.emplace("uri2", updateOperations2);
+    std::vector<BatchUpdateResult> results;
+    ret = helper->BatchUpdate(operations, results);
+    EXPECT_EQ(results.size(), 2);
+    EXPECT_EQ(results[0].codes[0], 1);
+    EXPECT_EQ(results[0].codes[1], 0);
+    EXPECT_EQ(results[1].codes[0], 0);
+    DataShare::DataSharePredicates predicates3;
+    predicates3.EqualTo("name", "batchUpdateTested");
+    ret = helper->Delete(uri, predicates3);
+    EXPECT_GT(ret, 0);
+    LOG_INFO("MediaDataShare_BatchUpdate_Test_001 End");
+}
+
+HWTEST_F(MediaDataShareUnitTest, MediaDataShare_BatchUpdateThanLimit_Test_001, TestSize.Level0)
+{
+    LOG_INFO("MediaDataShare_BatchUpdateThanLimit_Test_001::Start");
+    std::shared_ptr<DataShare::DataShareHelper> helper = g_dataShareHelper;
+    ASSERT_TRUE(helper != nullptr);
+    Uri uri(MEDIALIBRARY_DATA_URI);
+
+    DataShare::UpdateOperations operations;
+    std::vector<DataShare::UpdateOperation> updateOperations1;
+    DataShare::UpdateOperation updateOperation1;
+    updateOperation1.valuesBucket.Put("name", "batchUpdateTested");
+    updateOperation1.predicates.EqualTo("name", "batchUpdateTest");
+    for (int i = 0; i < 4001; i++) {
+        updateOperations1.push_back(updateOperation1);
+    }
+    operations.emplace("uri1", updateOperations1);
+    std::vector<BatchUpdateResult> results;
+    int ret = helper->BatchUpdate(operations, results);
+    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(results.size(), 0);
+    LOG_INFO("MediaDataShare_BatchUpdateThanLimit_Test_001 End");
+}
 } // namespace DataShare
 } // namespace OHOS
\ No newline at end of file
diff --git a/data_share/test/native/unittest/mediadatashare_test/src/slientaccess_test.cpp b/data_share/test/native/unittest/mediadatashare_test/src/slientaccess_test.cpp
index a5ab5b7aa9c360aeeea4294d7dad1989a14d32a3..bc6a74f65ee96fe640f4e15fc8eb448d530f4d35 100644
--- a/data_share/test/native/unittest/mediadatashare_test/src/slientaccess_test.cpp
+++ b/data_share/test/native/unittest/mediadatashare_test/src/slientaccess_test.cpp
@@ -83,6 +83,7 @@ protected:
     std::string TBL_STU_NAME = "name";
     std::string TBL_STU_AGE = "age";
     std::string SLIENT_ACCESS_PERMISSION1_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission1?Proxy=true";
+    std::string SLIENT_ERROR_URI = "datashare:///com.acts.datashare/entry/DB00/TBL00?Proxy=true";
     std::string SLIENT_PROXY_PERMISSION1_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission1";
     std::string SLIENT_ACCESS_PERMISSION2_URI = "datashare:///com.acts.datasharetest/entry/DB00/permission2?Proxy=true";
     std::string SLIENT_PROXY_PERMISSION2_URI = "datashareproxy://com.acts.datasharetest/entry/DB00/permission2";
@@ -218,6 +219,126 @@ void SlientAccessTest::TearDownTestCase(void)
 void SlientAccessTest::SetUp(void) {}
 void SlientAccessTest::TearDown(void) {}
 
+HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_001, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::Start");
+    std::string uriStr1(SLIENT_ACCESS_URI);
+    std::string uriStr2 (DATA_SHARE_URI);
+    auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (saManager == nullptr) {
+        LOG_ERROR("GetSystemAbilityManager get samgr failed.");
+    }
+    auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
+    if (remoteObj == nullptr) {
+        LOG_ERROR("GetSystemAbility service failed.");
+    }
+    auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
+    EXPECT_EQ(ret, DataShare::E_OK);
+    EXPECT_NE(helper, nullptr);
+    helper = nullptr;
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_001::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_002, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::Start");
+    std::string uriStr1(SLIENT_ACCESS_URI);
+    std::string uriStr2 (DATA_SHARE_URI);
+    auto [ret, helper] = DataShare::DataShareHelper::Create(nullptr, uriStr1, uriStr2);
+    EXPECT_EQ(ret, DataShare::E_TOKEN_EMPTY);
+    EXPECT_EQ(helper, nullptr);
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_002::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_003, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::Start");
+    std::string uriStr1(SLIENT_ERROR_URI);
+    std::string uriStr2 (DATA_SHARE_URI);
+    auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (saManager == nullptr) {
+        LOG_ERROR("GetSystemAbilityManager get samgr failed.");
+    }
+    auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
+    if (remoteObj == nullptr) {
+        LOG_ERROR("GetSystemAbility service failed.");
+    }
+    auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
+    EXPECT_EQ(ret, DataShare::E_BUNDLE_NAME_NOT_EXIST);
+    EXPECT_EQ(helper, nullptr);
+    helper = nullptr;
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_003::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_Creator_Errorcode_Test_004, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::Start");
+    std::string uriStr1(DATA_SHARE_URI);
+    std::string uriStr2 (DATA_SHARE_URI);
+    auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (saManager == nullptr) {
+        LOG_ERROR("GetSystemAbilityManager get samgr failed.");
+    }
+    auto remoteObj = saManager->GetSystemAbility(STORAGE_MANAGER_MANAGER_ID);
+    if (remoteObj == nullptr) {
+        LOG_ERROR("GetSystemAbility service failed.");
+    }
+    auto [ret, helper] = DataShare::DataShareHelper::Create(remoteObj, uriStr1, uriStr2);
+    EXPECT_EQ(ret, DataShare::E_OK);
+    EXPECT_NE(helper, nullptr);
+    helper = nullptr;
+    LOG_INFO("SlientAccess_Creator_Errorcode_Test_004::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_InsertEx_Test_001, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_InsertEx_Test_001::Start");
+    auto helper = g_slientAccessHelper;
+    Uri uri(SLIENT_ACCESS_URI);
+    DataShare::DataShareValuesBucket valuesBucket;
+    std::string value = "lisi";
+    valuesBucket.Put(TBL_STU_NAME, value);
+    int age = 25;
+    valuesBucket.Put(TBL_STU_AGE, age);
+
+    auto [errCode, retVal] = helper->InsertEx(uri, valuesBucket);
+    EXPECT_EQ((errCode == 0), true);
+    EXPECT_EQ((retVal > 0), true);
+    LOG_INFO("SlientAccess_InsertEx_Test_001::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_UpdateEx_Test_001, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_UpdateEx_Test_001::Start");
+    auto helper = g_slientAccessHelper;
+    Uri uri(SLIENT_ACCESS_URI);
+    DataShare::DataShareValuesBucket valuesBucket;
+    int value = 50;
+    valuesBucket.Put(TBL_STU_AGE, value);
+    DataShare::DataSharePredicates predicates;
+    std::string selections = TBL_STU_NAME + " = 'lisi'";
+    predicates.SetWhereClause(selections);
+    auto [errCode, retVal] = helper->UpdateEx(uri, predicates, valuesBucket);
+    EXPECT_EQ((errCode == 0), true);
+    EXPECT_EQ((retVal > 0), true);
+    LOG_INFO("SlientAccess_UpdateEx_Test_001::End");
+}
+
+HWTEST_F(SlientAccessTest, SlientAccess_DeleteEx_Test_001, TestSize.Level0)
+{
+    LOG_INFO("SlientAccess_DeleteEx_Test_001::Start");
+    auto helper = g_slientAccessHelper;
+    Uri uri(SLIENT_ACCESS_URI);
+
+    DataShare::DataSharePredicates deletePredicates;
+    std::string selections = TBL_STU_NAME + " = 'lisi'";
+    deletePredicates.SetWhereClause(selections);
+    auto [errCode, retVal] = helper->DeleteEx(uri, deletePredicates);
+    EXPECT_EQ((errCode == 0), true);
+    EXPECT_EQ((retVal > 0), true);
+    LOG_INFO("SlientAccess_DeleteEx_Test_001::End");
+}
+
 HWTEST_F(SlientAccessTest, SlientAccess_Insert_Test_001, TestSize.Level0)
 {
     LOG_INFO("SlientAccess_Insert_Test_001::Start");
diff --git a/datamgr_service/bundle.json b/datamgr_service/bundle.json
index c4a0ef434248559bdeba768ca403ef9ca822d0d1..3d202f77f9ca819bc51277026e36ba3a3454bde4 100644
--- a/datamgr_service/bundle.json
+++ b/datamgr_service/bundle.json
@@ -80,6 +80,7 @@
                 "resource_management",
                 "safwk",
                 "samgr",
+                "screenlock_mgr",
                 "time_service",
                 "udmf",
                 "app_file_service",
@@ -107,6 +108,7 @@
                     "name": "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/framework:distributeddatasvcfwk",
                     "header": {
                         "header_files": [
+                            "account/account_delegate.h",
                             "backuprule/backup_rule_manager.h",
                             "checker/checker_manager.h",
                             "cloud/asset_loader.h",
@@ -135,6 +137,7 @@
                             "metadata/store_meta_data_local.h",
                             "metadata/strategy_meta_data.h",
                             "metadata/user_meta_data.h",
+                            "screen/screen_manager.h",
                             "serializable/serializable.h",
                             "snapshot/bind_event.h",
                             "snapshot/machine_status.h",
diff --git a/datamgr_service/services/distributeddataservice/adapter/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/BUILD.gn
index ae76a3ce05c556d556e10e88c28317866cacb3cd..15f7c5f80409ee949dc0c5e2a6263b5cb0bb44aa 100644
--- a/datamgr_service/services/distributeddataservice/adapter/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/adapter/BUILD.gn
@@ -54,13 +54,18 @@ ohos_shared_library("distributeddata_adapter") {
 
   configs = [ ":distributeddata_adapter_private_config" ]
   deps = [
+    "${data_service_path}/adapter/account:distributeddata_account_static",
+    "${data_service_path}/adapter/communicator:distributeddata_communicator_static",
+    "${data_service_path}/adapter/dfx:distributeddata_dfx_static",
+    "${data_service_path}/adapter/permission:distributeddata_permission_static",
     "${data_service_path}/framework:distributeddatasvcfwk",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/account:distributeddata_account_static",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/communicator:distributeddata_communicator_static",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/dfx:distributeddata_dfx_static",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/permission:distributeddata_permission_static",
   ]
 
+  if (defined(global_parts_info) &&
+      defined(global_parts_info.theme_screenlock_mgr)) {
+    deps += [ "${data_service_path}/adapter/screenlock:distributeddata_screenlock_static" ]
+  }
+
   external_deps = [
     "c_utils:utils",
     "hilog:libhilog",
diff --git a/datamgr_service/services/distributeddataservice/adapter/CMakeLists.txt b/datamgr_service/services/distributeddataservice/adapter/CMakeLists.txt
index 3f76667f64ea9b96c5cda1173337b03054bb2dcc..3b7c83fd04d0bdfdd70e3f25b102c8368c1fd89d 100644
--- a/datamgr_service/services/distributeddataservice/adapter/CMakeLists.txt
+++ b/datamgr_service/services/distributeddataservice/adapter/CMakeLists.txt
@@ -19,6 +19,7 @@ aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/dfx/src/fault adapterSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/dfx/src/statistic adapterSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/dfx/src adapterSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/permission/src adapterSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/screenlock/src adapterSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/utils/src adapterSrc)
 list(REMOVE_ITEM adapterSrc "${CMAKE_CURRENT_SOURCE_DIR}/account/src/account_delegate_default_impl.cpp")
 
@@ -50,4 +51,5 @@ target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/br
 target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/communicator)
 target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/dfx)
 target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/permission)
+target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/screenlock)
 target_include_directories(adapter PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/utils)
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/account/BUILD.gn
index 95465797ce4eb1ea4b0382aa0f86e502a09a748b..2bc40d6e4c1560edd1bd02d6e24868b246ae9bdb 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/adapter/account/BUILD.gn
@@ -22,13 +22,10 @@ ohos_static_library("distributeddata_account_static") {
     boundary_sanitize = true
     ubsan = true
   }
-  sources = [
-    "src/account_delegate.cpp",
-    "src/account_delegate_impl.cpp",
-  ]
+  sources = [ "src/account_delegate_impl.cpp" ]
 
   include_dirs = [
-    "../include/account",
+    "../../framework/include/account",
     "../include/autils",
     "../include/log",
     "../include/permission",
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp
index 7cf335879f4fa11584617f47560f1a91f8f3c6f3..444d7b29986cdc7e7d99098cdd69d7464038aa6b 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.cpp
@@ -22,13 +22,7 @@ namespace DistributedKv {
 namespace {
     constexpr const char *DEFAULT_OHOS_ACCOUNT_UID = ""; // default UID
 }
-
-AccountDelegate::BaseInstance AccountDelegate::getInstance_ = AccountDelegateDefaultImpl::GetBaseInstance;
-AccountDelegate *AccountDelegateDefaultImpl::GetBaseInstance()
-{
-    static AccountDelegateDefaultImpl accountDelegate;
-    return &accountDelegate;
-}
+__attribute__((used)) static bool g_isInit = AccountDelegateDefaultImpl::Init();
 
 std::string AccountDelegateDefaultImpl::GetCurrentAccountId() const
 {
@@ -87,5 +81,13 @@ void AccountDelegateDefaultImpl::BindExecutor(std::shared_ptr<ExecutorPool> exec
 {
     ZLOGD("no account part");
 }
-}  // namespace DistributedKv
+
+bool AccountDelegateDefaultImpl::Init()
+{
+    static AccountDelegateDefaultImpl defaultAccountDelegate;
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [&]() { AccountDelegate::RegisterAccountInstance(&defaultAccountDelegate); });
+    return true;
+}
+} // namespace DistributedKv
 }  // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.h b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.h
index 74298cb527cf025187096a84e660cde313f13f3a..04ebda1d6e45fd6e1de5073019b2fad5c0bde08b 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.h
+++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_default_impl.h
@@ -21,7 +21,6 @@ namespace OHOS {
 namespace DistributedKv {
 class AccountDelegateDefaultImpl final : public AccountDelegateImpl {
 public:
-    static AccountDelegate *GetBaseInstance();
     std::string GetCurrentAccountId() const override;
     int32_t GetUserByToken(uint32_t tokenId) const override;
     bool QueryUsers(std::vector<int> &users) override;
@@ -31,6 +30,7 @@ public:
     void SubscribeAccountEvent() override;
     void UnsubscribeAccountEvent() override;
     void BindExecutor(std::shared_ptr<ExecutorPool> executors) override;
+    static bool Init();
 
 private:
     ~AccountDelegateDefaultImpl();
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.cpp b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.cpp
index edc5a7a95a82e6afc44e29427c6f7d976caa4bdc..e59d08a22b9b51369673673cda2d2dd7f52a84c6 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.cpp
@@ -17,7 +17,6 @@
 #include "account_delegate_normal_impl.h"
 #include <algorithm>
 #include <endian.h>
-#include <list>
 #include <regex>
 #include <thread>
 #include <unistd.h>
@@ -32,12 +31,7 @@ using namespace OHOS::EventFwk;
 using namespace OHOS::AAFwk;
 using namespace OHOS::DistributedData;
 using namespace Security::AccessToken;
-AccountDelegate::BaseInstance AccountDelegate::getInstance_ = AccountDelegateNormalImpl::GetBaseInstance;
-AccountDelegate *AccountDelegateNormalImpl::GetBaseInstance()
-{
-    static AccountDelegateNormalImpl accountDelegate;
-    return &accountDelegate;
-}
+__attribute__((used)) static bool g_isInit = AccountDelegateNormalImpl::Init();
 
 std::string AccountDelegateNormalImpl::GetCurrentAccountId() const
 {
@@ -216,7 +210,20 @@ std::string AccountDelegateNormalImpl::GetUnencryptedAccountId(int32_t userId) c
 
 bool AccountDelegateNormalImpl::QueryForegroundUserId(int &foregroundUserId)
 {
-    return AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(foregroundUserId);
+    int32_t status = AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(foregroundUserId);
+    if (status != ERR_OK) {
+        ZLOGE("GetForegroundOsAccountLocalId failed, status: %{public}d", status);
+        return false;
+    }
+    return true;
+}
+
+bool AccountDelegateNormalImpl::Init()
+{
+    static AccountDelegateNormalImpl normalAccountDelegate;
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [&]() { AccountDelegate::RegisterAccountInstance(&normalAccountDelegate); });
+    return true;
 }
-}  // namespace DistributedKv
+} // namespace DistributedKv
 }  // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.h b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.h
index 758e25d4178d5e0a71c7c4434e5507438611c0b8..63c86d66243187fbc4e176f30baf4204194033e7 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.h
+++ b/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate_normal_impl.h
@@ -26,7 +26,6 @@ namespace OHOS {
 namespace DistributedKv {
 class AccountDelegateNormalImpl final : public AccountDelegateImpl {
 public:
-    static AccountDelegate *GetBaseInstance();
     std::string GetCurrentAccountId() const override;
     int32_t GetUserByToken(uint32_t tokenId) const override;
     bool QueryUsers(std::vector<int> &users) override;
@@ -38,6 +37,7 @@ public:
     void BindExecutor(std::shared_ptr<ExecutorPool> executors) override;
     std::string GetUnencryptedAccountId(int32_t userId = 0) const override;
     bool QueryForegroundUserId(int &foregroundUserId) override;
+    static bool Init();
 
 private:
     ~AccountDelegateNormalImpl();
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/test/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/account/test/BUILD.gn
index 1fb62f2e83fa3f2df1de64e589511b4810ffb1fe..3b3df7fe0223d123b0e44b0675d0973c7e385ae6 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/test/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/adapter/account/test/BUILD.gn
@@ -18,10 +18,13 @@ module_output_path = "datamgr_service/distributeddatafwk"
 ohos_unittest("AccountDelegateTest") {
   module_out_path = module_output_path
 
-  sources = [ "account_delegate_test.cpp" ]
+  sources = [
+    "${data_service_path}/framework/account/account_delegate.cpp",
+    "account_delegate_test.cpp",
+  ]
   include_dirs = [
     "//commonlibrary/c_utils/base/include",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/include/account",
+    "${data_service_path}/framework/include/account",
     "//foundation/distributeddatamgr/kv_store/interfaces/innerkits/distributeddata/include",
     "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/include/autils",
     "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/include/utils",
@@ -51,6 +54,13 @@ ohos_unittest("AccountDelegateTest") {
     "os_account:libaccountkits",
     "os_account:os_account_innerkits",
   ]
+  if (os_account_part_is_enabled) {
+    sources += [ "${data_service_path}/adapter/account/src/account_delegate_normal_impl.cpp" ]
+    cflags_cc = [ "-DOS_ACCOUNT_PART_IS_ENABLED" ]
+    external_deps += [ "access_token:libaccesstoken_sdk" ]
+  } else {
+    sources += [ "${data_service_path}/adapter/account/src/account_delegate_default_impl.cpp" ]
+  }
   defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ]
 }
 
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp
index 1f9db2632ae357eb76c8f66c0fbe1dcf89356632..cd9f85c726f63758895f8fff8ef1d0d51de625f7 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp
@@ -747,4 +747,14 @@ std::string DeviceManagerAdapter::GetEncryptedUuidByNetworkId(const std::string
     }
     return encryptedUuid;
 }
+
+bool DeviceManagerAdapter::IsSameAccount(const std::string &id)
+{
+    if (id.empty()) {
+        ZLOGE("params id is empty");
+        return false;
+    }
+    auto networkId = DeviceManagerAdapter::GetInstance().ToNetworkID(id);
+    return DeviceManager::GetInstance().IsSameAccount(networkId);
+}
 } // namespace OHOS::DistributedData
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
index 3d1638982d936057e9a4e074e7724f116e3a0787..c1d5ffeaf11f492fe568288c348aae8141a813b5 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
@@ -91,6 +91,10 @@ private:
     std::string DelConnect(int32_t socket);
     void StartCloseSessionTask(const std::string &deviceId);
     Task GetCloseSessionTask();
+    bool CloseSession(const std::string &networkId);
+    void Reuse(const PipeInfo &pipeInfo, const DeviceId &deviceId,
+        uint32_t qosType, std::shared_ptr<SoftBusClient> &conn);
+    void GetExpireTime(std::shared_ptr<SoftBusClient> &conn);
     static constexpr const char *PKG_NAME = "distributeddata-default";
     static constexpr Time INVALID_NEXT = std::chrono::steady_clock::time_point::max();
     static constexpr uint32_t QOS_COUNT = 3;
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
index e5237c4a531be5a360fffcb76ed08b05ef459c5f..0827053dd03c0dc42fd3c579571769841d4a3cc0 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
@@ -17,6 +17,7 @@
 #include <thread>
 
 #include "communicator_context.h"
+#include "communication/connect_manager.h"
 #include "data_level.h"
 #include "device_manager_adapter.h"
 #include "dfx_types.h"
@@ -108,6 +109,15 @@ SoftBusAdapter::SoftBusAdapter()
     Context::GetInstance().SetSessionListener([this](const std::string &deviceId) {
         StartCloseSessionTask(deviceId);
     });
+
+    ConnectManager::GetInstance()->RegisterCloseSessionTask([this](const std::string &networkId) {
+        return CloseSession(networkId);
+    });
+    ConnectManager::GetInstance()->RegisterSessionCloseListener("context", [](const std::string &networkId) {
+        auto uuid = DmAdapter::GetInstance().GetUuidByNetworkId(networkId);
+        Context::GetInstance().NotifySessionClose(uuid);
+    });
+    ConnectManager::GetInstance()->OnStart();
 }
 
 SoftBusAdapter::~SoftBusAdapter()
@@ -117,6 +127,7 @@ SoftBusAdapter::~SoftBusAdapter()
         UnregDataLevelChangeCb(PKG_NAME);
     }
     connects_.Clear();
+    ConnectManager::GetInstance()->OnDestory();
 }
 
 std::shared_ptr<SoftBusAdapter> SoftBusAdapter::GetInstance()
@@ -155,38 +166,77 @@ Status SoftBusAdapter::StopWatchDataChange(__attribute__((unused)) const AppData
     return Status::ERROR;
 }
 
+void SoftBusAdapter::Reuse(const PipeInfo &pipeInfo, const DeviceId &deviceId,
+    uint32_t qosType, std::shared_ptr<SoftBusClient> &conn)
+{
+    std::vector<std::shared_ptr<SoftBusClient>> connects;
+    auto connect = std::make_shared<SoftBusClient>(pipeInfo, deviceId, qosType);
+    connect->isReuse = true;
+    connects.emplace_back(connect);
+    conn = connect;
+    connects_.Insert(deviceId.deviceId, connects);
+    ZLOGI("reuse connect:%{public}s", KvStoreUtils::ToBeAnonymous(deviceId.deviceId).c_str());
+}
+
+void SoftBusAdapter::GetExpireTime(std::shared_ptr<SoftBusClient> &conn)
+{
+    Time now = std::chrono::steady_clock::now();
+    auto expireTime = conn->GetExpireTime() > now ? conn->GetExpireTime() : now;
+    lock_guard<decltype(taskMutex_)> lock(taskMutex_);
+    if (taskId_ != ExecutorPool::INVALID_TASK_ID && expireTime < next_) {
+        taskId_ = Context::GetInstance().GetThreadPool()->Reset(taskId_, expireTime - now);
+        next_ = expireTime;
+    }
+}
+
 Status SoftBusAdapter::SendData(const PipeInfo &pipeInfo, const DeviceId &deviceId, const DataInfo &dataInfo,
     uint32_t length, const MessageInfo &info)
 {
     std::shared_ptr<SoftBusClient> conn;
-    bool isReady = DmAdapter::GetInstance().IsDeviceReady(deviceId.deviceId);
-    uint32_t qosType = isReady ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
+    bool isOHOSType = DmAdapter::GetInstance().IsOHOSType(deviceId.deviceId);
+    uint32_t qosType = isOHOSType ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
+    bool isReuse = false;
     connects_.Compute(deviceId.deviceId,
-        [&pipeInfo, &deviceId, &conn, qosType](const auto &key,
+        [&pipeInfo, &deviceId, &conn, qosType, isOHOSType, &isReuse](const auto &key,
             std::vector<std::shared_ptr<SoftBusClient>> &connects) -> bool {
             for (auto &connect : connects) {
-                if (connect->GetQoSType() == qosType) {
-                    conn = connect;
-                    return true;
+                if (connect->GetQoSType() != qosType) {
+                    continue;
+                }
+                if (!isOHOSType && connect->needRemove) {
+                    isReuse = true;
+                    return false;
                 }
+                conn = connect;
+                return true;
             }
             auto connect = std::make_shared<SoftBusClient>(pipeInfo, deviceId, qosType);
             connects.emplace_back(connect);
             conn = connect;
             return true;
         });
+    if (!isOHOSType && isReuse) {
+        Reuse(pipeInfo, deviceId, qosType, conn);
+    }
     if (conn == nullptr) {
         return Status::ERROR;
     }
-    auto status = conn->SendData(dataInfo, &clientListener_);
+    auto status = conn->CheckStatus();
+    if (status == Status::RATE_LIMIT) {
+        return Status::RATE_LIMIT;
+    }
+    if (status != Status::SUCCESS) {
+        auto task = [this, conn]() {
+            conn->OpenConnect(&clientListener_);
+        };
+        auto networkId = DmAdapter::GetInstance().GetDeviceInfo(deviceId.deviceId).networkId;
+        ConnectManager::GetInstance()->ApplyConnect(networkId, task);
+        return Status::RATE_LIMIT;
+    }
+
+    status = conn->SendData(dataInfo, &clientListener_);
     if ((status != Status::NETWORK_ERROR) && (status != Status::RATE_LIMIT)) {
-        Time now = std::chrono::steady_clock::now();
-        auto expireTime = conn->GetExpireTime() > now ? conn->GetExpireTime() : now;
-        lock_guard<decltype(taskMutex_)> lock(taskMutex_);
-        if (taskId_ != ExecutorPool::INVALID_TASK_ID && expireTime < next_) {
-            taskId_ = Context::GetInstance().GetThreadPool()->Reset(taskId_, expireTime - now);
-            next_ = expireTime;
-        }
+        GetExpireTime(conn);
     }
     return status;
 }
@@ -194,8 +244,8 @@ Status SoftBusAdapter::SendData(const PipeInfo &pipeInfo, const DeviceId &device
 void SoftBusAdapter::StartCloseSessionTask(const std::string &deviceId)
 {
     std::shared_ptr<SoftBusClient> conn;
-    bool isReady = DmAdapter::GetInstance().IsDeviceReady(deviceId);
-    uint32_t qosType = isReady ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
+    bool isOHOSType = DmAdapter::GetInstance().IsOHOSType(deviceId);
+    uint32_t qosType = isOHOSType ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
     auto connects = connects_.Find(deviceId);
     if (!connects.first) {
         return;
@@ -243,7 +293,7 @@ SoftBusAdapter::Task SoftBusAdapter::GetCloseSessionTask()
         });
         connects_.EraseIf([](const auto &key, const auto &conn) -> bool {
             if (conn.empty()) {
-                Context::GetInstance().NotifySessionClose(key);
+                ConnectManager::GetInstance()->OnSessionClose(DmAdapter::GetInstance().GetDeviceInfo(key).networkId);
             }
             return conn.empty();
         });
@@ -316,7 +366,8 @@ uint32_t SoftBusAdapter::GetTimeout(const DeviceId &deviceId)
 std::string SoftBusAdapter::DelConnect(int32_t socket)
 {
     std::string name;
-    connects_.ForEach([socket, &name](const auto &deviceId, auto &connects) -> bool {
+    std::set<std::string> closedConnect;
+    connects_.EraseIf([socket, &name, &closedConnect](const auto &deviceId, auto &connects) -> bool {
         for (auto iter = connects.begin(); iter != connects.end();) {
             if (*iter != nullptr && **iter == socket) {
                 name += deviceId;
@@ -326,8 +377,16 @@ std::string SoftBusAdapter::DelConnect(int32_t socket)
                 iter++;
             }
         }
+        if (connects.empty()) {
+            closedConnect.insert(deviceId);
+            return true;
+        }
         return false;
     });
+    for (const auto &deviceId : closedConnect) {
+        auto networkId = DmAdapter::GetInstance().GetDeviceInfo(deviceId).networkId;
+        ConnectManager::GetInstance()->OnSessionClose(networkId);
+    }
     return name;
 }
 
@@ -506,6 +565,18 @@ void SoftBusAdapter::OnBind(int32_t socket, PeerSocketInfo info)
     socketInfo.networkId = info.networkId;
     socketInfo.pkgName = info.pkgName;
     peerSocketInfos_.Insert(socket, socketInfo);
+    if (!DmAdapter::GetInstance().IsOHOSType(info.networkId)) {
+        auto uuid = DmAdapter::GetInstance().ToUUID(info.networkId);
+        auto connects = connects_.Find(uuid);
+        if (!connects.first) {
+            return;
+        }
+        for (auto &conn : connects.second) {
+            if (!conn->isReuse) {
+                conn->needRemove = true;
+            }
+        }
+    }
 }
 
 void SoftBusAdapter::OnServerShutdown(int32_t socket)
@@ -518,5 +589,15 @@ void SoftBusAdapter::OnDeviceChanged(const AppDistributedKv::DeviceInfo &info,
 {
     return;
 }
+
+bool SoftBusAdapter::CloseSession(const std::string &networkId)
+{
+    auto uuid = DmAdapter::GetInstance().GetUuidByNetworkId(networkId);
+    auto ret = connects_.Erase(uuid);
+    if (ret != 0) {
+        ConnectManager::GetInstance()->OnSessionClose(networkId);
+    }
+    return ret != 0;
+}
 } // namespace AppDistributedKv
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
index f46d4e0d9d89b28ee7ffb3da675bad367320e745..304b8cd204974fd2da2bac1368c6ea046a50660c 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
@@ -17,6 +17,7 @@
 #include "softbus_client.h"
 
 #include "communicator_context.h"
+#include "communication/connect_manager.h"
 #include "device_manager_adapter.h"
 #include "inner_socket.h"
 #include "kvstore_utils.h"
@@ -64,7 +65,7 @@ uint32_t SoftBusClient::GetTimeout() const
 Status SoftBusClient::SendData(const DataInfo &dataInfo, const ISocketListener *listener)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto result = OpenConnect(listener);
+    auto result = CheckStatus();
     if (result != Status::SUCCESS) {
         return result;
     }
@@ -81,15 +82,14 @@ Status SoftBusClient::SendData(const DataInfo &dataInfo, const ISocketListener *
 
 Status SoftBusClient::OpenConnect(const ISocketListener *listener)
 {
-    if (bindState_ == 0) {
-        return Status ::SUCCESS;
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto status = CheckStatus();
+    if (status == Status::SUCCESS || status == Status::RATE_LIMIT) {
+        return status;
     }
     if (isOpening_.exchange(true)) {
         return Status::RATE_LIMIT;
     }
-    if (bindState_ == 0) {
-        return Status ::SUCCESS;
-    }
     SocketInfo socketInfo;
     std::string peerName = pipe_.pipeId;
     socketInfo.peerName = const_cast<char *>(peerName.c_str());
@@ -122,6 +122,20 @@ Status SoftBusClient::OpenConnect(const ISocketListener *listener)
     return Status::RATE_LIMIT;
 }
 
+Status SoftBusClient::CheckStatus()
+{
+    if (bindState_ == 0) {
+        return Status::SUCCESS;
+    }
+    if (isOpening_.load()) {
+        return Status::RATE_LIMIT;
+    }
+    if (bindState_ == 0) {
+        return Status::SUCCESS;
+    }
+    return Status::ERROR;
+}
+
 Status SoftBusClient::Open(int32_t socket, const QosTV qos[], const ISocketListener *listener)
 {
     int32_t status = ::Bind(socket, qos, QOS_COUNT, listener);
@@ -149,6 +163,7 @@ Status SoftBusClient::Open(int32_t socket, const QosTV qos[], const ISocketListe
     }
     ZLOGI("open %{public}s, session:%{public}s success, socket:%{public}d",
         KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), socket_);
+    ConnectManager::GetInstance()->OnSessionOpen(DmAdapter::GetInstance().GetDeviceInfo(device_.deviceId).networkId);
     return Status::SUCCESS;
 }
 
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h
index b20cf012d05ac8a873192fcb7a7d6fba6bcc8966..898a7ada78d279c172d443f218311f9b666a0477 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/src/softbus_client.h
@@ -37,6 +37,8 @@ public:
 
     using Time = std::chrono::steady_clock::time_point;
     using Duration = std::chrono::steady_clock::duration;
+    Status CheckStatus();
+    Status OpenConnect(const ISocketListener *listener);
     Status SendData(const DataInfo &dataInfo, const ISocketListener *listener);
     bool operator==(int32_t socket) const;
     bool operator==(const std::string &deviceId) const;
@@ -46,9 +48,10 @@ public:
     int32_t GetSocket() const;
     uint32_t GetQoSType() const;
     void UpdateExpireTime();
+    bool needRemove = false;
+    bool isReuse = false;
 
 private:
-    Status OpenConnect(const ISocketListener *listener);
     Status Open(int32_t socket, const QosTV qos[], const ISocketListener *listener);
     std::pair<int32_t, uint32_t> GetMtu(int32_t socket);
     Time CalcExpireTime() const;
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn
index a7c54aff81950fd9b817d994d126740b98060939..3ee6efe2e6612b7a1f2bf07d736ce21f5c7efb9b 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/BUILD.gn
@@ -26,6 +26,7 @@ ohos_fuzztest("SoftBusAdapterFuzzTest") {
     "${data_service_path}/adapter/include/autils",
     "${data_service_path}/adapter/include/utils",
     "${data_service_path}/adapter/communicator/src",
+    "${data_service_path}/framework/include",
     "${dsoftbus_core_path}",
     "${kv_store_common_path}",
     "${kv_store_distributeddb_path}/interfaces/include",
diff --git a/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/softbus_adapter_standard_test.cpp b/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/softbus_adapter_standard_test.cpp
index d0c91821c843c44a00eb7cabab15b51e0d2290d8..9804ce14f625c7850cf3eb85088e90ab4dd4bb19 100644
--- a/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/softbus_adapter_standard_test.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/communicator/test/unittest/softbus_adapter_standard_test.cpp
@@ -19,7 +19,6 @@
 #include "gtest/gtest.h"
 #include <iostream>
 #include "log_print.h"
-#define private public
 #include "softbus_adapter.h"
 #include "types.h"
 #include <unistd.h>
diff --git a/datamgr_service/services/distributeddataservice/adapter/dfx/src/radar_reporter.cpp b/datamgr_service/services/distributeddataservice/adapter/dfx/src/radar_reporter.cpp
index 56048427b341ad1dd2e48b68db4f980a1f5b0f92..0a22c8f60eaced073e65f35d05dc9c35e68bbfcd 100644
--- a/datamgr_service/services/distributeddataservice/adapter/dfx/src/radar_reporter.cpp
+++ b/datamgr_service/services/distributeddataservice/adapter/dfx/src/radar_reporter.cpp
@@ -49,14 +49,14 @@ void RadarReporter::Report(const RadarParam &param, const char *funcName, int32_
             BIZ_SCENE_LABEL, param.scene_, BIZ_STAGE_LABEL, param.stage_, BIZ_STATE_LABEL, state, STAGE_RES_LABEL, res,
             ERROR_CODE_LABEL, param.errCode_, HOST_PKG, param.bundleName_, LOCAL_UUID_LABEL,
             AnonymousUuid(DmAdapter::GetInstance().GetLocalDevice().uuid), CONCURRENT_ID,
-            std::to_string(param.syncId_));
+            std::to_string(param.syncId_), TRIGGER_MODE, param.triggerMode_, WATER_VERSION, param.changeCount);
     } else {
         HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DATAMGR, eventName,
             OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR, ORG_PKG_LABEL, ORG_PKG, FUNC_LABEL, funcName,
             BIZ_SCENE_LABEL, param.scene_, BIZ_STAGE_LABEL, param.stage_, STAGE_RES_LABEL, res, ERROR_CODE_LABEL,
             param.errCode_, HOST_PKG, param.bundleName_, LOCAL_UUID_LABEL,
             AnonymousUuid(DmAdapter::GetInstance().GetLocalDevice().uuid), CONCURRENT_ID,
-            std::to_string(param.syncId_));
+            std::to_string(param.syncId_), TRIGGER_MODE, param.triggerMode_, WATER_VERSION, param.changeCount);
     }
     return;
 }
diff --git a/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h b/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h
index f02d2891caf592c5e04fc17b1e97f9775a912374..7c99f1fb99f8faed188f1b381f504d22f29e7917 100644
--- a/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h
+++ b/datamgr_service/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h
@@ -77,6 +77,7 @@ public:
     bool IsNetworkAvailable();
     NetworkType GetNetworkType(bool retrieve = false);
     int32_t GetAuthType(const std::string& id);
+    bool IsSameAccount(const std::string &id);
     friend class DataMgrDmStateCall;
     friend class NetConnCallbackObserver;
 
diff --git a/datamgr_service/services/distributeddataservice/adapter/include/dfx/radar_reporter.h b/datamgr_service/services/distributeddataservice/adapter/include/dfx/radar_reporter.h
index 72a6752bb0fd38b6d76b99b1b8a8fec3dca48d9b..7a60cc064c10ea002fca58f968477249b0e74e31 100644
--- a/datamgr_service/services/distributeddataservice/adapter/include/dfx/radar_reporter.h
+++ b/datamgr_service/services/distributeddataservice/adapter/include/dfx/radar_reporter.h
@@ -70,6 +70,8 @@ struct RadarParam {
     int32_t scene_ = CLOUD_SYNC;
     int32_t stage_ = GENERAL_STAGE;
     uint64_t syncId_ = 0;
+    int32_t triggerMode_ = 0;
+    uint64_t changeCount = 0;
     int32_t errCode_ = 0;
     int32_t res_ = RES_SUCCESS;
 };
@@ -102,6 +104,8 @@ private:
     static constexpr const char *REPLACE_CHAIN = "**";
     static constexpr const char *DEFAULT_ANONYMOUS = "************";
     static constexpr const char *CONCURRENT_ID = "CONCURRENT_ID";
+    static constexpr const char *TRIGGER_MODE = "TRIGGER_MODE";
+    static constexpr const char *WATER_VERSION = "WATER_VERSION";
     static constexpr const int32_t NO_ERROR = 0;
     static constexpr const int32_t HEAD_SIZE = 5;
     static constexpr const int32_t END_SIZE = 5;
diff --git a/datamgr_service/services/distributeddataservice/adapter/include/screenlock/screen_lock.h b/datamgr_service/services/distributeddataservice/adapter/include/screenlock/screen_lock.h
new file mode 100644
index 0000000000000000000000000000000000000000..db40555e3d797bac5d535b459933060907d7274d
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/adapter/include/screenlock/screen_lock.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DISTRIBUTEDDATAMGR_ADAPTER_SCREEN_LOCK_H
+#define DISTRIBUTEDDATAMGR_ADAPTER_SCREEN_LOCK_H
+
+#include "visibility.h"
+#include "screen/screen_manager.h"
+
+namespace OHOS {
+namespace DistributedData {
+class ScreenLock : public ScreenManager {
+public:
+    API_EXPORT bool IsLocked();
+};
+} // namespace DistributedData
+} // namespace OHOS
+#endif //DISTRIBUTEDDATAMGR_ADAPTER_SCREEN_LOCK_H
diff --git a/datamgr_service/services/distributeddataservice/adapter/include/utils/visibility.h b/datamgr_service/services/distributeddataservice/adapter/include/utils/visibility.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5aec5485e6debf4dbf3ac16e84b701785f638f9
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/adapter/include/utils/visibility.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_VISIBILITY_H
+#define OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_VISIBILITY_H
+
+#ifndef API_EXPORT
+#define API_EXPORT __attribute__((visibility ("default")))
+#endif
+#ifndef API_LOCAL
+#define API_LOCAL __attribute__((visibility ("hidden")))
+#endif
+#ifndef KVSTORE_API
+#define KVSTORE_API API_EXPORT
+#endif
+
+#endif // OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_VISIBILITY_H
diff --git a/datamgr_service/services/distributeddataservice/adapter/screenlock/BUILD.gn b/datamgr_service/services/distributeddataservice/adapter/screenlock/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..cb30d1da49819d8bc735ede6017e23100b23ca80
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/adapter/screenlock/BUILD.gn
@@ -0,0 +1,42 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/ohos.gni")
+import("//foundation/distributeddatamgr/datamgr_service/datamgr_service.gni")
+
+ohos_static_library("distributeddata_screenlock_static") {
+  branch_protector_ret = "pac_ret"
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+    boundary_sanitize = true
+    ubsan = true
+  }
+  sources = [ "src/screen_lock.cpp" ]
+
+  cflags_cc = [ "-fvisibility=hidden" ]
+
+  include_dirs = [
+    "../include/screenlock",
+    "../include/utils",
+    "${data_service_path}/framework/include",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "screenlock_mgr:screenlock_client",
+  ]
+  subsystem_name = "distributeddatamgr"
+  part_name = "datamgr_service"
+  defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ]
+}
diff --git a/datamgr_service/services/distributeddataservice/adapter/screenlock/src/screen_lock.cpp b/datamgr_service/services/distributeddataservice/adapter/screenlock/src/screen_lock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..92e9118ee4ac025af25086638757439532651ad9
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/adapter/screenlock/src/screen_lock.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "screen_lock.h"
+#include "screenlock_manager.h"
+
+namespace OHOS::DistributedData {
+using namespace OHOS::ScreenLock;
+__attribute__((used)) static bool g_init =
+    ScreenManager::RegisterInstance(std::static_pointer_cast<ScreenManager>(std::make_shared<ScreenLock>()));
+bool ScreenLock::IsLocked()
+{
+    auto manager = ScreenLockManager::GetInstance();
+    if (manager == nullptr) {
+        return false;
+    }
+    return manager->IsScreenLocked();
+}
+} // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/app/BUILD.gn b/datamgr_service/services/distributeddataservice/app/BUILD.gn
index cc59341fc4437a88df48cabd6e25960c1666013f..fd6efcbc4db415376a48c1f74cc9e0ca332547c7 100644
--- a/datamgr_service/services/distributeddataservice/app/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/app/BUILD.gn
@@ -58,6 +58,7 @@ config("module_private_config") {
     "${data_service_path}/service/permission/include",
     "${data_service_path}/service/matrix/include",
     "${data_service_path}/service/backup/include",
+    "${data_service_path}/service/app_id_mapping/include",
     "${data_service_path}/service/kvdb",
     "${data_service_path}/service/waterversion",
     "${data_service_path}/service/dumper/include",
diff --git a/datamgr_service/services/distributeddataservice/app/distributed_data.cfg b/datamgr_service/services/distributeddataservice/app/distributed_data.cfg
index a9e48f7b498d4e214577dbbacc4fae5396c97c6d..b4b210b2cdad4f26204c34495a716365a1de0410 100644
--- a/datamgr_service/services/distributeddataservice/app/distributed_data.cfg
+++ b/datamgr_service/services/distributeddataservice/app/distributed_data.cfg
@@ -17,7 +17,7 @@
         "name" : "distributeddata",
         "path" : ["/system/bin/sa_main","/system/profile/distributeddata.json"],
         "uid" : "ddms",
-        "gid" : ["system","shell","readproc","ddms","dfs_share","netsys_socket"],
+        "gid" : ["system","shell","readproc","ddms","dfs_share","netsys_socket","data_reserve"],
         "writepid":[
             "/dev/cpuset/foreground/tasks",
             "/dev/stune/foreground/tasks",
@@ -38,7 +38,6 @@
             "ohos.permission.PUBLISH_SYSTEM_COMMON_EVENT",
             "ohos.permission.GET_BUNDLE_INFO",
             "ohos.permission.GET_NETWORK_INFO",
-            "ohos.permission.INTERNET",
             "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER",
             "ohos.permission.MONITOR_DEVICE_NETWORK_STATE",
             "ohos.permission.USE_CLOUD_DRIVE_SERVICE",
diff --git a/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.cpp b/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.cpp
index 0ec512f6fe1dd46a6381d4e4a726147de17fb957..628329961c9400a105bb11065b57e1b827e09646 100644
--- a/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.cpp
@@ -60,10 +60,6 @@ void InstallEventSubscriber::OnReceiveEvent(const CommonEventData &event)
         int32_t appIndex = want.GetIntParam(SANDBOX_APP_INDEX, 0);
         ZLOGI("bundleName:%{public}s, user:%{public}d, appIndex:%{public}d", bundleName.c_str(), userId, appIndex);
         (this->*(it->second))(bundleName, userId, appIndex);
-    } else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED) {
-        int32_t userId = want.GetIntParam(USER_ID, -1);
-        ZLOGI("user:%{public}d ScreenUnlocked", userId);
-        OnScreenUnlocked(userId);
     }
 }
 
@@ -119,11 +115,6 @@ void InstallEventSubscriber::OnInstall(const std::string &bundleName, int32_t us
     kvStoreDataService_->OnInstall(bundleName, userId, appIndex);
 }
 
-void InstallEventSubscriber::OnScreenUnlocked(int32_t userId)
-{
-    kvStoreDataService_->OnScreenUnlocked(userId);
-}
-
 InstallerImpl::~InstallerImpl()
 {
     ZLOGD("destruct");
@@ -153,7 +144,6 @@ Status InstallerImpl::Init(KvStoreDataService *kvStoreDataService, std::shared_p
     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_CHANGED);
     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED);
     matchingSkills.AddEvent(OHOS::AppExecFwk::COMMON_EVENT_SANDBOX_PACKAGE_ADDED);
-    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
     CommonEventSubscribeInfo info(matchingSkills);
 
     auto subscriber = std::make_shared<InstallEventSubscriber>(info, kvStoreDataService);
diff --git a/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.h b/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.h
index aabcd933ec4039e4ac95513f34c4213f0d3bdb55..683ae72999006e46b2217958bcde2b610796eecf 100644
--- a/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.h
+++ b/datamgr_service/services/distributeddataservice/app/src/installer/installer_impl.h
@@ -36,7 +36,6 @@ private:
     void OnUninstall(const std::string &bundleName, int32_t userId, int32_t appIndex);
     void OnUpdate(const std::string &bundleName, int32_t userId, int32_t appIndex);
     void OnInstall(const std::string &bundleName, int32_t userId, int32_t appIndex);
-    void OnScreenUnlocked(int32_t userId);
     std::map<std::string, InstallEventCallback> callbacks_;
     KvStoreDataService *kvStoreDataService_;
 };
diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp
index 94d55d6c62424f2e13d66400a430959e5044a75f..ecc50daad3474156dfd213a41e56efaf5f4315d6 100644
--- a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.cpp
@@ -23,7 +23,6 @@
 #include "accesstoken_kit.h"
 #include "auth_delegate.h"
 #include "auto_launch_export.h"
-#include "auto_sync_matrix.h"
 #include "bootstrap.h"
 #include "checker/checker_manager.h"
 #include "communication_provider.h"
@@ -63,6 +62,7 @@
 #include "utils/block_integer.h"
 #include "utils/crypto.h"
 #include "water_version_manager.h"
+#include "app_id_mapping/app_id_mapping_config_manager.h"
 
 namespace OHOS::DistributedKv {
 using namespace std::chrono;
@@ -76,6 +76,8 @@ using DBConfig = DistributedDB::RuntimeConfig;
 
 REGISTER_SYSTEM_ABILITY_BY_ID(KvStoreDataService, DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, true);
 
+constexpr char FOUNDATION_PROCESS_NAME[] = "foundation";
+
 KvStoreDataService::KvStoreDataService(bool runOnCreate)
     : SystemAbility(runOnCreate), clients_()
 {
@@ -200,26 +202,14 @@ Status KvStoreDataService::RegisterClientDeathObserver(const AppId &appId, sptr<
         ZLOGW("check bundleName:%{public}s uid:%{public}d failed.", appId.appId.c_str(), info.uid);
         return Status::PERMISSION_DENIED;
     }
-    KvStoreClientDeathObserverImpl kvStoreClientDeathObserver(*this);
-    auto inserted = clients_.Emplace(
-        [&info, &appId, &kvStoreClientDeathObserver](decltype(clients_)::map_type &entries) {
-            auto it = entries.find(info.tokenId);
-            if (it == entries.end()) {
-                return true;
-            }
-            if (IPCSkeleton::GetCallingPid() == it->second.GetPid()) {
-                ZLOGW("bundleName:%{public}s, uid:%{public}d, pid:%{public}d has already registered.",
-                    appId.appId.c_str(), info.uid, IPCSkeleton::GetCallingPid());
-                return false;
-            }
-            kvStoreClientDeathObserver = std::move(it->second);
-            entries.erase(it);
-            return true;
-        },
-        std::piecewise_construct, std::forward_as_tuple(info.tokenId),
-        std::forward_as_tuple(appId, *this, std::move(observer)));
-    ZLOGI("bundleName:%{public}s, uid:%{public}d, pid:%{public}d, inserted:%{public}s.", appId.appId.c_str(), info.uid,
-        IPCSkeleton::GetCallingPid(), inserted ? "success" : "failed");
+    auto pid = IPCSkeleton::GetCallingPid();
+    clients_.Compute(
+        info.tokenId, [&appId, &info, pid, this, obs = std::move(observer)](const auto tokenId, auto &clients) {
+            auto res = clients.try_emplace(pid, appId, *this, std::move(obs));
+            ZLOGI("bundleName:%{public}s, uid:%{public}d, pid:%{public}d, inserted:%{public}s.", appId.appId.c_str(),
+                info.uid, pid, res.second ? "success" : "failed");
+            return !clients.empty();
+        });
     return Status::SUCCESS;
 }
 
@@ -230,9 +220,14 @@ Status KvStoreDataService::AppExit(pid_t uid, pid_t pid, uint32_t token, const A
     // clientDeathObserverMap_ erase, so we have to take a copy if we want to use this parameter after erase operation.
     AppId appIdTmp = appId;
     KvStoreClientDeathObserverImpl impl(*this);
-    clients_.ComputeIfPresent(token, [&impl](auto &, auto &value) {
-        impl = std::move(value);
-        return false;
+    clients_.ComputeIfPresent(token, [&impl, pid](auto &, auto &value) {
+        auto it = value.find(pid);
+        if (it == value.end()) {
+            return !value.empty();
+        }
+        impl = std::move(it->second);
+        value.erase(it);
+        return !value.empty();
     });
     return Status::SUCCESS;
 }
@@ -281,12 +276,7 @@ void KvStoreDataService::OnStart()
         ZLOGW("GetLocalDeviceId failed, retry count:%{public}d", static_cast<int>(retry));
     }
     ZLOGI("Bootstrap configs and plugins.");
-    Bootstrap::GetInstance().LoadComponents();
-    Bootstrap::GetInstance().LoadDirectory();
-    Bootstrap::GetInstance().LoadCheckers();
-    Bootstrap::GetInstance().LoadNetworks();
-    Bootstrap::GetInstance().LoadBackup(executors_);
-    Bootstrap::GetInstance().LoadCloud();
+    LoadConfigs();
     Initialize();
     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (samgr != nullptr) {
@@ -315,6 +305,17 @@ void KvStoreDataService::OnStart()
     StartService();
 }
 
+void KvStoreDataService::LoadConfigs()
+{
+    Bootstrap::GetInstance().LoadComponents();
+    Bootstrap::GetInstance().LoadDirectory();
+    Bootstrap::GetInstance().LoadCheckers();
+    Bootstrap::GetInstance().LoadNetworks();
+    Bootstrap::GetInstance().LoadBackup(executors_);
+    Bootstrap::GetInstance().LoadCloud();
+    Bootstrap::GetInstance().LoadAppIdMappings();
+}
+
 void KvStoreDataService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
 {
     ZLOGI("add system abilityid:%{public}d", systemAbilityId);
@@ -346,7 +347,6 @@ void KvStoreDataService::StartService()
     ZLOGI("begin.");
     KvStoreMetaManager::GetInstance().InitMetaListener();
     DeviceMatrix::GetInstance().Initialize(IPCSkeleton::GetCallingTokenID(), Bootstrap::GetInstance().GetMetaDBName());
-    AutoSyncMatrix::GetInstance().Initialize();
     WaterVersionManager::GetInstance().Init();
     LoadFeatures();
     bool ret = SystemAbility::Publish(this);
@@ -396,6 +396,25 @@ void KvStoreDataService::OnStoreMetaChanged(
     ZLOGI("dirty kv store. storeId:%{public}s", Anonymous::Change(metaData.storeId).c_str());
 }
 
+bool KvStoreDataService::CompareTripleIdentifier(const std::string &accountId, const std::string &identifier,
+    const StoreMetaData &storeMeta)
+{
+    std::vector<std::string> accountIds { accountId, "ohosAnonymousUid", "default" };
+    for (auto &id : accountIds) {
+        auto convertedIds =
+            AppIdMappingConfigManager::GetInstance().Convert(storeMeta.appId, storeMeta.user);
+        const std::string &tempTripleIdentifier =
+            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(id, convertedIds.first,
+                storeMeta.storeId, false);
+        if (tempTripleIdentifier == identifier) {
+            ZLOGI("find triple identifier,storeId:%{public}s,id:%{public}s",
+                Anonymous::Change(storeMeta.storeId).c_str(), Anonymous::Change(id).c_str());
+            return true;
+        }
+    }
+    return false;
+}
+
 bool KvStoreDataService::ResolveAutoLaunchParamByIdentifier(
     const std::string &identifier, DistributedDB::AutoLaunchParam &param)
 {
@@ -414,15 +433,13 @@ bool KvStoreDataService::ResolveAutoLaunchParamByIdentifier(
             // judge local userid and local meta
             continue;
         }
-        const std::string &itemTripleIdentifier =
-            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(accountId, storeMeta.appId,
-                storeMeta.storeId, false);
+        bool isTripleIdentifierEqual = CompareTripleIdentifier(accountId, identifier, storeMeta);
         const std::string &itemDualIdentifier =
             DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier("", storeMeta.appId, storeMeta.storeId, true);
-        if (identifier == itemTripleIdentifier && storeMeta.bundleName != Bootstrap::GetInstance().GetProcessLabel()) {
+        if (isTripleIdentifierEqual && storeMeta.bundleName != Bootstrap::GetInstance().GetProcessLabel()) {
             ResolveAutoLaunchCompatible(storeMeta, identifier, accountId);
         }
-        if (identifier == itemDualIdentifier || identifier == itemTripleIdentifier) {
+        if (identifier == itemDualIdentifier || isTripleIdentifierEqual) {
             ZLOGI("identifier  find");
             DistributedDB::AutoLaunchOption option;
             option.createIfNecessary = false;
@@ -709,7 +726,8 @@ void KvStoreDataService::InitSecurityAdapter(std::shared_ptr<ExecutorPool> execu
         ZLOGE("security is nullptr.");
         return;
     }
-
+    
+    security_->InitLocalSecurity();
     auto dbStatus = DistributedDB::RuntimeConfig::SetProcessSystemAPIAdapter(security_);
     ZLOGD("set distributed db system api adapter: %d.", static_cast<int>(dbStatus));
 
@@ -809,10 +827,10 @@ int32_t KvStoreDataService::OnScreenUnlocked(int32_t user)
 int32_t KvStoreDataService::ClearAppStorage(const std::string &bundleName, int32_t userId, int32_t appIndex,
     int32_t tokenId)
 {
-    HapTokenInfo hapTokenInfo;
-    if (AccessTokenKit::GetHapTokenInfo(tokenId, hapTokenInfo) != RET_SUCCESS ||
-        hapTokenInfo.bundleName != bundleName || hapTokenInfo.userID != userId ||
-        hapTokenInfo.instIndex != appIndex) {
+    auto callerToken = IPCSkeleton::GetCallingTokenID();
+    NativeTokenInfo nativeTokenInfo;
+    if (AccessTokenKit::GetNativeTokenInfo(callerToken, nativeTokenInfo) != RET_SUCCESS ||
+        nativeTokenInfo.processName != FOUNDATION_PROCESS_NAME) {
         ZLOGE("passed wrong, tokenId: %{public}u, bundleName:%{public}s, user:%{public}d, appIndex:%{public}d",
             tokenId, bundleName.c_str(), userId, appIndex);
         return ERROR;
diff --git a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.h b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.h
index ae5b3b1c45d942337925c08950bb835382da4c7b..53a02afe2fd3d2026bafe15770d4d78b852afae2 100644
--- a/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.h
+++ b/datamgr_service/services/distributeddataservice/app/src/kvstore_data_service.h
@@ -169,13 +169,18 @@ private:
     bool ResolveAutoLaunchParamByIdentifier(const std::string &identifier, DistributedDB::AutoLaunchParam &param);
     void ResolveAutoLaunchCompatible(const StoreMetaData &storeMeta, const std::string &identifier,
         const std::string &accountId);
+
+    void LoadConfigs();
+
+    bool CompareTripleIdentifier(const std::string &accountId, const std::string &identifier,
+        const StoreMetaData &storeMeta);
     static DistributedDB::SecurityOption ConvertSecurity(int securityLevel);
     static Status InitNbDbOption(const Options &options, const std::vector<uint8_t> &cipherKey,
                           DistributedDB::KvStoreNbDelegate::Option &dbOption);
 
     static constexpr int TEN_SEC = 10;
 
-    ConcurrentMap<uint32_t, KvStoreClientDeathObserverImpl> clients_;
+    ConcurrentMap<uint32_t, std::map<int32_t, KvStoreClientDeathObserverImpl>> clients_;
     std::shared_ptr<KvStoreAccountObserver> accountEventObserver_;
 
     std::shared_ptr<Security> security_;
diff --git a/datamgr_service/services/distributeddataservice/app/src/security/security.cpp b/datamgr_service/services/distributeddataservice/app/src/security/security.cpp
index b3cceb7176e9b7f7aa1d36087a88bc3a39e84120..ca7c97203742130e1ad017fcfe5c5eea3a80b180 100644
--- a/datamgr_service/services/distributeddataservice/app/src/security/security.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/security/security.cpp
@@ -165,6 +165,12 @@ bool Security::IsExits(const std::string &file) const
     return access(file.c_str(), F_OK) == 0;
 }
 
+void Security::InitLocalSecurity()
+{
+    auto devInfo = DistributedData::DeviceManagerAdapter::GetInstance().GetLocalDevice();
+    GetSensitiveByUuid(devInfo.uuid);
+}
+
 Sensitive Security::GetSensitiveByUuid(const std::string &uuid) const
 {
     auto it = devicesUdid_.Find(uuid);
diff --git a/datamgr_service/services/distributeddataservice/app/src/security/security.h b/datamgr_service/services/distributeddataservice/app/src/security/security.h
index 702f2af2c3217aed9c26f9354bc83a6076aa4777..bfa2a5415f53ef3aef0f784b3b6b4d424e33bb0d 100644
--- a/datamgr_service/services/distributeddataservice/app/src/security/security.h
+++ b/datamgr_service/services/distributeddataservice/app/src/security/security.h
@@ -58,6 +58,8 @@ public:
 
     AppDistributedKv::ChangeLevelType GetChangeLevelType() const override;
 
+    void InitLocalSecurity();
+
 private:
     enum {
         NO_PWD = -1,
diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp b/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
index 5d5dc15e4ccad8a9b7f9917bc1888c35b0b53373..318891be635eff9971a2678be69876f4f7e6deee 100644
--- a/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
@@ -34,6 +34,7 @@ using namespace OHOS::DistributedKv;
 using namespace std::chrono;
 using DmAdapter = DistributedData::DeviceManagerAdapter;
 constexpr const int ALIGN_WIDTH = 8;
+constexpr const char *DEFAULT_USERID = "0";
 std::shared_ptr<RouteHeadHandler> RouteHeadHandlerImpl::Create(const ExtendInfo &info)
 {
     auto handler = std::make_shared<RouteHeadHandlerImpl>(info);
@@ -58,6 +59,9 @@ void RouteHeadHandlerImpl::Init()
     if (deviceId_.empty()) {
         return;
     }
+    if (!DmAdapter::GetInstance().IsOHOSType(deviceId_) && userId_ != DEFAULT_USERID) {
+        userId_ = DEFAULT_USERID;
+    }
     SessionPoint localPoint { DmAdapter::GetInstance().GetLocalDevice().uuid,
         static_cast<uint32_t>(atoi(userId_.c_str())), appId_, storeId_ };
     session_ = SessionManager::GetInstance().GetSession(localPoint, deviceId_);
diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.cpp b/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.cpp
index 271c1d8cbd64032b9c60611ada646bacede540e7..d46217a47b5211f88a7507c2285553ae4fa287d8 100644
--- a/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.cpp
@@ -27,7 +27,7 @@
 #include "user_delegate.h"
 #include "utils/anonymous.h"
 #include "utils/converter.h"
-
+#include "types.h"
 namespace OHOS::DistributedData {
 using namespace OHOS::DistributedKv;
 SessionManager &SessionManager::GetInstance()
@@ -57,9 +57,17 @@ Session SessionManager::GetSession(const SessionPoint &from, const std::string &
             session.targetUserIds.push_back(UserDelegate::SYSTEM_USER);
         }
     }
+    
+    std::string bundleName = "";
+    int32_t authType = static_cast<int32_t>(AuthType::DEFAULT);
+    if (!GetAuthParams(from, bundleName, authType)) {
+        ZLOGE("GetAuthParams failed");
+        return session;
+    }
 
     for (const auto &user : users) {
-        bool isPermitted = AuthDelegate::GetInstance()->CheckAccess(from.userId, user.id, targetDeviceId, from.appId);
+        bool isPermitted = AuthDelegate::GetInstance()->CheckAccess(from.userId, user.id,
+            targetDeviceId, authType);
         ZLOGD("access to peer user %{public}d is %{public}d", user.id, isPermitted);
         if (isPermitted) {
             auto it = std::find(session.targetUserIds.begin(), session.targetUserIds.end(), user.id);
@@ -72,9 +80,36 @@ Session SessionManager::GetSession(const SessionPoint &from, const std::string &
     return session;
 }
 
+bool SessionManager::GetAuthParams(const SessionPoint &from, std::string &bundleName, int32_t &auth) const
+{
+    std::vector<StoreMetaData> metaData;
+    if (!MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({ from.deviceId }), metaData)) {
+        ZLOGW("load meta failed, deviceId:%{public}s", Anonymous::Change(from.deviceId).c_str());
+        return false;
+    }
+    for (const auto &storeMeta : metaData) {
+        if (storeMeta.appId == from.appId) {
+            bundleName = storeMeta.bundleName;
+            auth = storeMeta.authType;
+            break;
+        }
+    }
+    if (bundleName.empty()) {
+        ZLOGE("not find bundleName");
+        return false;
+    }
+    return true;
+}
+
 bool SessionManager::CheckSession(const SessionPoint &from, const SessionPoint &to) const
 {
-    return AuthDelegate::GetInstance()->CheckAccess(from.userId, to.userId, to.deviceId, from.appId);
+    std::string bundleName = "";
+    int32_t authType = static_cast<int32_t>(AuthType::DEFAULT);
+    if (!GetAuthParams(from, bundleName, authType)) {
+        ZLOGE("GetAuthParams failed");
+        return false;
+    }
+    return AuthDelegate::GetInstance()->CheckAccess(from.userId, to.userId, to.deviceId, authType, false);
 }
 
 bool Session::Marshal(json &node) const
diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.h b/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.h
index bad2b8e2f6cad8b3d461d4aa722de72ec415d532..43c6312f78e9db26872eaace711fecde048f96c6 100644
--- a/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.h
+++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/session_manager.h
@@ -49,6 +49,8 @@ public:
     static SessionManager &GetInstance();
     Session GetSession(const SessionPoint &from, const std::string &targetDeviceId) const;
     bool CheckSession(const SessionPoint &from, const SessionPoint &to) const;
+private:
+    bool GetAuthParams(const SessionPoint &from, std::string &bundleName, int32_t &auth) const;
 };
 } // namespace OHOS::DistributedData
 
diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp
index 0627708fe8570dc0c352860b9ec0b0889ffc2339..65360d84898a7ca4d184594c149fb11d4513a760 100644
--- a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.cpp
@@ -23,6 +23,7 @@
 #include "metadata/meta_data_manager.h"
 #include "utils/anonymous.h"
 #include "utils/constant.h"
+#include "app_id_mapping/app_id_mapping_config_manager.h"
 
 namespace OHOS::DistributedData {
 using namespace OHOS::DistributedKv;
@@ -119,20 +120,24 @@ void UpgradeManager::SetCompatibleIdentifyByType(DistributedDB::KvStoreNbDelegat
     GetIdentifierParams(sameAccountDevs, uuids, IDENTICAL_ACCOUNT);
     GetIdentifierParams(defaultAccountDevs, uuids, NO_ACCOUNT);
     if (!sameAccountDevs.empty()) {
-        auto syncIdentifier =
-            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(tuple.userId, tuple.appId, tuple.storeId);
-        ZLOGI("same account set compatible identifier store:%{public}s, user:%{public}s, device:%{public}.10s",
-            Anonymous::Change(tuple.storeId).c_str(), Anonymous::Change(tuple.userId).c_str(),
-            DistributedData::Serializable::Marshall(sameAccountDevs).c_str());
-        storeDelegate->SetEqualIdentifier(syncIdentifier, sameAccountDevs);
+        auto convertedIds = AppIdMappingConfigManager::GetInstance().Convert(tuple.appId, tuple.userId);
+        auto identifier =
+            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(convertedIds.second,
+            convertedIds.first, tuple.storeId);
+        ZLOGI("same account store:%{public}s, user:%{public}s, device:%{public}.10s, appId:%{public}s",
+            Anonymous::Change(tuple.storeId).c_str(), Anonymous::Change(convertedIds.second).c_str(),
+            DistributedData::Serializable::Marshall(sameAccountDevs).c_str(), convertedIds.first.c_str());
+        storeDelegate->SetEqualIdentifier(identifier, sameAccountDevs);
     }
     if (!defaultAccountDevs.empty()) {
-        auto syncIdentifier =
-            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(defaultAccountId, tuple.appId, tuple.storeId);
-        ZLOGI("no account set compatible identifier, store:%{public}s,  device:%{public}.10s",
+        auto convertedIds = AppIdMappingConfigManager::GetInstance().Convert(tuple.appId, defaultAccountId);
+        auto identifier =
+            DistributedDB::KvStoreDelegateManager::GetKvStoreIdentifier(convertedIds.second,
+            convertedIds.first, tuple.storeId);
+        ZLOGI("no account identifier, store:%{public}s, device:%{public}.10s, appId:%{public}s",
             Anonymous::Change(tuple.storeId).c_str(),
-            DistributedData::Serializable::Marshall(defaultAccountDevs).c_str());
-        storeDelegate->SetEqualIdentifier(syncIdentifier, defaultAccountDevs);
+            DistributedData::Serializable::Marshall(defaultAccountDevs).c_str(), convertedIds.first.c_str());
+        storeDelegate->SetEqualIdentifier(identifier, defaultAccountDevs);
     }
 }
 } // namespace OHOS::DistributedData
diff --git a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.h b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.h
index 9fc71a2fd457682a7f7b4097b3b2026f12339a51..9348fc02b6af9952669fd0bd1e8ae26f5811853a 100644
--- a/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.h
+++ b/datamgr_service/services/distributeddataservice/app/src/session_manager/upgrade_manager.h
@@ -47,7 +47,7 @@ private:
 
     static constexpr int32_t NO_ACCOUNT = 0;
     static constexpr int32_t IDENTICAL_ACCOUNT = 1;
-    static constexpr const char *defaultAccountId = "default";
+    static constexpr const char *defaultAccountId = "ohosAnonymousUid";
 };
 } // namespace OHOS::DistributedData
 #endif // DISTRIBUTEDDATAMGR_UPGRADE_MANAGER_H
diff --git a/datamgr_service/services/distributeddataservice/app/test/unittest/kvstore_data_service_clear_test.cpp b/datamgr_service/services/distributeddataservice/app/test/unittest/kvstore_data_service_clear_test.cpp
index 506d689bc354227cc177abc8bfe5a6d20e5238d3..268811200ef9a1507189c30959295ef60adda039 100644
--- a/datamgr_service/services/distributeddataservice/app/test/unittest/kvstore_data_service_clear_test.cpp
+++ b/datamgr_service/services/distributeddataservice/app/test/unittest/kvstore_data_service_clear_test.cpp
@@ -45,11 +45,8 @@ class KvStoreDataServiceClearTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
-
     void SetUp();
     void TearDown();
-
-    NativeTokenInfoParams infoInstance {0};
 protected:
     static constexpr const char *TEST_USER = "100";
     static constexpr const char *TEST_BUNDLE = "ohos.test.demo";
@@ -57,16 +54,10 @@ protected:
     static constexpr int32_t TEST_UID = 2000000;
     static constexpr int32_t TEST_USERID = 100;
     static constexpr const char *BUNDLE_NAME = "ohos.test.demo";
-    static constexpr const char *BUNDLENAME_NO = "com.sample.helloworld";
     static constexpr int32_t USER_ID = 100;
-    static constexpr int32_t USERID_NO = 10;
     static constexpr int32_t APP_INDEX = 0;
-    static constexpr int32_t APPINDEX_NO = 2;
-    static constexpr int32_t INVALID_TOKEN = 222;
-
     DistributedData::StoreMetaData metaData_;
     DistributedData::StoreMetaDataLocal localMeta_;
-
     void InitMetaData();
 };
 
@@ -80,55 +71,12 @@ void KvStoreDataServiceClearTest::TearDownTestCase(void)
 
 void KvStoreDataServiceClearTest::SetUp(void)
 {
-    DistributedData::Bootstrap::GetInstance().LoadComponents();
     DistributedData::Bootstrap::GetInstance().LoadDirectory();
     DistributedData::Bootstrap::GetInstance().LoadCheckers();
-
-    infoInstance.dcapsNum = 0;
-    infoInstance.permsNum = 0;
-    infoInstance.aclsNum = 0;
-    infoInstance.dcaps = nullptr;
-    infoInstance.perms = nullptr;
-    infoInstance.acls = nullptr;
-    infoInstance.processName = "KvStoreDataServiceClearTest";
-    infoInstance.aplStr = "system_core";
-
-    HapInfoParams info = {
-        .userID = TEST_USERID,
-        .bundleName = TEST_BUNDLE,
-        .instIndex = 0,
-        .appIDDesc = TEST_BUNDLE
-    };
-    PermissionDef infoManagerTestPermDef = {
-        .permissionName = "ohos.permission.test",
-        .bundleName = TEST_BUNDLE,
-        .grantMode = 1,
-        .availableLevel = APL_NORMAL,
-        .label = "label",
-        .labelId = 1,
-        .description = "open the door",
-        .descriptionId = 1
-    };
-    PermissionStateFull infoManagerTestState = {
-        .permissionName = "ohos.permission.test",
-        .isGeneral = true,
-        .resDeviceID = {"local"},
-        .grantStatus = {PermissionState::PERMISSION_GRANTED},
-        .grantFlags = {1}
-    };
-    HapPolicyParams policy = {
-        .apl = APL_NORMAL,
-        .domain = "test.domain",
-        .permList = {infoManagerTestPermDef},
-        .permStateList = {infoManagerTestState}
-    };
-    AccessTokenKit::AllocHapToken(info, policy);
 }
 
 void KvStoreDataServiceClearTest::TearDown(void)
 {
-    auto tokenId = AccessTokenKit::GetHapTokenID(TEST_USERID, TEST_BUNDLE, 0);
-    AccessTokenKit::DeleteToken(tokenId);
 }
 
 void KvStoreDataServiceClearTest::InitMetaData()
@@ -155,7 +103,7 @@ void KvStoreDataServiceClearTest::InitMetaData()
 
 /**
  * @tc.name: ClearAppStorage001
- * @tc.desc: Test that the parameters are entered correctly
+ * @tc.desc: The parameters are valid but have no metaData
  * @tc.type: FUNC
  * @tc.require:
  * @tc.author: suoqilong
@@ -163,49 +111,23 @@ void KvStoreDataServiceClearTest::InitMetaData()
 HWTEST_F(KvStoreDataServiceClearTest, ClearAppStorage001, TestSize.Level1)
 {
     auto kvDataService = OHOS::DistributedKv::KvStoreDataService();
-    auto tokenIdOk = AccessTokenKit::GetHapTokenID(TEST_USERID, TEST_BUNDLE, 0);
-    auto ret =
-        kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APP_INDEX, INVALID_TOKEN);
-    EXPECT_EQ(ret, Status::ERROR);
-
-    ret = kvDataService.ClearAppStorage(BUNDLENAME_NO, USER_ID, APP_INDEX, tokenIdOk);
-    EXPECT_EQ(ret, Status::ERROR);
-
-    ret = kvDataService.ClearAppStorage(BUNDLE_NAME, USERID_NO, APP_INDEX, tokenIdOk);
-    EXPECT_EQ(ret, Status::ERROR);
-
-    ret = kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APPINDEX_NO, tokenIdOk);
+    auto tokenIdOk = AccessTokenKit::GetNativeTokenId("foundation");
+    SetSelfTokenID(tokenIdOk);
+    auto ret = kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APP_INDEX, tokenIdOk);
     EXPECT_EQ(ret, Status::ERROR);
 }
 
 /**
  * @tc.name: ClearAppStorage002
- * @tc.desc: The parameters are valid but have no metaData
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: suoqilong
- */
-HWTEST_F(KvStoreDataServiceClearTest, ClearAppStorage002, TestSize.Level1)
-{
-    auto kvDataService = OHOS::DistributedKv::KvStoreDataService();
-    auto tokenIdOk = AccessTokenKit::GetHapTokenID(TEST_USERID, TEST_BUNDLE, 0);
-
-    auto ret =
-        kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APP_INDEX, tokenIdOk);
-    EXPECT_EQ(ret, Status::ERROR);
-}
-
-/**
- * @tc.name: ClearAppStorage003
  * @tc.desc: Test that the cleanup is implemented
  * @tc.type: FUNC
  * @tc.require:
  * @tc.author: suoqilong
  */
-HWTEST_F(KvStoreDataServiceClearTest, ClearAppStorage003, TestSize.Level1)
+HWTEST_F(KvStoreDataServiceClearTest, ClearAppStorage002, TestSize.Level1)
 {
-    auto executors = std::make_shared<ExecutorPool>(12, 5);
-    // Create an object of the ExecutorPool class and pass 12 and 5 as arguments to the constructor of the class
+    auto executors = std::make_shared<ExecutorPool>(2, 1);
+    // Create an object of the ExecutorPool class and pass 2 and 1 as arguments to the constructor of the class
     KvStoreMetaManager::GetInstance().BindExecutor(executors);
     KvStoreMetaManager::GetInstance().InitMetaParameter();
     DmAdapter::GetInstance().Init(executors);
@@ -226,10 +148,10 @@ HWTEST_F(KvStoreDataServiceClearTest, ClearAppStorage003, TestSize.Level1)
     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(metaData_.appId, metaData_, true));
     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(metaData_.GetKeyLocal(), localMeta_, true));
 
-    auto tokenIdOk = AccessTokenKit::GetHapTokenID(TEST_USERID, TEST_BUNDLE, 0);
+    auto tokenIdOk = AccessTokenKit::GetNativeTokenId("foundation");
+    SetSelfTokenID(tokenIdOk);
     auto kvDataService = OHOS::DistributedKv::KvStoreDataService();
-    auto ret =
-        kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APP_INDEX, tokenIdOk);
+    auto ret = kvDataService.ClearAppStorage(BUNDLE_NAME, USER_ID, APP_INDEX, tokenIdOk);
     EXPECT_EQ(ret, Status::SUCCESS);
 
     EXPECT_FALSE(MetaDataManager::GetInstance().LoadMeta(metaData_.GetKey(), metaData_));
diff --git a/datamgr_service/services/distributeddataservice/app/test/unittest/session_manager_test.cpp b/datamgr_service/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
index 554891ba8588124854e9f1d80af250e12c48e8d2..96fa8ca77c257a42bb9749b9b1ccc184992b25ec 100644
--- a/datamgr_service/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
+++ b/datamgr_service/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
@@ -93,6 +93,7 @@ public:
 
         StoreMetaData metaData;
         metaData.bundleName = "ohos.test.demo";
+        metaData.appId = "ohos.test.demo";
         metaData.storeId = "test_store";
         metaData.user = "100";
         metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
@@ -110,6 +111,7 @@ public:
         MetaDataManager::GetInstance().DelMeta(std::string(peerCapMetaKey.begin(), peerCapMetaKey.end()));
         StoreMetaData metaData;
         metaData.bundleName = "ohos.test.demo";
+        metaData.appId = "ohos.test.demo";
         metaData.storeId = "test_store";
         metaData.user = "100";
         metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
@@ -142,7 +144,7 @@ HWTEST_F(SessionManagerTest, PackAndUnPack01, TestSize.Level2)
     ASSERT_NE(sendHandler, nullptr);
     uint32_t routeHeadSize = 0;
     sendHandler->GetHeadDataSize(routeHeadSize);
-    ASSERT_GT(routeHeadSize, 0);
+    ASSERT_EQ(routeHeadSize, 0);
     std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(routeHeadSize);
     sendHandler->FillHeadData(data.get(), routeHeadSize, routeHeadSize);
 
@@ -152,7 +154,6 @@ HWTEST_F(SessionManagerTest, PackAndUnPack01, TestSize.Level2)
     uint32_t parseSize = 1;
     recvHandler->ParseHeadData(data.get(), routeHeadSize, parseSize, users);
     EXPECT_EQ(routeHeadSize, parseSize);
-    ASSERT_EQ(users.size(), 1);
-    EXPECT_EQ(users[0], "100");
+    ASSERT_EQ(users.size(), 0);
 }
 } // namespace
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/BUILD.gn b/datamgr_service/services/distributeddataservice/framework/BUILD.gn
index f069d43e881f8669394ea2865e563a37d7ddd43f..ca78af920b56d92820997a5c80a0f4714d13242a 100644
--- a/datamgr_service/services/distributeddataservice/framework/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/framework/BUILD.gn
@@ -33,6 +33,7 @@ config("module_public_config") {
   visibility = [ ":*" ]
   include_dirs = [
     "include",
+    "${data_service_path}/framework/include/account",
     "${kv_store_common_path}",
   ]
 }
@@ -47,6 +48,8 @@ ohos_shared_library("distributeddatasvcfwk") {
     debug = false
   }
   sources = [
+    "account/account_delegate.cpp",
+    "app_id_mapping/app_id_mapping_config_manager.cpp",
     "backuprule/backup_rule_manager.cpp",
     "changeevent/remote_change_event.cpp",
     "checker/checker_manager.cpp",
@@ -56,6 +59,7 @@ ohos_shared_library("distributeddatasvcfwk") {
     "cloud/cloud_event.cpp",
     "cloud/cloud_extra_data.cpp",
     "cloud/cloud_info.cpp",
+    "cloud/cloud_lock_event.cpp",
     "cloud/cloud_server.cpp",
     "cloud/cloud_share_event.cpp",
     "cloud/cloud_sync_finished_event.cpp",
@@ -65,6 +69,7 @@ ohos_shared_library("distributeddatasvcfwk") {
     "cloud/subscription.cpp",
     "cloud/sync_event.cpp",
     "cloud/sync_strategy.cpp",
+    "communication/connect_manager.cpp",
     "directory/directory_manager.cpp",
     "dump/dump_manager.cpp",
     "eventcenter/event.cpp",
@@ -86,6 +91,7 @@ ohos_shared_library("distributeddatasvcfwk") {
     "metadata/switches_meta_data.cpp",
     "metadata/user_meta_data.cpp",
     "metadata/version_meta_data.cpp",
+    "screen/screen_manager.cpp",
     "serializable/serializable.cpp",
     "snapshot/bind_event.cpp",
     "snapshot/snapshot.cpp",
diff --git a/datamgr_service/services/distributeddataservice/framework/CMakeLists.txt b/datamgr_service/services/distributeddataservice/framework/CMakeLists.txt
index d72ea16e5797af7d76fdd04a7e56b3092c1dff3f..9166243b738ddfd32191bc8754cd8b8e242cd999 100644
--- a/datamgr_service/services/distributeddataservice/framework/CMakeLists.txt
+++ b/datamgr_service/services/distributeddataservice/framework/CMakeLists.txt
@@ -10,18 +10,22 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
 set(MOCK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../mock")
 set(KV_STORE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../kv_store")
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/account svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/app_id_mapping svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/backuprule svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/changeevent svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/checker svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/cloud svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/communication svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/directory svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/dump svcFwkSrc)
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/metadata svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/eventcenter svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/feature svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/metadata svcFwkSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/screen svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/serializable svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/snapshot svcFwkSrc)
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/feature svcFwkSrc)
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/directory svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/store svcFwkSrc)
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/cloud svcFwkSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/utils svcFwkSrc)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../adapter/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../../../utils_native/base/include)
@@ -35,3 +39,4 @@ set(LIBRARY_OUTPUT_PATH "${PROJECT_BINARY_DIR}/../../../../")
 add_library(svcFwk SHARED ${svcFwkSrc})
 target_link_libraries(svcFwk ${links})
 target_include_directories(svcFwk PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(svcFwk PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/account)
diff --git a/datamgr_service/services/distributeddataservice/framework/account/account_delegate.cpp b/datamgr_service/services/distributeddataservice/framework/account/account_delegate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1734d6541b80be85e2bbb28e63018590ba27242f
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/account/account_delegate.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "account_delegate.h"
+
+namespace OHOS {
+namespace DistributedKv {
+AccountDelegate *AccountDelegate::instance_ = nullptr;
+
+bool AccountDelegate::RegisterAccountInstance(AccountDelegate *instance)
+{
+    if (instance_ != nullptr) {
+        return false;
+    }
+    instance_ = instance;
+    return true;
+}
+
+AccountDelegate *AccountDelegate::GetInstance()
+{
+    return instance_;
+}
+} // namespace DistributedKv
+} // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/app_id_mapping/app_id_mapping_config_manager.cpp b/datamgr_service/services/distributeddataservice/framework/app_id_mapping/app_id_mapping_config_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d03d5246261b7ba873aa408d3454edf801dd335
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/app_id_mapping/app_id_mapping_config_manager.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AppIdMappingConfigManager"
+#include "app_id_mapping/app_id_mapping_config_manager.h"
+
+namespace OHOS::DistributedData {
+AppIdMappingConfigManager &AppIdMappingConfigManager::GetInstance()
+{
+    static AppIdMappingConfigManager instance;
+    return instance;
+}
+
+void AppIdMappingConfigManager::Initialize(const std::vector<AppMappingInfo> &mapper)
+{
+    for (const auto &info : mapper) {
+        toDstMapper_.insert_or_assign(info.srcAppId, info.dstAppId);
+    }
+}
+
+std::pair<std::string, std::string> AppIdMappingConfigManager::Convert(const std::string &appId,
+    const std::string &accountId)
+{
+    auto it = toDstMapper_.find(appId);
+    if (it == toDstMapper_.end()) {
+        return std::make_pair(appId, accountId);
+    }
+    return std::make_pair(it->second, "default");
+}
+
+} // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_db.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_db.cpp
index 612c5a088f3d61d69bc773b4efdb05d677e654f9..0e3c2a4c607d79173d4e437cea11c2c61336741c 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_db.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_db.cpp
@@ -35,7 +35,7 @@ int32_t CloudDB::BatchUpdate(const std::string &table, VBuckets &&values, const
     return E_NOT_SUPPORT;
 }
 
-int32_t CloudDB::BatchDelete(const std::string &table, const VBuckets &extends)
+int32_t CloudDB::BatchDelete(const std::string &table, VBuckets &extends)
 {
     return E_NOT_SUPPORT;
 }
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_event.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_event.cpp
index bfaf3c9eb16bf519dc41416ba55176eede336adc..701bce29cfc04cf90646f386c1dfeb254632c579 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_event.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_event.cpp
@@ -17,7 +17,7 @@
 
 namespace OHOS::DistributedData {
 CloudEvent::CloudEvent(int32_t evtId, StoreInfo storeInfo)
-    : Event(evtId), storeInfo_(std::move(storeInfo))
+    : Event(evtId), eventId_(evtId), storeInfo_(std::move(storeInfo))
 {
 }
 
@@ -25,4 +25,9 @@ const StoreInfo& CloudEvent::GetStoreInfo() const
 {
     return storeInfo_;
 }
+
+int32_t CloudEvent::GetEventId() const
+{
+    return eventId_;
+}
 }
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_info.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_info.cpp
index d723adfe5b37a57565e9ccb0bb90498f1da02852..191c6f88eff51b27cddde990cba8f51f2fa9e502 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_info.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_info.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "cloud/cloud_info.h"
+
 #include "utils/constant.h"
 
 namespace OHOS::DistributedData {
@@ -76,8 +77,7 @@ std::map<std::string, std::string> CloudInfo::GetSchemaKey() const
 {
     std::map<std::string, std::string> keys;
     for (const auto &[bundle, app] : apps) {
-        const auto key = GetKey(
-            SCHEMA_PREFIX, { std::to_string(user), bundle, std::to_string(app.instanceId) });
+        const auto key = GetKey(SCHEMA_PREFIX, { std::to_string(user), bundle, std::to_string(app.instanceId) });
         keys.insert_or_assign(app.bundleName, key);
     }
     return keys;
@@ -98,12 +98,12 @@ std::string CloudInfo::GetSchemaPrefix(const std::string &bundleName) const
     if (bundleName.empty()) {
         return GetKey(SCHEMA_PREFIX, { std::to_string(user) });
     }
-    return GetKey(SCHEMA_PREFIX, { std::to_string(user), bundleName});
+    return GetKey(SCHEMA_PREFIX, { std::to_string(user), bundleName });
 }
 
 std::string CloudInfo::GetSchemaKey(const StoreMetaData &meta)
 {
-    return GetKey(SCHEMA_PREFIX, { meta.user,  meta.bundleName, std::to_string(meta.instanceId) });
+    return GetKey(SCHEMA_PREFIX, { meta.user, meta.bundleName, std::to_string(meta.instanceId) });
 }
 
 bool CloudInfo::IsValid() const
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/cloud_lock_event.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_lock_event.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0bf9a1ad79953e6d62cd28bd48b2dece6a6cd8f
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/cloud_lock_event.cpp
@@ -0,0 +1,27 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "cloud/cloud_lock_event.h"
+
+namespace OHOS::DistributedData {
+CloudLockEvent::CloudLockEvent(int32_t evtId, StoreInfo storeInfo, Callback callback)
+    :CloudEvent(evtId, storeInfo), callback_(std::move(callback))
+{
+}
+CloudLockEvent::Callback CloudLockEvent::GetCallback() const
+{
+    return callback_;
+}
+} // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/schema_meta.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/schema_meta.cpp
index f22c28ae1f65380ba76f40914ae0f17f42d3f63b..e0df117706ce7c26f3b65e57341c37260e2dcb0a 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/schema_meta.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/schema_meta.cpp
@@ -39,7 +39,7 @@ std::vector<std::string> Database::GetTableNames() const
 {
     std::vector<std::string> tableNames;
     tableNames.reserve(tables.size());
-    for (auto& table : tables) {
+    for (auto &table : tables) {
         tableNames.push_back(table.name);
         if (!table.sharedTableName.empty()) {
             tableNames.push_back(table.sharedTableName);
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/sharing_center.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/sharing_center.cpp
index 0986649660c3535769b22b77e9b998a2bb11b613..cb171858d284ec4b858eb2cd85774328657fee2f 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/sharing_center.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/sharing_center.cpp
@@ -15,50 +15,50 @@
 
 #include "cloud/sharing_center.h"
 namespace OHOS::DistributedData {
-SharingCenter::Results SharingCenter::Share(int32_t userId, const std::string &bundleName,
-    const std::string &sharingRes, const Participants &participants)
+SharingCenter::Results SharingCenter::Share(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes, const Participants &participants)
 {
     return {};
 }
 
-SharingCenter::Results SharingCenter::Unshare(int32_t userId, const std::string &bundleName,
-    const std::string &sharingRes, const Participants &participants)
+SharingCenter::Results SharingCenter::Unshare(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes, const Participants &participants)
 {
     return {};
 }
 
-std::pair<int32_t, std::string> SharingCenter::Exit(int32_t userId, const std::string &bundleName,
-    const std::string &sharingRes)
+std::pair<int32_t, std::string> SharingCenter::Exit(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes)
 {
     return {};
 }
 
-SharingCenter::Results SharingCenter::ChangePrivilege(int32_t userId, const std::string &bundleName,
-    const std::string &sharingRes, const Participants &participants)
+SharingCenter::Results SharingCenter::ChangePrivilege(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes, const Participants &participants)
 {
     return {};
 }
 
-SharingCenter::QueryResults SharingCenter::Query(int32_t userId, const std::string &bundleName,
-    const std::string &sharingRes)
+SharingCenter::QueryResults SharingCenter::Query(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes)
 {
     return {};
 }
 
-SharingCenter::QueryResults SharingCenter::QueryByInvitation(int32_t userId, const std::string &bundleName,
-    const std::string &invitation)
+SharingCenter::QueryResults SharingCenter::QueryByInvitation(
+    int32_t userId, const std::string &bundleName, const std::string &invitation)
 {
     return {};
 }
 
-std::tuple<int32_t, std::string, std::string> SharingCenter::ConfirmInvitation(int32_t userId,
-    const std::string &bundleName, const std::string &invitation, int32_t confirmation)
+std::tuple<int32_t, std::string, std::string> SharingCenter::ConfirmInvitation(
+    int32_t userId, const std::string &bundleName, const std::string &invitation, int32_t confirmation)
 {
     return {};
 }
 
-std::pair<int32_t, std::string> SharingCenter::ChangeConfirmation(int32_t userId,
-    const std::string &bundleName, const std::string &sharingRes, int32_t confirmation)
+std::pair<int32_t, std::string> SharingCenter::ChangeConfirmation(
+    int32_t userId, const std::string &bundleName, const std::string &sharingRes, int32_t confirmation)
 {
     return {};
 }
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/subscription.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/subscription.cpp
index 28030d881146285152f98573b4daf1fb798c6938..1f570f3c20b3fd59a18b0e54a94e9607653a4ac1 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/subscription.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/subscription.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "cloud/subscription.h"
+
 #include "utils/constant.h"
 namespace OHOS::DistributedData {
 bool Subscription::Relation::Marshal(json &node) const
diff --git a/datamgr_service/services/distributeddataservice/framework/cloud/sync_event.cpp b/datamgr_service/services/distributeddataservice/framework/cloud/sync_event.cpp
index badf9ffee94405268fa72dd3201ee26a1618cb4c..f2c78e6c34e8b67735832ffe3d76785644c7f585 100644
--- a/datamgr_service/services/distributeddataservice/framework/cloud/sync_event.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/cloud/sync_event.cpp
@@ -22,7 +22,7 @@ SyncEvent::EventInfo::EventInfo(int32_t mode, int32_t wait, bool retry, std::sha
 }
 SyncEvent::EventInfo::EventInfo(const SyncParam &syncParam, bool retry, std::shared_ptr<GenQuery> query, GenAsync async)
     : retry_(retry), mode_(syncParam.mode), wait_(syncParam.wait), query_(std::move(query)),
-      asyncDetail_(std::move(async)), isCompensation_(syncParam.isCompensation)
+      asyncDetail_(std::move(async)), isCompensation_(syncParam.isCompensation), triggerMode_(syncParam.triggerMode)
 {
 }
 
@@ -42,6 +42,7 @@ SyncEvent::EventInfo &SyncEvent::EventInfo::operator=(SyncEvent::EventInfo &&inf
     query_ = std::move(info.query_);
     asyncDetail_ = std::move(info.asyncDetail_);
     isCompensation_ = info.isCompensation_;
+    triggerMode_ = info.triggerMode_;
     return *this;
 }
 
@@ -84,4 +85,9 @@ bool SyncEvent::IsCompensation() const
 {
     return info_.isCompensation_;
 }
+
+int32_t SyncEvent::GetTriggerMode() const
+{
+    return info_.triggerMode_;
+}
 } // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/communication/connect_manager.cpp b/datamgr_service/services/distributeddataservice/framework/communication/connect_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..74f8f70a88d4e0120b66cfc9e4eada414b975c55
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/communication/connect_manager.cpp
@@ -0,0 +1,137 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#define LOG_TAG "ConnectManager"
+#include "communication/connect_manager.h"
+
+#include "log_print.h"
+
+namespace OHOS::AppDistributedKv {
+std::mutex ConnectManager::mtx_;
+std::shared_ptr<ConnectManager> ConnectManager::instance_ = nullptr;
+ConnectManager::CloseSessionTask ConnectManager::closeSessionTask_ = nullptr;
+ConcurrentMap<std::string, ConnectManager::SessionCloseListener> ConnectManager::sessionCloseListener_;
+ConcurrentMap<std::string, ConnectManager::SessionOpenListener> ConnectManager::sessionOpenListener_;
+
+std::shared_ptr<ConnectManager> ConnectManager::GetInstance()
+{
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [&]() {
+        std::lock_guard<std::mutex> lock(mtx_);
+        if (instance_ == nullptr) {
+            instance_ = std::make_shared<ConnectManager>();
+        }
+    });
+    return instance_;
+}
+
+bool ConnectManager::RegisterInstance(std::shared_ptr<ConnectManager> instance)
+{
+    std::lock_guard<std::mutex> lock(mtx_);
+    if (instance_ != nullptr) {
+        ZLOGW("ConnectManager instance has been replaced!");
+    }
+    instance_ = instance;
+    return true;
+}
+
+bool ConnectManager::CloseSession(const std::string &networkId)
+{
+    if (closeSessionTask_ != nullptr) {
+        return closeSessionTask_(networkId);
+    }
+    return false;
+}
+
+bool ConnectManager::RegisterCloseSessionTask(CloseSessionTask task)
+{
+    if (closeSessionTask_ != nullptr) {
+        ZLOGE("Register close session task error, task already exists.");
+        return false;
+    }
+    closeSessionTask_ = std::move(task);
+    return true;
+}
+
+bool ConnectManager::RegisterSessionCloseListener(const std::string &name, SessionCloseListener listener)
+{
+    bool success = false;
+    sessionCloseListener_.Compute(name, [&success, &listener](const auto &key, auto &value) {
+        if (value != nullptr) {
+            ZLOGE("Register session close listener error, type:%{public}s already exists.", key.c_str());
+            return true;
+        }
+        value = std::move(listener);
+        success = true;
+        return true;
+    });
+    return success;
+}
+
+void ConnectManager::UnRegisterSessionCloseListener(const std::string &name)
+{
+    sessionCloseListener_.Erase(name);
+}
+
+void ConnectManager::OnSessionClose(const std::string &networkId)
+{
+    sessionCloseListener_.ForEach([&networkId](const auto &key, auto &listener) {
+        listener(networkId);
+        return false;
+    });
+}
+
+bool ConnectManager::RegisterSessionOpenListener(const std::string &name, SessionOpenListener listener)
+{
+    bool success = false;
+    sessionOpenListener_.Compute(name, [&success, &listener](const auto &key, auto &value) {
+        if (value != nullptr) {
+            ZLOGE("Register session open listener error, type:%{public}s already exists.", key.c_str());
+            return true;
+        }
+        value = std::move(listener);
+        success = true;
+        return true;
+    });
+    return success;
+}
+
+void ConnectManager::UnRegisterSessionOpenListener(const std::string &name)
+{
+    sessionOpenListener_.Erase(name);
+}
+
+void ConnectManager::OnSessionOpen(const std::string &networkId)
+{
+    sessionOpenListener_.ForEach([&networkId](const auto &key, auto &listener) {
+        listener(networkId);
+        return false;
+    });
+}
+
+void ConnectManager::OnStart()
+{
+}
+
+void ConnectManager::OnDestory()
+{
+}
+
+int32_t ConnectManager::ApplyConnect(__attribute__((unused)) const std::string &networkId, ConnectTask task)
+{
+    task();
+    return 0;
+}
+} // OHOS::AppDistributedKv
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/directory/directory_manager.cpp b/datamgr_service/services/distributeddataservice/framework/directory/directory_manager.cpp
index 16b34ce02aff6727fdf08e8148d556e357729253..bb954fd151c1e5713d2b74c200df2b44549bd8a2 100644
--- a/datamgr_service/services/distributeddataservice/framework/directory/directory_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/directory/directory_manager.cpp
@@ -117,18 +117,18 @@ std::string DirectoryManager::GetType(const StoreMetaData &metaData) const
 
 std::string DirectoryManager::GetStore(const StoreMetaData &metaData) const
 {
-    if (metaData.storeType >= StoreMetaData::StoreType::STORE_KV_BEGIN
-        && metaData.storeType <= StoreMetaData::StoreType::STORE_KV_END) {
+    if (metaData.storeType >= StoreMetaData::StoreType::STORE_KV_BEGIN &&
+        metaData.storeType <= StoreMetaData::StoreType::STORE_KV_END) {
         return "kvdb";
     }
     // rdb use empty session
-    if (metaData.storeType >= StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN
-        && metaData.storeType <= StoreMetaData::StoreType::STORE_RELATIONAL_END) {
+    if (metaData.storeType >= StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN &&
+        metaData.storeType <= StoreMetaData::StoreType::STORE_RELATIONAL_END) {
         return "rdb";
     }
     // object use meta
-    if (metaData.storeType >= StoreMetaData::StoreType::STORE_OBJECT_BEGIN
-        && metaData.storeType <= StoreMetaData::StoreType::STORE_OBJECT_END) {
+    if (metaData.storeType >= StoreMetaData::StoreType::STORE_OBJECT_BEGIN &&
+        metaData.storeType <= StoreMetaData::StoreType::STORE_OBJECT_END) {
         return "kvdb";
     }
     return "other";
@@ -142,7 +142,8 @@ std::string DirectoryManager::GetSecurity(const StoreMetaData &metaData) const
                 break;
             }
             [[fallthrough]];
-        case SecurityLevel::S0: [[fallthrough]];
+        case SecurityLevel::S0:
+            [[fallthrough]];
         case SecurityLevel::S1:
             return "misc_de";
     }
@@ -271,4 +272,41 @@ bool DirectoryManager::CreateDirectory(const std::string &path) const
 
     return access(path.c_str(), F_OK) == 0;
 }
+
+bool DirectoryManager::DeleteDirectory(const char* path)
+{
+    if (path == nullptr) {
+        return false;
+    }
+    DIR* dir;
+    struct dirent* dirEntry;
+    struct stat buf;
+    char* curWorkDir = getcwd(nullptr, 0);
+    if ((dir = opendir(path)) == nullptr) {
+        return true;
+    }
+    if (chdir(path) == -1) {
+        return false;
+    }
+    while ((dirEntry = readdir(dir))) {
+        if ((strcmp(dirEntry->d_name, ".") == 0) || (strcmp(dirEntry->d_name, "..") == 0)) {
+            continue;
+        }
+        if (stat(dirEntry->d_name, &buf) == -1) {
+            return false;
+        }
+        if (S_ISDIR(buf.st_mode)) {
+            DeleteDirectory(dirEntry->d_name);
+            continue;
+        }
+        if (remove(dirEntry->d_name) == -1) {
+            return false;
+        }
+    }
+    closedir(dir);
+    if (chdir(curWorkDir) == -1 || rmdir(path) == -1) {
+        return false;
+    }
+    return true;
+}
 } // namespace OHOS::DistributedData
diff --git a/datamgr_service/services/distributeddataservice/adapter/include/account/account_delegate.h b/datamgr_service/services/distributeddataservice/framework/include/account/account_delegate.h
similarity index 82%
rename from datamgr_service/services/distributeddataservice/adapter/include/account/account_delegate.h
rename to datamgr_service/services/distributeddataservice/framework/include/account/account_delegate.h
index 4c6458158d39809e891642f80c566b7e2b0bae64..29a8c7e4570d660be546eeb9e992f5a762c673a0 100644
--- a/datamgr_service/services/distributeddataservice/adapter/include/account/account_delegate.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/account/account_delegate.h
@@ -16,8 +16,9 @@
 #ifndef DISTRIBUTEDDATAMGR_ACCOUNT_DELEGATE_H
 #define DISTRIBUTEDDATAMGR_ACCOUNT_DELEGATE_H
 
-#include <mutex>
 #include <memory>
+#include <mutex>
+
 #include "executor_pool.h"
 #include "types.h"
 #include "visibility.h"
@@ -26,11 +27,11 @@ namespace OHOS {
 namespace DistributedKv {
 enum class AccountStatus {
     HARMONY_ACCOUNT_LOGIN = 0, // the openHarmony account is logged in
-    HARMONY_ACCOUNT_LOGOUT, // the openHarmony account is logged out
-    HARMONY_ACCOUNT_DELETE, // the openHarmony account is deleted
-    DEVICE_ACCOUNT_DELETE, // the device account is deleted
-    DEVICE_ACCOUNT_SWITCHED, // the device account is switched
-    DEVICE_ACCOUNT_UNLOCKED, // the device account is unlocked
+    HARMONY_ACCOUNT_LOGOUT,    // the openHarmony account is logged out
+    HARMONY_ACCOUNT_DELETE,    // the openHarmony account is deleted
+    DEVICE_ACCOUNT_DELETE,     // the device account is deleted
+    DEVICE_ACCOUNT_SWITCHED,   // the device account is switched
+    DEVICE_ACCOUNT_UNLOCKED,   // the device account is unlocked
 };
 
 struct AccountEventInfo {
@@ -54,7 +55,7 @@ public:
         API_EXPORT virtual std::string Name() = 0;
         API_EXPORT virtual LevelType GetLevel() = 0;
     };
-    using HashFunc = std::string(*)(const void *data, size_t size, bool isUpper);
+    using HashFunc = std::string (*)(const void *data, size_t size, bool isUpper);
     API_EXPORT virtual ~AccountDelegate() = default;
     API_EXPORT virtual Status Subscribe(std::shared_ptr<Observer> observer) = 0;
     API_EXPORT virtual Status Unsubscribe(std::shared_ptr<Observer> observer) = 0;
@@ -71,11 +72,11 @@ public:
     API_EXPORT virtual void BindExecutor(std::shared_ptr<ExecutorPool> executors) = 0;
     API_EXPORT virtual std::string GetUnencryptedAccountId(int32_t userId = 0) const = 0;
     API_EXPORT static AccountDelegate *GetInstance();
+    API_EXPORT static bool RegisterAccountInstance(AccountDelegate *instance);
 
 private:
-    using BaseInstance = AccountDelegate *(*)();
-    static BaseInstance getInstance_;
+    static AccountDelegate *instance_;
 };
-}  // namespace DistributedKv
-}  // namespace OHOS
+} // namespace DistributedKv
+} // namespace OHOS
 #endif // DISTRIBUTEDDATAMGR_ACCOUNT_DELEGATE_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/app_id_mapping/app_id_mapping_config_manager.h b/datamgr_service/services/distributeddataservice/framework/include/app_id_mapping/app_id_mapping_config_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..9799f9af673fa969a71d9d01cf57b249b6b09592
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/include/app_id_mapping/app_id_mapping_config_manager.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_APP_ID_MAPPING_CONFIG_MANAGER_H
+#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_APP_ID_MAPPING_CONFIG_MANAGER_H
+#include <string>
+#include <vector>
+#include <map>
+#include "visibility.h"
+namespace OHOS {
+namespace DistributedData {
+class AppIdMappingConfigManager {
+public:
+    struct AppMappingInfo {
+        std::string srcAppId;
+        std::string dstAppId;
+    };
+    API_EXPORT static AppIdMappingConfigManager &GetInstance();
+    API_EXPORT void Initialize(const std::vector<AppMappingInfo> &mapper);
+    API_EXPORT std::pair<std::string, std::string> Convert(const std::string &appId,
+        const std::string &accountId);
+
+private:
+    std::map<std::string, std::string> toDstMapper_;
+};
+
+} // namespace DistributedData
+} // namespace OHOS
+#endif //OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_APP_ID_MAPPING_CONFIG_MANAGER_H
diff --git a/datamgr_service/services/distributeddataservice/framework/include/changeevent/remote_change_event.h b/datamgr_service/services/distributeddataservice/framework/include/changeevent/remote_change_event.h
index 8236df1b429e76c7c73768e2152762389bb24741..bf58f4328937a5fa76140409c8baf4be77ed95fe 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/changeevent/remote_change_event.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/changeevent/remote_change_event.h
@@ -33,6 +33,7 @@ public:
         std::string storeId;
         std::string deviceId;
         std::string bundleName;
+        int changeType = 0; // 0 means CLOUD_DATA_CHANGE
         std::vector<std::string> tables;
     };
 
diff --git a/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_db.h b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_db.h
index f0517d10c07333238fd79e0b23ec80192575e3a7..6927a277a20fdcf004960657e8d778e9c8c732ba 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_db.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_db.h
@@ -38,7 +38,7 @@ public:
 
     virtual int32_t BatchUpdate(const std::string &table, VBuckets &&values, const VBuckets &extends);
 
-    virtual int32_t BatchDelete(const std::string &table, const VBuckets &extends);
+    virtual int32_t BatchDelete(const std::string &table, VBuckets &extends);
 
     virtual std::shared_ptr<Cursor> Query(const std::string &table, const VBucket &extend);
 
diff --git a/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_event.h b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_event.h
index 0ac070ad609a5f1731da69ace445f0b33adf2d40..8cd2d2d47b3df14737edf6ad688450dc80cf14ce 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_event.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_event.h
@@ -27,20 +27,26 @@ public:
         FEATURE_INIT = EVT_CLOUD,
         GET_SCHEMA,
         LOCAL_CHANGE,
+        CLEAN_DATA,
         CLOUD_SYNC,
         DATA_CHANGE,
+        SET_SEARCHABLE,
         CLOUD_SHARE,
         MAKE_QUERY,
         CLOUD_SYNC_FINISHED,
         DATA_SYNC,
+        LOCK_CLOUD_CONTAINER,
+        UNLOCK_CLOUD_CONTAINER,
         CLOUD_BUTT
     };
 
     CloudEvent(int32_t evtId, StoreInfo storeInfo);
     ~CloudEvent() = default;
     const StoreInfo& GetStoreInfo() const;
+    int32_t GetEventId() const;
 
 private:
+    int32_t eventId_;
     StoreInfo storeInfo_;
 };
 } // namespace OHOS::DistributedData
diff --git a/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_lock_event.h b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_lock_event.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbced1b0324d1f5046b263c1ddeed1af5ad1e8f4
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/include/cloud/cloud_lock_event.h
@@ -0,0 +1,34 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_LOCK_EVENT_H
+#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_LOCK_EVENT_H
+#include "cloud/cloud_event.h"
+#include "store/general_value.h"
+#include "store/general_store.h"
+#include "visibility.h"
+
+namespace OHOS::DistributedData {
+class API_EXPORT CloudLockEvent : public CloudEvent {
+public:
+    using Callback = std::function<void(int32_t status, uint32_t expiredTime)>;
+    CloudLockEvent(int32_t evtId, StoreInfo storeInfo, Callback callback);
+    ~CloudLockEvent() override = default;
+    Callback GetCallback() const;
+private:
+    Callback callback_;
+};
+} // namespace OHOS::DistributedData
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_LOCK_EVENT_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/cloud/sync_event.h b/datamgr_service/services/distributeddataservice/framework/include/cloud/sync_event.h
index 9887d9a77920d163297a91cee04b9a8b75bfdd1b..22a06c077f1d891121c71d1278b2462dad24349e 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/cloud/sync_event.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/cloud/sync_event.h
@@ -37,6 +37,7 @@ public:
         std::shared_ptr<GenQuery> query_;
         GenAsync asyncDetail_;
         bool isCompensation_ = false;
+        int32_t triggerMode_ = MODE_DEFAULT;
     };
     SyncEvent(StoreInfo storeInfo, EventInfo info);
     ~SyncEvent() override = default;
@@ -46,7 +47,7 @@ public:
     std::shared_ptr<GenQuery> GetQuery() const;
     GenAsync GetAsyncDetail() const;
     bool IsCompensation() const;
-
+    int32_t GetTriggerMode() const;
 protected:
     SyncEvent(int32_t evtId, StoreInfo storeInfo, EventInfo info);
 
diff --git a/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_change_event.h b/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_change_event.h
index be3970cdf26bccc83eb53587e9b60d24c7d9553f..d66482886b232bf3715f5073b8347b9a4b5f2b84 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_change_event.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_change_event.h
@@ -27,6 +27,7 @@ public:
     using TableProperties = std::map<std::string, TableChangeProperties>;
     struct EventInfo {
         TableProperties tableProperties;
+        bool isFull;
     };
 
     DataChangeEvent(StoreInfo storeInfo, EventInfo evtInfo)
@@ -40,6 +41,11 @@ public:
     {
         return info_.tableProperties;
     }
+
+    bool IsFull() const
+    {
+        return info_.isFull;
+    }
 private:
     EventInfo info_;
 };
diff --git a/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_sync_event.h b/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_sync_event.h
index 51e83a7d1cd0a778fd1cd814cb25ac1cb06da2d1..5ff60b65af1c0b1025ae90b8b2b49c3f22e17a36 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_sync_event.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/commonevent/data_sync_event.h
@@ -26,8 +26,9 @@ public:
         FINISH,
     };
 
-    DataSyncEvent(StoreInfo storeInfo, uint32_t syncMode, int32_t status)
-        : CloudEvent(DATA_SYNC, std::move(storeInfo)), syncMode_(syncMode), status_(std::move(status))
+    DataSyncEvent(StoreInfo storeInfo, uint32_t syncMode, int32_t status, uint32_t traceId, uint32_t count = 0)
+        : CloudEvent(DATA_SYNC, std::move(storeInfo)), syncMode_(syncMode), status_(std::move(status)),
+        traceId_(traceId), count_(count)
     {
     }
 
@@ -38,14 +39,26 @@ public:
         return syncMode_;
     }
 
-    uint32_t GetSyncStatus() const
+    int32_t GetSyncStatus() const
     {
         return status_;
     }
 
+    uint32_t GetTraceId() const
+    {
+        return traceId_;
+    }
+
+    uint32_t GetCount() const
+    {
+        return count_;
+    }
+
 private:
     uint32_t syncMode_;
     int32_t status_;
+    uint32_t traceId_;
+    uint32_t count_;
 };
 } // OHOS::DistributedData
 #endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMON_EVENT_DATA_SYNC_EVENT_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/commonevent/set_searchable_event.h b/datamgr_service/services/distributeddataservice/framework/include/commonevent/set_searchable_event.h
new file mode 100644
index 0000000000000000000000000000000000000000..833ddd82e88652ff291304504dd182917008d71d
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/include/commonevent/set_searchable_event.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMON_EVENT_SET_SEARCHABLE_EVENT_H
+#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMON_EVENT_SET_SEARCHABLE_EVENT_H
+
+#include "cloud/cloud_event.h"
+#include "visibility.h"
+namespace OHOS::DistributedData {
+class API_EXPORT SetSearchableEvent : public CloudEvent {
+public:
+    struct EventInfo {
+        bool isSearchable;
+    };
+
+    SetSearchableEvent(StoreInfo storeInfo, EventInfo evtInfo)
+        : CloudEvent(SET_SEARCHABLE, std::move(storeInfo)), info_(std::move(evtInfo))
+    {
+    }
+
+    ~SetSearchableEvent() override = default;
+
+    bool GetIsSearchabl() const
+    {
+        return info_.isSearchable;
+    }
+private:
+    EventInfo info_;
+};
+} // OHOS::DistributedData
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMON_EVENT_SET_SEARCHABLE_EVENT_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/communication/connect_manager.h b/datamgr_service/services/distributeddataservice/framework/include/communication/connect_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e9093c75964e43dbd631edb5bbe67062129005e
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/include/communication/connect_manager.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMUNICATION_CONNECT_MANAGER_H
+#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMUNICATION_CONNECT_MANAGER_H
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+
+#include "concurrent_map.h"
+#include "visibility.h"
+namespace OHOS {
+namespace AppDistributedKv {
+class API_EXPORT ConnectManager {
+public:
+    using ConnectTask = std::function<void(void)>;
+    using CloseSessionTask = std::function<bool(const std::string &networkId)>;
+    using SessionCloseListener = std::function<void(const std::string &networkId)>;
+    using SessionOpenListener = std::function<void(const std::string &networkId)>;
+
+    API_EXPORT static std::shared_ptr<ConnectManager> GetInstance();
+    API_EXPORT static bool RegisterInstance(std::shared_ptr<ConnectManager> instance);
+
+    API_EXPORT static bool CloseSession(const std::string &networkId);
+    API_EXPORT static bool RegisterCloseSessionTask(CloseSessionTask task);
+
+    API_EXPORT static bool RegisterSessionCloseListener(const std::string &name, SessionCloseListener listener);
+    API_EXPORT static void UnRegisterSessionCloseListener(const std::string &name);
+    API_EXPORT static void OnSessionClose(const std::string &networkId);
+
+    API_EXPORT static bool RegisterSessionOpenListener(const std::string &name, SessionOpenListener listener);
+    API_EXPORT static void UnRegisterSessionOpenListener(const std::string &name);
+    API_EXPORT static void OnSessionOpen(const std::string &networkId);
+
+    ConnectManager() = default;
+    virtual ~ConnectManager() = default;
+
+    virtual void OnStart();
+    virtual void OnDestory();
+    virtual int32_t ApplyConnect(const std::string &networkId, ConnectTask task);
+
+private:
+    static std::mutex mtx_;
+    static std::shared_ptr<ConnectManager> instance_;
+    static CloseSessionTask closeSessionTask_;
+    static ConcurrentMap<std::string, SessionCloseListener> sessionCloseListener_;
+    static ConcurrentMap<std::string, SessionOpenListener> sessionOpenListener_;
+};
+} // namespace AppDistributedKv
+} // namespace OHOS
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_COMMUNICATION_CONNECT_MANAGER_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/directory/directory_manager.h b/datamgr_service/services/distributeddataservice/framework/include/directory/directory_manager.h
index 737b7f5fc51814c10fe4455d0e83d0cc2055e3b2..e2642ec86373d546adf58d50add3586c189e894b 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/directory/directory_manager.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/directory/directory_manager.h
@@ -40,6 +40,7 @@ public:
     API_EXPORT std::vector<uint32_t> GetVersions();
     API_EXPORT void Initialize(const std::vector<Strategy> &strategies);
     API_EXPORT bool CreateDirectory(const std::string &path) const;
+    API_EXPORT bool DeleteDirectory(const char* path);
 
 private:
     using Action = std::string (DirectoryManager::*)(const StoreMetaData &) const;
diff --git a/datamgr_service/services/distributeddataservice/framework/include/error/general_error.h b/datamgr_service/services/distributeddataservice/framework/include/error/general_error.h
index 25c3cdf861df2ae428d4919c96bb66704375fcf4..f798cecfceb7cb07164ccbcb8b90f63fa41117bc 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/error/general_error.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/error/general_error.h
@@ -39,6 +39,19 @@ enum GeneralError : int32_t {
     E_RECORD_EXIST_CONFLICT,
     E_WITH_INVENTORY_DATA,
     E_SYNC_TASK_MERGED,
+    E_RECORD_NOT_FOUND,
+    E_RECORD_ALREADY_EXISTED,
+    E_DB_ERROR,
+    E_INVALID_VALUE_FIELDS,
+    E_INVALID_FIELD_TYPE,
+    E_CONSTRAIN_VIOLATION,
+    E_INVALID_FORMAT,
+    E_INVALID_QUERY_FORMAT,
+    E_INVALID_QUERY_FIELD,
+    E_TIME_OUT,
+    E_OVER_MAX_LIMITS,
+    E_SECURITY_LEVEL_ERROR,
+    E_FILE_NOT_EXIST,
     E_BUTT,
 };
 }
diff --git a/datamgr_service/services/distributeddataservice/framework/include/metadata/auto_launch_meta_data.h b/datamgr_service/services/distributeddataservice/framework/include/metadata/auto_launch_meta_data.h
index de1da05c6dbd09d4a4e1a03440b711f3afdf12d1..293e3c2a021e9ac20ba9c5147f7feb503465191d 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/metadata/auto_launch_meta_data.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/metadata/auto_launch_meta_data.h
@@ -21,6 +21,7 @@
 namespace OHOS::DistributedData {
 struct API_EXPORT AutoLaunchMetaData final : public Serializable {
     std::map<std::string, std::vector<std::string>> datas;
+    bool launchForCleanData = false;
 
     API_EXPORT AutoLaunchMetaData();
     API_EXPORT ~AutoLaunchMetaData() = default;
diff --git a/datamgr_service/services/distributeddataservice/framework/include/metadata/matrix_meta_data.h b/datamgr_service/services/distributeddataservice/framework/include/metadata/matrix_meta_data.h
index ac6ee82a4ad4d76b0e6e06dcb150a26b986fdf84..909be37dfef9c25e273986d59a5f979fc3790b91 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/metadata/matrix_meta_data.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/metadata/matrix_meta_data.h
@@ -48,4 +48,4 @@ private:
     static constexpr const char *RMOTE_CONSISTENT = "Consistent";
 };
 } // namespace OHOS::DistributedData
-#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_METADATA_MATRIX_META_DATA_H
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_METADATA_MATRIX_META_DATA_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/metadata/store_meta_data.h b/datamgr_service/services/distributeddataservice/framework/include/metadata/store_meta_data.h
index 61bf6fd04c31526e1d0cfda90e3148fb8773a371..ff5e203a0cc300898fd77dace0d2b5ff4a33361b 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/metadata/store_meta_data.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/metadata/store_meta_data.h
@@ -45,6 +45,7 @@ struct API_EXPORT StoreMetaData final : public Serializable {
     int32_t area = 0;
     int32_t uid = -1;
     int32_t instanceId = 0;
+    int32_t haMode = 0;
     uint32_t tokenId = 0;
     std::string appId = "";
     std::string appType = "";
@@ -57,6 +58,7 @@ struct API_EXPORT StoreMetaData final : public Serializable {
     std::string storeId = "";
     std::string user = "";
     std::string account = "";
+    int32_t authType = 0;
 
     enum StoreType {
         STORE_KV_BEGIN = 0,
diff --git a/datamgr_service/services/distributeddataservice/framework/include/screen/screen_manager.h b/datamgr_service/services/distributeddataservice/framework/include/screen/screen_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbf7c8666ed2fe73674f5e5039b4ae1805b14908
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/include/screen/screen_manager.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DISTRIBUTEDDATAMGR_FRAMEWORK_SCREEN_LOCK_H
+#define DISTRIBUTEDDATAMGR_FRAMEWORK_SCREEN_LOCK_H
+
+#include <memory>
+#include <mutex>
+#include "visibility.h"
+
+namespace OHOS {
+namespace DistributedData {
+class ScreenManager {
+public:
+    API_EXPORT static std::shared_ptr<ScreenManager> GetInstance();
+    API_EXPORT static bool RegisterInstance(std::shared_ptr<ScreenManager> instance);
+    ScreenManager() = default;
+    virtual ~ScreenManager() = default;
+    virtual bool IsLocked();
+
+private:
+    static std::mutex mutex_;
+    static std::shared_ptr<ScreenManager> instance_;
+};
+} // namespace DistributedData
+} // namespace OHOS
+#endif //DISTRIBUTEDDATAMGR_FRAMEWORK_SCREEN_LOCK_H
diff --git a/datamgr_service/services/distributeddataservice/framework/include/store/auto_cache.h b/datamgr_service/services/distributeddataservice/framework/include/store/auto_cache.h
index 9fcf14a4c1e0bed70eacfa045f442bbf9a52a402..0ee41a97222dd952e1d31258874cbfa73fb070c7 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/store/auto_cache.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/store/auto_cache.h
@@ -50,9 +50,7 @@ public:
 
     API_EXPORT Stores GetStoresIfPresent(uint32_t tokenId, const std::string &storeName = "");
 
-    API_EXPORT void CloseStore(uint32_t tokenId, const std::string &storeId);
-
-    API_EXPORT void CloseStore(uint32_t tokenId);
+    API_EXPORT void CloseStore(uint32_t tokenId, const std::string &storeId = "");
 
     API_EXPORT void CloseExcept(const std::set<int32_t> &users);
 
@@ -69,11 +67,14 @@ private:
     void StartTimer();
     struct Delegate : public GeneralWatcher {
         Delegate(GeneralStore *delegate, const Watchers &watchers, int32_t user, const StoreMetaData &meta);
+        Delegate(const Delegate& delegate);
         ~Delegate();
         operator Store();
         bool operator<(const Time &time) const;
         bool Close();
         int32_t GetUser() const;
+        int32_t GetArea() const;
+        const std::string& GetDataDir() const;
         void SetObservers(const Watchers &watchers);
         int32_t OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values) override;
         int32_t OnChange(const Origin &origin, const Fields &fields, ChangeData &&datas) override;
@@ -84,7 +85,7 @@ private:
         GeneralStore *store_ = nullptr;
         Watchers watchers_;
         int32_t user_;
-        StoreMetaData meta_;
+        const StoreMetaData meta_;
         std::shared_mutex mutex_;
     };
 
@@ -96,6 +97,7 @@ private:
     ConcurrentMap<uint32_t, std::map<std::string, Delegate>> stores_;
     ConcurrentMap<uint32_t, std::set<std::string>> disables_;
     Creator creators_[MAX_CREATOR_NUM];
+    std::set<std::string> disableStores_;
 };
 } // namespace OHOS::DistributedData
-#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_STORE_STORE_AUTO_CACHE_H
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_STORE_STORE_AUTO_CACHE_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/include/store/general_store.h b/datamgr_service/services/distributeddataservice/framework/include/store/general_store.h
index 17f9db29d3fb274aff98922bda8bd6ecf21c2363..efc2db665a067774de5591daa374b65148cbbb9f 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/store/general_store.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/store/general_store.h
@@ -20,10 +20,12 @@
 #include <memory>
 #include <set>
 
+#include "executor_pool.h"
 #include "snapshot/snapshot.h"
 #include "store/cursor.h"
 #include "store/general_value.h"
 #include "store/general_watcher.h"
+
 namespace OHOS::DistributedData {
 class CloudDB;
 class AssetLoader;
@@ -33,6 +35,7 @@ public:
     using Watcher = GeneralWatcher;
     using DetailAsync = GenAsync;
     using Devices = std::vector<std::string>;
+    using Executor = ExecutorPool;
     enum SyncMode {
         NEARBY_BEGIN,
         NEARBY_PUSH = NEARBY_BEGIN,
@@ -60,6 +63,15 @@ public:
         CLEAN_MODE_BUTT
     };
 
+    enum Area : int32_t {
+        EL0,
+        EL1,
+        EL2,
+        EL3,
+        EL4,
+        EL5
+    };
+
     static inline uint32_t MixMode(uint32_t syncMode, uint32_t highMode)
     {
         return syncMode | highMode;
@@ -107,6 +119,8 @@ public:
 
     virtual ~GeneralStore() = default;
 
+    virtual void SetExecutor(std::shared_ptr<Executor> executor) = 0;
+
     virtual int32_t Bind(Database &database, const std::map<uint32_t, BindInfo> &bindInfos,
         const CloudConfig &config) = 0;
 
@@ -129,13 +143,14 @@ public:
 
     virtual int32_t Delete(const std::string &table, const std::string &sql, Values &&args) = 0;
 
-    virtual std::shared_ptr<Cursor> Query(const std::string &table, const std::string &sql, Values &&args) = 0;
+    virtual std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, const std::string &sql,
+        Values &&args) = 0;
 
-    virtual std::shared_ptr<Cursor> Query(const std::string &table, GenQuery &query) = 0;
+    virtual std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, GenQuery &query) = 0;
 
     virtual int32_t Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm) = 0;
 
-    virtual std::shared_ptr<Cursor> PreSharing(GenQuery &query) = 0;
+    virtual std::pair<int32_t, std::shared_ptr<Cursor>> PreSharing(GenQuery &query) = 0;
 
     virtual int32_t Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName) = 0;
 
@@ -147,7 +162,7 @@ public:
 
     virtual int32_t UnregisterDetailProgressObserver() = 0;
 
-    virtual int32_t Close() = 0;
+    virtual int32_t Close(bool isForce = false) = 0;
 
     virtual int32_t AddRef() = 0;
 
@@ -162,6 +177,10 @@ public:
     virtual void SetEqualIdentifier(const std::string &appId, const std::string &storeId) {};
 
     virtual void SetConfig(const StoreConfig &storeConfig) {};
+
+    virtual std::pair<int32_t, uint32_t> LockCloudDB() = 0;
+
+    virtual int32_t UnLockCloudDB() = 0;
 };
 } // namespace OHOS::DistributedData
 #endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_STORE_GENERAL_STORE_H
diff --git a/datamgr_service/services/distributeddataservice/framework/include/store/general_value.h b/datamgr_service/services/distributeddataservice/framework/include/store/general_value.h
index aed711a11da17a77f569efd88a0d1ffaddef9197..f0bc9b2504a6e6901f5d7c3149329467a6d2471a 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/store/general_value.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/store/general_value.h
@@ -31,6 +31,15 @@ enum GenProgress {
     SYNC_FINISH,
 };
 
+enum SyncTriggerMode {
+    MODE_DEFAULT = 0,
+    MODE_PUSH,
+    MODE_ONLINE,
+    MODE_UNLOCK,
+    MODE_BROADCASTER,
+    MODE_CONSISTENCY,
+};
+
 struct GenStatistic {
     uint32_t total;
     uint32_t success;
@@ -47,6 +56,7 @@ struct GenProgressDetail {
     int32_t progress;
     int32_t code;
     int32_t dbCode;
+    uint64_t changeCount = 0;
     std::map<std::string, GenTableDetail> details;
 };
 
@@ -86,6 +96,7 @@ struct SyncParam {
     int32_t mode;
     int32_t wait;
     bool isCompensation = false;
+    int32_t triggerMode = MODE_DEFAULT;
 };
 
 using Assets = std::vector<Asset>;
diff --git a/datamgr_service/services/distributeddataservice/framework/include/utils/constant.h b/datamgr_service/services/distributeddataservice/framework/include/utils/constant.h
index ff0dffda86d90b6ba67a86a1496cf625c2b24056..bfeaee6b31e945ef1564d6847c8c4742d08a76ae 100644
--- a/datamgr_service/services/distributeddataservice/framework/include/utils/constant.h
+++ b/datamgr_service/services/distributeddataservice/framework/include/utils/constant.h
@@ -42,6 +42,8 @@ public:
 
     API_EXPORT static bool NotEqual(bool first, bool second);
 
+    API_EXPORT static std::vector<std::string> Split(const std::string &str, const std::string &delim);
+
     template<typename T>
     inline static constexpr bool is_pod = (std::is_standard_layout_v<T> && std::is_trivial_v<T>);
 
diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/auto_launch_meta_data.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/auto_launch_meta_data.cpp
index 3224368c419088697c3fa1b26573c653afc1306b..8ecf15edddbd50137803c917fbd2b5a8de6ec88c 100644
--- a/datamgr_service/services/distributeddataservice/framework/metadata/auto_launch_meta_data.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/metadata/auto_launch_meta_data.cpp
@@ -25,12 +25,14 @@ AutoLaunchMetaData::AutoLaunchMetaData()
 bool AutoLaunchMetaData::Marshal(json& node) const
 {
     SetValue(node[GET_NAME(datas)], datas);
+    SetValue(node[GET_NAME(launchForCleanData)], launchForCleanData);
     return true;
 }
 
 bool AutoLaunchMetaData::Unmarshal(const json& node)
 {
     GetValue(node, GET_NAME(datas), datas);
+    GetValue(node, GET_NAME(launchForCleanData), launchForCleanData);
     return true;
 }
 
diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp
index 1f77a82b3bc605606698ae13a39e441365a4c273..777a8d9396902324bc32be67d130ac4c25e667d3 100644
--- a/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/metadata/meta_data_manager.cpp
@@ -29,8 +29,8 @@ public:
     using DBOrigin = DistributedDB::Origin;
     using DBChangeData = DistributedDB::ChangedData;
     using Type = DistributedDB::Type;
-    MetaObserver(std::shared_ptr<MetaStore> metaStore,
-        std::shared_ptr<Filter> filter, Observer observer, bool isLocal = false);
+    MetaObserver(std::shared_ptr<MetaStore> metaStore, std::shared_ptr<Filter> filter, Observer observer,
+        bool isLocal = false);
     virtual ~MetaObserver();
 
     // Database change callback
@@ -38,14 +38,15 @@ public:
     void OnChange(DBOrigin origin, const std::string &originalId, DBChangeData &&data) override;
 
     void HandleChanges(int32_t flag, std::vector<std::vector<Type>> &priData);
+
 private:
     std::shared_ptr<MetaStore> metaStore_;
     std::shared_ptr<Filter> filter_;
     Observer observer_;
 };
 
-MetaObserver::MetaObserver(std::shared_ptr<MetaStore> metaStore,
-    std::shared_ptr<Filter> filter, Observer observer, bool isLocal)
+MetaObserver::MetaObserver(
+    std::shared_ptr<MetaStore> metaStore, std::shared_ptr<Filter> filter, Observer observer, bool isLocal)
     : metaStore_(std::move(metaStore)), filter_(std::move(filter)), observer_(std::move(observer))
 {
     if (metaStore_ != nullptr) {
@@ -78,8 +79,7 @@ std::vector<uint8_t> MetaDataManager::Filter::GetKey() const
     return std::vector<uint8_t>();
 }
 
-MetaDataManager::Filter::Filter(const std::string &pattern)
-    : pattern_(pattern)
+MetaDataManager::Filter::Filter(const std::string &pattern) : pattern_(pattern)
 {
 }
 
@@ -191,8 +191,8 @@ bool MetaDataManager::SaveMeta(const std::string &key, const Serializable &value
         cloudSyncer_();
     }
     if (status != DistributedDB::DBStatus::OK) {
-        ZLOGE("failed! status:%{public}d isLocal:%{public}d, key:%{public}s",
-            status, isLocal, Anonymous::Change(key).c_str());
+        ZLOGE("failed! status:%{public}d isLocal:%{public}d, key:%{public}s", status, isLocal,
+            Anonymous::Change(key).c_str());
     }
     return status == DistributedDB::DBStatus::OK;
 }
@@ -256,8 +256,7 @@ bool MetaDataManager::Sync(const std::vector<std::string> &devices, OnComplete c
     if (!inited_ || devices.empty()) {
         return false;
     }
-    auto status = metaStore_->Sync(
-        devices, DistributedDB::SyncMode::SYNC_MODE_PUSH_PULL, [complete](auto &dbResults) {
+    auto status = metaStore_->Sync(devices, DistributedDB::SyncMode::SYNC_MODE_PUSH_PULL, [complete](auto &dbResults) {
         std::map<std::string, int32_t> results;
         for (auto &[uuid, status] : dbResults) {
             results.insert_or_assign(uuid, static_cast<int32_t>(status));
@@ -276,10 +275,9 @@ bool MetaDataManager::Subscribe(std::shared_ptr<Filter> filter, Observer observe
         return false;
     }
 
-    return metaObservers_.ComputeIfAbsent(
-        "", [ this, &observer, &filter ](const std::string &key) -> auto {
-            return std::make_shared<MetaObserver>(metaStore_, filter, observer);
-        });
+    return metaObservers_.ComputeIfAbsent("", [this, &observer, &filter](const std::string &key) -> auto {
+        return std::make_shared<MetaObserver>(metaStore_, filter, observer);
+    });
 }
 
 bool MetaDataManager::Subscribe(std::string prefix, Observer observer, bool isLocal)
@@ -288,10 +286,9 @@ bool MetaDataManager::Subscribe(std::string prefix, Observer observer, bool isLo
         return false;
     }
 
-    return metaObservers_.ComputeIfAbsent(
-        prefix, [ this,  isLocal, &observer, &prefix ](const std::string &key) -> auto {
-            return std::make_shared<MetaObserver>(metaStore_, std::make_shared<Filter>(prefix), observer, isLocal);
-        });
+    return metaObservers_.ComputeIfAbsent(prefix, [this, isLocal, &observer, &prefix](const std::string &key) -> auto {
+        return std::make_shared<MetaObserver>(metaStore_, std::make_shared<Filter>(prefix), observer, isLocal);
+    });
 }
 
 bool MetaDataManager::Unsubscribe(std::string filter)
diff --git a/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp b/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp
index 219780e540921a7eda0179fb97100e71b8aa31cb..2a31c3805663a804983201ab3fd58b3ab95279eb 100644
--- a/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/metadata/store_meta_data.cpp
@@ -55,14 +55,14 @@ bool StoreMetaData::Marshal(json &node) const
     SetValue(node[GET_NAME(dataType)], dataType);
     SetValue(node[GET_NAME(enableCloud)], enableCloud);
     SetValue(node[GET_NAME(cloudAutoSync)], cloudAutoSync);
-
     // compatible with the versions which lower than VERSION_TAG_0000
     SetValue(node[GET_NAME(kvStoreType)], storeType);
     SetValue(node[GET_NAME(deviceAccountID)], user);
     SetValue(node[GET_NAME(userId)], account);
     SetValue(node[GET_NAME(UID)], uid);
     SetValue(node[GET_NAME(customDir)], customDir);
-
+    SetValue(node[GET_NAME(authType)], authType);
+    SetValue(node[GET_NAME(haMode)], haMode);
     return true;
 }
 
@@ -95,7 +95,6 @@ bool StoreMetaData::Unmarshal(const json &node)
     GetValue(node, GET_NAME(dataType), dataType);
     GetValue(node, GET_NAME(enableCloud), enableCloud);
     GetValue(node, GET_NAME(cloudAutoSync), cloudAutoSync);
-
     // compatible with the older versions
     if (version < FIELD_CHANGED_TAG) {
         GetValue(node, GET_NAME(kvStoreType), storeType);
@@ -104,6 +103,8 @@ bool StoreMetaData::Unmarshal(const json &node)
         GetValue(node, GET_NAME(userId), account);
     }
     GetValue(node, GET_NAME(customDir), customDir);
+    GetValue(node, GET_NAME(authType), authType);
+    GetValue(node, GET_NAME(haMode), haMode);
     return true;
 }
 
@@ -120,7 +121,7 @@ StoreMetaData::StoreMetaData(const std::string &userId, const std::string &appId
 {
 }
 
-StoreMetaData::StoreMetaData(const StoreInfo& storeInfo)
+StoreMetaData::StoreMetaData(const StoreInfo &storeInfo)
     : instanceId(storeInfo.instanceId), bundleName(storeInfo.bundleName), storeId(storeInfo.storeName),
       user(std::to_string(storeInfo.user))
 {
@@ -141,7 +142,7 @@ bool StoreMetaData::operator==(const StoreMetaData &metaData) const
             tokenId == metaData.tokenId && instanceId == metaData.instanceId && appId == metaData.appId &&
             appType == metaData.appType && bundleName == metaData.bundleName && dataDir == metaData.dataDir &&
             storeId == metaData.storeId && user == metaData.user && deviceId == metaData.deviceId &&
-            account == metaData.account);
+            account == metaData.account && authType == metaData.authType && haMode == metaData.haMode);
 }
 
 bool StoreMetaData::operator!=(const StoreMetaData &metaData) const
diff --git a/datamgr_service/services/distributeddataservice/framework/screen/screen_manager.cpp b/datamgr_service/services/distributeddataservice/framework/screen/screen_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f7698f5bb28cfd602cd7a453a58d1c907fc2c19
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/framework/screen/screen_manager.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "ScreenManager"
+#include "screen/screen_manager.h"
+#include "log_print.h"
+
+namespace OHOS::DistributedData {
+std::mutex ScreenManager::mutex_;
+std::shared_ptr<ScreenManager> ScreenManager::instance_ = nullptr;
+std::shared_ptr<ScreenManager> ScreenManager::GetInstance()
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    if (instance_ != nullptr) {
+        return instance_;
+    }
+    instance_ = std::make_shared<ScreenManager>();
+    ZLOGW("no register, new instance!");
+    return instance_;
+}
+
+bool ScreenManager::RegisterInstance(std::shared_ptr<ScreenManager> instance)
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    instance_ = std::move(instance);
+    return true;
+}
+
+bool ScreenManager::IsLocked()
+{
+    return false;
+}
+
+} // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/store/auto_cache.cpp b/datamgr_service/services/distributeddataservice/framework/store/auto_cache.cpp
index 0e5420b21bebe5fc50d716843d9d0d3573f24068..fa94983b91ccbb99362ae1f4c6ef2ed72ddb87aa 100644
--- a/datamgr_service/services/distributeddataservice/framework/store/auto_cache.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/store/auto_cache.cpp
@@ -13,13 +13,15 @@
  * limitations under the License.
  */
 #define LOG_TAG "AutoCache"
+#include "store/auto_cache.h"
+
 #include <cinttypes>
+
 #include "changeevent/remote_change_event.h"
 #include "eventcenter/event_center.h"
-#include "utils/anonymous.h"
-#include "store/auto_cache.h"
-
 #include "log_print.h"
+#include "screenlock/screen_lock.h"
+#include "utils/anonymous.h"
 namespace OHOS::DistributedData {
 AutoCache &AutoCache::GetInstance()
 {
@@ -41,10 +43,12 @@ void AutoCache::Bind(std::shared_ptr<Executor> executor)
     if (executor == nullptr || taskId_ != Executor::INVALID_TASK_ID) {
         return;
     }
-    executor_ = executor;
+    executor_ = std::move(executor);
 }
 
-AutoCache::AutoCache() {}
+AutoCache::AutoCache()
+{
+}
 
 AutoCache::~AutoCache()
 {
@@ -57,15 +61,22 @@ AutoCache::~AutoCache()
 AutoCache::Store AutoCache::GetStore(const StoreMetaData &meta, const Watchers &watchers)
 {
     Store store;
-    if (meta.storeType >= MAX_CREATOR_NUM || meta.storeType < 0 || !creators_[meta.storeType] ||
-        disables_.ContainIf(meta.tokenId, [&meta](const std::set<std::string>& stores) -> bool {
+    if ((meta.area >= GeneralStore::EL4 && ScreenManager::GetInstance()->IsLocked()) ||
+        meta.storeType >= MAX_CREATOR_NUM || meta.storeType < 0 || !creators_[meta.storeType] ||
+        disables_.ContainIf(meta.tokenId, [&meta](const std::set<std::string> &stores) -> bool {
             return stores.count(meta.storeId) != 0;
         })) {
         return store;
     }
 
-    stores_.Compute(meta.tokenId,
-        [this, &meta, &watchers, &store](auto &, std::map<std::string, Delegate> &stores) -> bool {
+    stores_.Compute(
+        meta.tokenId, [this, &meta, &watchers, &store](auto &, std::map<std::string, Delegate> &stores) -> bool {
+            if (disableStores_.count(meta.dataDir) != 0) {
+                ZLOGW("store is closing, tokenId:0x%{public}x user:%{public}s"
+                    "bundleName:%{public}s storeName:%{public}s",
+                    meta.tokenId, meta.user.c_str(), meta.bundleName.c_str(), meta.GetStoreAlias().c_str());
+                return !stores.empty();
+            }
             auto it = stores.find(meta.storeId);
             if (it != stores.end()) {
                 if (!watchers.empty()) {
@@ -79,6 +90,7 @@ AutoCache::Store AutoCache::GetStore(const StoreMetaData &meta, const Watchers &
                 ZLOGE("creator failed. storeName:%{public}s", meta.GetStoreAlias().c_str());
                 return !stores.empty();
             }
+            dbStore->SetExecutor(executor_);
             auto result = stores.emplace(std::piecewise_construct, std::forward_as_tuple(meta.storeId),
                 std::forward_as_tuple(dbStore, watchers, atoi(meta.user.c_str()), meta));
             store = result.first->second;
@@ -88,22 +100,23 @@ AutoCache::Store AutoCache::GetStore(const StoreMetaData &meta, const Watchers &
     return store;
 }
 
-AutoCache::Stores AutoCache::GetStoresIfPresent(uint32_t tokenId, const std::string& storeName)
+AutoCache::Stores AutoCache::GetStoresIfPresent(uint32_t tokenId, const std::string &storeName)
 {
     Stores stores;
-    stores_.ComputeIfPresent(tokenId, [&stores, &storeName](auto&, std::map<std::string, Delegate>& delegates) -> bool {
-        if (storeName.empty()) {
-            for (auto& [_, delegate] : delegates) {
-                stores.push_back(delegate);
-            }
-        } else {
-            auto it = delegates.find(storeName);
-            if (it != delegates.end()) {
-                stores.push_back(it->second);
+    stores_.ComputeIfPresent(
+        tokenId, [&stores, &storeName](auto &, std::map<std::string, Delegate> &delegates) -> bool {
+            if (storeName.empty()) {
+                for (auto &[_, delegate] : delegates) {
+                    stores.push_back(delegate);
+                }
+            } else {
+                auto it = delegates.find(storeName);
+                if (it != delegates.end()) {
+                    stores.push_back(it->second);
+                }
             }
-        }
-        return !stores.empty();
-    });
+            return !stores.empty();
+        });
     return stores;
 }
 
@@ -131,31 +144,51 @@ void AutoCache::StartTimer()
 
 void AutoCache::CloseStore(uint32_t tokenId, const std::string &storeId)
 {
-    stores_.ComputeIfPresent(tokenId, [&storeId](auto &key, std::map<std::string, Delegate> &delegates) {
-        auto it = delegates.find(storeId);
-        if (it != delegates.end()) {
-            it->second.Close();
-            delegates.erase(it);
+    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();
+    stores_.ComputeIfPresent(tokenId,
+        [this, &storeId, isScreenLocked, &storeIds, &closeStores](auto &key, auto &delegates) {
+            auto it = delegates.begin();
+            while (it != delegates.end()) {
+                if ((storeId == it->first || storeId.empty()) &&
+                    (!isScreenLocked || it->second.GetArea() < GeneralStore::EL4) &&
+                    disableStores_.count(it->second.GetDataDir()) == 0) {
+                    disableStores_.insert(it->second.GetDataDir());
+                    storeIds.insert(it->first);
+                    closeStores.emplace(closeStores.end(), it->second);
+                } else {
+                    ++it;
+                }
+            }
+            return !delegates.empty();
+        });
+    closeStores.clear();
+    stores_.ComputeIfPresent(tokenId, [this, &storeIds](auto &key, auto &delegates) {
+        for (auto it = delegates.begin(); it != delegates.end();) {
+            if (storeIds.count(it->first) != 0) {
+                disableStores_.erase(it->second.GetDataDir());
+                it = delegates.erase(it);
+            } else {
+                ++it;
+            }
         }
         return !delegates.empty();
     });
 }
 
-void AutoCache::CloseStore(uint32_t tokenId)
-{
-    stores_.Erase(tokenId);
-}
-
 void AutoCache::CloseExcept(const std::set<int32_t> &users)
 {
-    stores_.EraseIf([&users](const auto &tokenId, std::map<std::string, Delegate> &delegates) {
+    bool isScreenLocked = ScreenManager::GetInstance()->IsLocked();
+    stores_.EraseIf([&users, isScreenLocked](const auto &tokenId, std::map<std::string, Delegate> &delegates) {
         if (delegates.empty() || users.count(delegates.begin()->second.GetUser()) != 0) {
             return delegates.empty();
         }
 
         for (auto it = delegates.begin(); it != delegates.end();) {
             // if the kv store is BUSY we wait more INTERVAL minutes again
-            if (!it->second.Close()) {
+            if ((isScreenLocked && it->second.GetArea() >= GeneralStore::EL4) || !it->second.Close()) {
                 ++it;
             } else {
                 it = delegates.erase(it);
@@ -168,8 +201,8 @@ void AutoCache::CloseExcept(const std::set<int32_t> &users)
 void AutoCache::SetObserver(uint32_t tokenId, const std::string &storeId, const AutoCache::Watchers &watchers)
 {
     stores_.ComputeIfPresent(tokenId, [&storeId, &watchers](auto &key, auto &stores) {
-        ZLOGD("tokenId:0x%{public}x storeId:%{public}s observers:%{public}zu", key, Anonymous::Change(storeId).c_str(),
-            watchers.size());
+        ZLOGD("tokenId:0x%{public}x storeId:%{public}s observers:%{public}zu", key,
+            Anonymous::Change(storeId).c_str(), watchers.size());
         auto it = stores.find(storeId);
         if (it != stores.end()) {
             it->second.SetObservers(watchers);
@@ -181,10 +214,12 @@ void AutoCache::SetObserver(uint32_t tokenId, const std::string &storeId, const
 void AutoCache::GarbageCollect(bool isForce)
 {
     auto current = std::chrono::steady_clock::now();
-    stores_.EraseIf([&current, isForce](auto &key, std::map<std::string, Delegate> &delegates) {
+    bool isScreenLocked = ScreenManager::GetInstance()->IsLocked();
+    stores_.EraseIf([&current, isForce, isScreenLocked](auto &key, std::map<std::string, Delegate> &delegates) {
         for (auto it = delegates.begin(); it != delegates.end();) {
             // if the store is BUSY we wait more INTERVAL minutes again
-            if ((isForce || it->second < current) && it->second.Close()) {
+            if ((!isScreenLocked || it->second.GetArea() < GeneralStore::EL4) && (isForce || it->second < current) &&
+                it->second.Close()) {
                 it = delegates.erase(it);
             } else {
                 ++it;
@@ -194,25 +229,24 @@ void AutoCache::GarbageCollect(bool isForce)
     });
 }
 
-void AutoCache::Enable(uint32_t tokenId, const std::string& storeId)
+void AutoCache::Enable(uint32_t tokenId, const std::string &storeId)
 {
-    disables_.ComputeIfPresent(tokenId, [&storeId](auto key, std::set<std::string>& stores) {
+    disables_.ComputeIfPresent(tokenId, [&storeId](auto key, std::set<std::string> &stores) {
         stores.erase(storeId);
         return !(stores.empty() || storeId.empty());
     });
 }
 
-void AutoCache::Disable(uint32_t tokenId, const std::string& storeId)
+void AutoCache::Disable(uint32_t tokenId, const std::string &storeId)
 {
-    disables_.Compute(tokenId, [&storeId](auto key, std::set<std::string>& stores) {
+    disables_.Compute(tokenId, [&storeId](auto key, std::set<std::string> &stores) {
         stores.insert(storeId);
         return !stores.empty();
     });
     CloseStore(tokenId, storeId);
 }
 
-AutoCache::Delegate::Delegate(GeneralStore *delegate, const Watchers &watchers, int32_t user,
-    const StoreMetaData &meta)
+AutoCache::Delegate::Delegate(GeneralStore *delegate, const Watchers &watchers, int32_t user, const StoreMetaData &meta)
     : store_(delegate), watchers_(watchers), user_(user), meta_(meta)
 {
     time_ = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL);
@@ -221,11 +255,19 @@ AutoCache::Delegate::Delegate(GeneralStore *delegate, const Watchers &watchers,
     }
 }
 
+AutoCache::Delegate::Delegate(const Delegate& delegate)
+{
+    store_ = delegate.store_;
+    if (store_ != nullptr) {
+        store_->AddRef();
+    }
+}
+
 AutoCache::Delegate::~Delegate()
 {
     if (store_ != nullptr) {
+        store_->Close(true);
         store_->Unwatch(Origin::ORIGIN_ALL, *this);
-        store_->Close();
         store_->Release();
         store_ = nullptr;
     }
@@ -248,7 +290,6 @@ bool AutoCache::Delegate::operator<(const AutoCache::Time &time) const
 
 bool AutoCache::Delegate::Close()
 {
-    std::unique_lock<decltype(mutex_)> lock(mutex_);
     if (store_ != nullptr) {
         auto status = store_->Close();
         if (status == Error::E_BUSY) {
@@ -270,6 +311,16 @@ int32_t AutoCache::Delegate::GetUser() const
     return user_;
 }
 
+int32_t AutoCache::Delegate::GetArea() const
+{
+    return meta_.area;
+}
+
+const std::string& AutoCache::Delegate::GetDataDir() const
+{
+    return meta_.dataDir;
+}
+
 int32_t AutoCache::Delegate::OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values)
 {
     std::vector<std::string> tables;
@@ -327,4 +378,4 @@ void AutoCache::Delegate::PostDataChange(const StoreMetaData &meta, const std::v
     auto evt = std::make_unique<RemoteChangeEvent>(RemoteChangeEvent::DATA_CHANGE, std::move(info));
     EventCenter::GetInstance().PostEvent(std::move(evt));
 }
-} // namespace OHOS::DistributedData
+} // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/test/BUILD.gn b/datamgr_service/services/distributeddataservice/framework/test/BUILD.gn
index 026e7a9009caa13a2f081273c579e2f63ed23e19..2476ad7d067766da1f672cdc2d011bdc445f867f 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/framework/test/BUILD.gn
@@ -127,6 +127,11 @@ ohos_unittest("ServiceUtilsTest") {
 
   configs = [ ":module_private_config" ]
 
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
   external_deps = [
     "access_token:libaccesstoken_sdk",
     "access_token:libnativetoken",
diff --git a/datamgr_service/services/distributeddataservice/framework/test/checker_manager_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/checker_manager_test.cpp
index 8dfc80b407d1cd53e3bdfcb16d808e382b864e5b..d95a7df7dd7ea8fd5c7df2730508f36e2aedf80e 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/checker_manager_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/checker_manager_test.cpp
@@ -170,4 +170,36 @@ HWTEST_F(CheckerManagerTest, BundleChecker, TestSize.Level0)
     AccessTokenKit::GetHapTokenInfo(storeInfo.tokenId, tokenInfo);
     ASSERT_EQ(Crypto::Sha256(tokenInfo.appID), CheckerManager::GetInstance().GetAppId(storeInfo));
     ASSERT_TRUE(CheckerManager::GetInstance().IsValid(storeInfo));
+}
+
+/**
+* @tc.name: IsDynamic
+* @tc.desc: checker data type.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author:
+*/
+HWTEST_F(CheckerManagerTest, IsDynamic, TestSize.Level0)
+{
+    CheckerManager::StoreInfo storeInfo;
+    storeInfo.uid = 2000000;
+    storeInfo.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
+    storeInfo.bundleName = "ohos.test.demo";
+    ASSERT_FALSE(CheckerManager::GetInstance().IsDynamic(storeInfo));
+}
+
+/**
+* @tc.name: IsStatic
+* @tc.desc: checker data type.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author:
+*/
+HWTEST_F(CheckerManagerTest, IsStatic, TestSize.Level0)
+{
+    CheckerManager::StoreInfo storeInfo;
+    storeInfo.uid = 2000000;
+    storeInfo.tokenId = AccessTokenKit::GetHapTokenID(100, "ohos.test.demo", 0);
+    storeInfo.bundleName = "ohos.test.demo";
+    ASSERT_FALSE(CheckerManager::GetInstance().IsStatic(storeInfo));
 }
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/test/cloud_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/cloud_test.cpp
index 15a83e104235b731a0521583754b6bfa4c21f29e..90232b1848192abf5a4b3256489172c0a59a247b 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/cloud_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/cloud_test.cpp
@@ -18,11 +18,13 @@
 
 #include "serializable/serializable.h"
 #include "cloud/cloud_db.h"
+#include "cloud/cloud_event.h"
 #include "cloud/cloud_info.h"
 #include "cloud/cloud_server.h"
 #include "cloud/schema_meta.h"
 #include "nlohmann/json.hpp"
 #include "utils/crypto.h"
+#include "screen/screen_manager.h"
 #include "store/general_store.h"
 #include "store/general_value.h"
 #include "store/general_watcher.h"
@@ -54,6 +56,22 @@ public:
     void TearDown(){};
 };
 
+class CloudEventTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+};
+
+class ScreenManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+};
+
 class MockGeneralWatcher : public DistributedData::GeneralWatcher {
 public:
     int32_t OnChange(const Origin &origin, const PRIFields &primaryFields,
@@ -207,13 +225,13 @@ HWTEST_F(CloudInfoTest, GetPrefix, TestSize.Level0)
 }
 
 /**
-* @tc.name: CloudInfoTest
+* @tc.name: CloudInfoTest001
 * @tc.desc: Marshal and Unmarshal of CloudInfo.
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: Anvette
 */
-HWTEST_F(CloudInfoTest, CloudInfoTest, TestSize.Level0)
+HWTEST_F(CloudInfoTest, CloudInfoTest001, TestSize.Level0)
 {
     CloudInfo cloudInfo1;
     cloudInfo1.user = 111;
@@ -231,6 +249,33 @@ HWTEST_F(CloudInfoTest, CloudInfoTest, TestSize.Level0)
     EXPECT_EQ(Serializable::Marshall(cloudInfo1), Serializable::Marshall(cloudInfo1));
 }
 
+/**
+* @tc.name: CloudInfoTest002
+* @tc.desc: Marshal and Unmarshal of CloudInfo.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(CloudInfoTest, CloudInfoTest002, TestSize.Level0)
+{
+    CloudInfo cloudInfo1;
+    cloudInfo1.user = 111;
+    cloudInfo1.id = "test1_id";
+    cloudInfo1.totalSpace = 0;
+    cloudInfo1.remainSpace = 0;
+    cloudInfo1.enableCloud = false;
+    cloudInfo1.maxNumber = CloudInfo::DEFAULT_BATCH_NUMBER;
+    cloudInfo1.maxSize = CloudInfo::DEFAULT_BATCH_SIZE;
+
+    Serializable::json node1;
+    cloudInfo1.Marshal(node1);
+    EXPECT_EQ(Serializable::Marshall(cloudInfo1), to_string(node1));
+
+    CloudInfo cloudInfo2;
+    cloudInfo2.Unmarshal(node1);
+    EXPECT_EQ(Serializable::Marshall(cloudInfo1), Serializable::Marshall(cloudInfo1));
+}
+
 /**
 * @tc.name: AppInfoTest
 * @tc.desc: Marshal and Unmarshal of AppInfo.
@@ -506,4 +551,32 @@ HWTEST_F(CloudInfoTest, SchemaMeta, TestSize.Level0)
     auto result2 = schemaMeta.GetHighVersion();
     EXPECT_EQ(result2, metaVersion);
 }
+
+/**
+* @tc.name: GetEventId
+* @tc.desc: test GetEventId function
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author:
+*/
+HWTEST_F(CloudEventTest, GetEventId, TestSize.Level0)
+{
+    int32_t evtId = 1;
+    StoreInfo info;
+    CloudEvent event(evtId, info);
+    auto ret = event.GetEventId();
+    EXPECT_EQ(ret, evtId);
+}
+
+/**
+* @tc.name: IsLocked
+* @tc.desc: test IsLocked function
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author:
+*/
+HWTEST_F(ScreenManagerTest, IsLocked, TestSize.Level0)
+{
+    ASSERT_FALSE(ScreenManager::GetInstance()->IsLocked());
+}
 } // namespace OHOS::Test
diff --git a/datamgr_service/services/distributeddataservice/framework/test/constant_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/constant_test.cpp
index a5147d3578d261d51426946ee8075eb51c6502ab..79e748d81f66fa64483ae72a1b63e41a5db7cda1 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/constant_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/constant_test.cpp
@@ -31,14 +31,10 @@ class ConstantTest : public testing::Test {
 */
 HWTEST_F(ConstantTest, EqualTest, TestSize.Level1)
 {
-    bool result = Constant::Equal(true, true);
-    ASSERT_TRUE(result);
-
-    result = Constant::Equal(true, false);
-    ASSERT_FALSE(result);
-
-    result = OHOS::DistributedData::Constant::Equal(false, false);
-    ASSERT_TRUE(result);
+    ASSERT_TRUE(Constant::Equal(true, true));
+    ASSERT_TRUE(Constant::Equal(false, false));
+    ASSERT_FALSE(Constant::Equal(true, false));
+    ASSERT_FALSE(Constant::Equal(false, true));
 }
 
 /**
@@ -50,12 +46,127 @@ HWTEST_F(ConstantTest, EqualTest, TestSize.Level1)
 */
 HWTEST_F(ConstantTest, NotEqualTest, TestSize.Level1)
 {
-    bool result = Constant::NotEqual(true, true);
-    ASSERT_FALSE(result);
+    ASSERT_TRUE(Constant::NotEqual(true, false));
+    ASSERT_TRUE(Constant::NotEqual(false, true));
+    ASSERT_FALSE(Constant::NotEqual(true, true));
+    ASSERT_FALSE(Constant::NotEqual(false, false));
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitEmptyStringTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitEmptyStringTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("", ",");
+    ASSERT_EQ(tokens.size(), 1);
+    EXPECT_EQ(tokens[0], "");
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringOneDelimTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringOneDelimTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc_123", "_");
+    ASSERT_EQ(tokens.size(), 2);
+    EXPECT_EQ(tokens[0], "abc");
+    EXPECT_EQ(tokens[1], "123");
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringOneDelimAtBeginTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringOneDelimAtBeginTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("#abc123", "#");
+    ASSERT_EQ(tokens.size(), 2);
+    EXPECT_EQ(tokens[0], "");
+    EXPECT_EQ(tokens[1], "abc123");
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringOneDelimAtEndTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringOneDelimAtEndTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc123!", "!");
+    ASSERT_EQ(tokens.size(), 1);
+    EXPECT_EQ(tokens[0], "abc123");
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringMutipleDelimTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringMutipleDelimTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc!123!", "!");
+    ASSERT_EQ(tokens.size(), 2);
+    EXPECT_EQ(tokens[0], "abc");
+    EXPECT_EQ(tokens[1], "123");
+}
+
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringNoDelimTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringNoDelimTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc123", "^");
+    ASSERT_EQ(tokens.size(), 1);
+    EXPECT_EQ(tokens[0], "abc123");
+}
 
-    result = Constant::NotEqual(true, false);
-    ASSERT_TRUE(result);
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringContinuousDelimTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringContinuousDelimTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc$$$123", "$");
+    ASSERT_EQ(tokens.size(), 4);
+    EXPECT_EQ(tokens[0], "abc");
+    EXPECT_EQ(tokens[1], "");
+    EXPECT_EQ(tokens[2], "");
+    EXPECT_EQ(tokens[3], "123");
+}
 
-    result = Constant::NotEqual(false, false);
-    ASSERT_FALSE(result);
+/**
+* @tc.name: SplitTest
+* @tc.desc: SplitStringLongDelimTest.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: ht
+*/
+HWTEST_F(ConstantTest, SplitStringLongDelimTest, TestSize.Level1)
+{
+    auto tokens = Constant::Split("abc&&&123", "&&");
+    ASSERT_EQ(tokens.size(), 2);
+    EXPECT_EQ(tokens[0], "abc");
+    EXPECT_EQ(tokens[1], "&123");
 }
diff --git a/datamgr_service/services/distributeddataservice/framework/test/feature_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/feature_test.cpp
index 5490d0436f868921619b51a521769dab7ff7049b..befe45f828df7836d86bf798225986e104802132 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/feature_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/feature_test.cpp
@@ -257,4 +257,19 @@ HWTEST_F(FeatureSystemTest, FeatureTest002, TestSize.Level1)
     ret = mockFeature.OnSessionReady(device);
     EXPECT_EQ(ret, E_OK);
 }
+
+/**
+* @tc.name: OnScreenUnlockedTest
+* @tc.desc: test OnScreenUnlocked
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author:
+*/
+HWTEST_F(FeatureSystemTest, OnScreenUnlockedTest, TestSize.Level1)
+{
+    MockFeature mockFeature;
+    int32_t user = 0;
+    int32_t ret = mockFeature.OnScreenUnlocked(user);
+    EXPECT_EQ(ret, E_OK);
+}
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/test/meta_data_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/meta_data_test.cpp
index 992b78a6100e93ca6abc7e89f308d8e2e4114380..1e99a72101f0c175eb990d9c3c23950a581952f4 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/meta_data_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/meta_data_test.cpp
@@ -45,7 +45,6 @@ public:
     static void SetUpTestCase()
     {
         std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
-        Bootstrap::GetInstance().LoadComponents();
         Bootstrap::GetInstance().LoadDirectory();
         Bootstrap::GetInstance().LoadCheckers();
         KvStoreMetaManager::GetInstance().BindExecutor(executors);
@@ -462,6 +461,16 @@ HWTEST_F(ServiceMetaDataTest, StoreMetaData006, TestSize.Level1)
     EXPECT_FALSE(storemetaData1 == storemetaData2);
     storemetaData2.isNeedCompress = true;
     EXPECT_TRUE(storemetaData1 == storemetaData2);
+
+    storemetaData1.enableCloud = true;
+    EXPECT_FALSE(storemetaData1 == storemetaData2);
+    storemetaData2.enableCloud = true;
+    EXPECT_TRUE(storemetaData1 == storemetaData2);
+
+    storemetaData1.cloudAutoSync = true;
+    EXPECT_FALSE(storemetaData1 == storemetaData2);
+    storemetaData2.cloudAutoSync = true;
+    EXPECT_TRUE(storemetaData1 == storemetaData2);
 }
 
 /**
@@ -508,6 +517,16 @@ HWTEST_F(ServiceMetaDataTest, StoreMetaData007, TestSize.Level1)
     EXPECT_TRUE(storemetaData1 != storemetaData2);
     storemetaData2.isNeedCompress = true;
     EXPECT_FALSE(storemetaData1 != storemetaData2);
+
+    storemetaData1.enableCloud = true;
+    EXPECT_TRUE(storemetaData1 != storemetaData2);
+    storemetaData2.enableCloud = true;
+    EXPECT_FALSE(storemetaData1 != storemetaData2);
+
+    storemetaData1.cloudAutoSync = true;
+    EXPECT_TRUE(storemetaData1 != storemetaData2);
+    storemetaData2.cloudAutoSync = true;
+    EXPECT_FALSE(storemetaData1 != storemetaData2);
 }
 
 /**
@@ -771,5 +790,8 @@ HWTEST_F(ServiceMetaDataTest, MatrixMetaData, TestSize.Level1)
     matrixMetaData3.deviceId = "DEVICE_ID";
     EXPECT_TRUE(matrixMetaData1 != matrixMetaData3);
     EXPECT_FALSE(matrixMetaData1 != matrixMetaData2);
+
+    std::string key = matrixMetaData3.GetConsistentKey();
+    EXPECT_EQ(key, "MatrixMeta###DEVICE_ID###Consistent");
 }
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/test/store_meta_data_local_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/store_meta_data_local_test.cpp
index fa78ec5d180c78149209518b3a6888d0d26200fb..5527998edb49df72293b3a66f449c18b04b80b4f 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/store_meta_data_local_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/store_meta_data_local_test.cpp
@@ -37,22 +37,45 @@ public:
 HWTEST_F(StoreMetaDataLocalTest, EqualityOperatorTest, TestSize.Level1)
 {
     StoreMetaDataLocal metaData1;
-    metaData1.isAutoSync = true;
-    metaData1.isBackup = true;
     StoreMetaDataLocal metaData2;
-    metaData2.isAutoSync = true;
-    metaData2.isBackup = false;
     StoreMetaDataLocal metaData3;
+
+    ASSERT_TRUE(metaData1 == metaData2);
     metaData3.isAutoSync = true;
+    ASSERT_FALSE(metaData1 == metaData3);
     metaData3.isBackup = true;
+    ASSERT_FALSE(metaData1 == metaData3);
+    ASSERT_TRUE(metaData1 != metaData3);
+    ASSERT_FALSE(metaData1 != metaData2);
+    metaData3.isDirty = true;
+    ASSERT_FALSE(metaData1 == metaData3);
+    metaData3.isEncrypt = true;
+    ASSERT_FALSE(metaData1 == metaData3);
+    metaData3.isPublic = true;
+    ASSERT_FALSE(metaData1 == metaData3);
 
-    ASSERT_FALSE(metaData1 == metaData2);
-    ASSERT_TRUE(metaData1 == metaData3);
+    metaData2.isAutoSync = true;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isBackup = true;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isDirty = true;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isEncrypt = true;
     ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isPublic = true;
+    ASSERT_TRUE(metaData2 == metaData3);
 
-    ASSERT_TRUE(metaData1 != metaData2);
-    ASSERT_FALSE(metaData1 != metaData3);
-    ASSERT_TRUE(metaData2 != metaData3);
+    metaData2.isBackup = false;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isBackup = true;
+    metaData2.isDirty = false;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isBackup = true;
+    metaData2.isEncrypt = false;
+    ASSERT_FALSE(metaData2 == metaData3);
+    metaData2.isBackup = true;
+    metaData2.isPublic = false;
+    ASSERT_FALSE(metaData2 == metaData3);
 }
 
 /**
@@ -95,5 +118,8 @@ HWTEST_F(StoreMetaDataLocalTest, GetPolicy, TestSize.Level1)
     policy.index = 1;
     EXPECT_FALSE(metaData.HasPolicy(type));
     EXPECT_TRUE(policy.IsValueEffect());
+    type = UINT32_MAX;
+    policy = metaData.GetPolicy(type);
+    EXPECT_EQ(policy.type, type);
 }
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/test/store_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/store_test.cpp
index 322b494a16783e5cd9b9cebe50b2af37f8e24e07..18db822c9d25d685d6ba43b3e7eda0c54cadb682 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/store_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/store_test.cpp
@@ -21,7 +21,6 @@
 #include "metadata/store_meta_data.h"
 #include "rdb_query.h"
 #include "rdb_types.h"
-#define private public
 #include "store/auto_cache.h"
 #include "store/general_store.h"
 #include "store/general_value.h"
diff --git a/datamgr_service/services/distributeddataservice/framework/test/utils_test.cpp b/datamgr_service/services/distributeddataservice/framework/test/utils_test.cpp
index e81c8602929c6005e33f62cc0f5c22d4bfff834c..7f5da600c25cbc89b3ea3b8fe54dd45b94acc4ed 100644
--- a/datamgr_service/services/distributeddataservice/framework/test/utils_test.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/test/utils_test.cpp
@@ -21,6 +21,7 @@
 #include "ipc_skeleton.h"
 #include "log_print.h"
 #include "utils/block_integer.h"
+#include "utils/constant.h"
 #include "utils/converter.h"
 #include "utils/ref_count.h"
 #include "utils/endian_converter.h"
@@ -130,6 +131,10 @@ HWTEST_F(RefCountTest, Constructortest, TestSize.Level2)
     std::function<void()> action = []() { };
     RefCount refCountWithAction(action);
     EXPECT_TRUE(refCountWithAction);
+
+    std::function<void()> actions;
+    RefCount refCountWithActions(actions);
+    EXPECT_TRUE(refCountWithActions);
     int num = 0;
     {
         RefCount refCount([&num]() {
@@ -158,6 +163,8 @@ HWTEST_F(RefCountTest, Constructortest, TestSize.Level2)
         RefCount refCount6 = std::move(refCount2);
         refCount6 = std::move(refCount4);
         ASSERT_TRUE(refCount6);
+
+        EXPECT_TRUE(refCount5 = refCount5);
     }
     ASSERT_EQ(num, 10);
 }
@@ -189,4 +196,34 @@ HWTEST_F(ServiceUtilsTest, HostToNet, TestSize.Level1)
     uint64_t hostValue64 = NetToHost(NET_VALUE64);
     EXPECT_EQ(hostValue64, le64toh(NET_VALUE64));
 }
+
+/**
+* @tc.name: DCopy
+* @tc.desc: test Constant::DCopy function.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(ServiceUtilsTest, DCopy, TestSize.Level1)
+{
+    Constant constant;
+    uint8_t *tag = nullptr;
+    size_t tagLen = 1;
+    uint8_t *src = nullptr;
+    size_t srcLen = 0;
+
+    uint8_t tags[10];
+    size_t tagsLen = 10;
+    uint8_t srcs[10];
+    size_t srcsLen = 10;
+
+    EXPECT_FALSE(constant.DCopy(tag, tagLen, src, srcLen));
+    EXPECT_FALSE(constant.DCopy(tag, tagsLen, src, srcsLen));
+    EXPECT_FALSE(constant.DCopy(tags, tagLen, src, srcLen));
+    EXPECT_FALSE(constant.DCopy(tag, tagLen, srcs, srcLen));
+    EXPECT_FALSE(constant.DCopy(tags, tagsLen, src, srcsLen));
+    EXPECT_FALSE(constant.DCopy(tag, tagsLen, srcs, srcsLen));
+    EXPECT_FALSE(constant.DCopy(tags, tagLen, srcs, srcLen));
+    EXPECT_TRUE(constant.DCopy(tags, tagsLen, srcs, srcsLen));
+}
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/framework/utils/constant.cpp b/datamgr_service/services/distributeddataservice/framework/utils/constant.cpp
index 2b834643cbe59d5dd4f04c0682daa77aee662560..6fedf3f619ba5780cdf8efc664fd0909a11082a9 100644
--- a/datamgr_service/services/distributeddataservice/framework/utils/constant.cpp
+++ b/datamgr_service/services/distributeddataservice/framework/utils/constant.cpp
@@ -51,6 +51,25 @@ std::string Constant::Join(const std::string &prefix, const std::string &separat
     return result;
 }
 
+std::vector<std::string> Constant::Split(const std::string &str, const std::string &delim)
+{
+    if (str.empty()) {
+        return { str };
+    }
+    std::vector<std::string> res;
+    size_t pos = 0;
+    while (pos < str.size()) {
+        size_t found = str.find(delim, pos);
+        if (found == std::string::npos) {
+            res.push_back(str.substr(pos));
+            break;
+        }
+        res.push_back(str.substr(pos, found - pos));
+        pos = found + delim.size();
+    }
+    return res;
+}
+
 bool Constant::Equal(bool first, bool second)
 {
     return (first && second) || (!first && !second);
diff --git a/datamgr_service/services/distributeddataservice/rust/extension/BUILD.gn b/datamgr_service/services/distributeddataservice/rust/extension/BUILD.gn
index 302f89d6ae8a134e72da04fbb5b4b8f51cb83e98..cffbfca971c9d6f8ab4a3021e261c34cb8c9294b 100644
--- a/datamgr_service/services/distributeddataservice/rust/extension/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/rust/extension/BUILD.gn
@@ -56,6 +56,7 @@ ohos_shared_library("opencloudextension") {
   external_deps = [
     "access_token:libaccesstoken_sdk",
     "hilog:libhilog",
+    "json:nlohmann_json_static",
     "kv_store:distributeddata_inner",
   ]
   subsystem_name = "distributeddatamgr"
diff --git a/datamgr_service/services/distributeddataservice/rust/extension/cloud_cursor_impl.cpp b/datamgr_service/services/distributeddataservice/rust/extension/cloud_cursor_impl.cpp
index fc42049721363bd52ea456965e617dc3683deeef..9d62cc7e10d5df567ca411db806f432f6b00760d 100644
--- a/datamgr_service/services/distributeddataservice/rust/extension/cloud_cursor_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/rust/extension/cloud_cursor_impl.cpp
@@ -271,6 +271,7 @@ int32_t CloudCursorImpl::Get(const std::string &col, DBValue &value)
     auto it = std::find(names_.begin(), names_.end(), col);
     if (it == names_.end()) {
         value = GetExtend(vBucket, EXTEND_TO_KEYS[col]);
+        OhCloudExtValueBucketFree(vBucket);
         return DBErr::E_OK;
     }
     auto pair = GetData(vBucket);
diff --git a/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.cpp b/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.cpp
index 8cac03c467e183fbd785ff17dfb69b35b9cc7e56..da137619bfc423220f73d0095506c8fc6b57fc59 100644
--- a/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.cpp
@@ -57,6 +57,8 @@ int32_t CloudDbImpl::BatchInsert(const std::string &table, DBVBuckets &&values,
     auto valIn = ExtensionUtil::Convert(std::move(inValues));
     auto exdIn = ExtensionUtil::Convert(std::move(extends));
     if (valIn.first == nullptr || exdIn.first == nullptr) {
+        OhCloudExtVectorFree(valIn.first);
+        OhCloudExtVectorFree(exdIn.first);
         return DBErr::E_ERROR;
     }
     auto status = OhCloudExtCloudDbBatchInsert(database_, reinterpret_cast<const unsigned char *>(table.c_str()),
@@ -74,6 +76,8 @@ int32_t CloudDbImpl::BatchUpdate(const std::string &table, DBVBuckets &&values,
     auto exdIn = ExtensionUtil::Convert(std::move(extends));
     auto valIn = ExtensionUtil::Convert(std::move(values));
     if (valIn.first == nullptr || exdIn.first == nullptr) {
+        OhCloudExtVectorFree(valIn.first);
+        OhCloudExtVectorFree(exdIn.first);
         return DBErr::E_ERROR;
     }
     auto status = OhCloudExtCloudDbBatchUpdate(database_, reinterpret_cast<const unsigned char *>(table.c_str()),
@@ -91,6 +95,8 @@ int32_t CloudDbImpl::BatchUpdate(const std::string &table, DBVBuckets &&values,
     auto exdIn = ExtensionUtil::Convert(std::move(const_cast<DBVBuckets &>(extends)));
     auto valIn = ExtensionUtil::Convert(std::move(values));
     if (valIn.first == nullptr || exdIn.first == nullptr) {
+        OhCloudExtVectorFree(valIn.first);
+        OhCloudExtVectorFree(exdIn.first);
         return DBErr::E_ERROR;
     }
     auto status = OhCloudExtCloudDbBatchUpdate(database_, reinterpret_cast<const unsigned char *>(table.c_str()),
@@ -100,14 +106,15 @@ int32_t CloudDbImpl::BatchUpdate(const std::string &table, DBVBuckets &&values,
     return ExtensionUtil::ConvertStatus(status);
 }
 
-int32_t CloudDbImpl::BatchDelete(const std::string &table, const DBVBuckets &extends)
+int32_t CloudDbImpl::BatchDelete(const std::string &table, DBVBuckets &extends)
 {
-    auto data = ExtensionUtil::Convert(std::move(const_cast<DBVBuckets &>(extends)));
+    auto data = ExtensionUtil::Convert(std::move(extends));
     if (data.first == nullptr) {
         return DBErr::E_ERROR;
     }
     auto status = OhCloudExtCloudDbBatchDelete(database_, reinterpret_cast<const unsigned char *>(table.c_str()),
         table.size(), data.first);
+    extends = ExtensionUtil::ConvertBuckets(data.first);
     OhCloudExtVectorFree(data.first);
     return ExtensionUtil::ConvertStatus(status);
 }
diff --git a/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.h b/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.h
index dee05c431e2a4e8c4f9929373ec9c0f9f2a0b82e..099bfaad0ddf004cbdee4b887f02f6a62eaafb12 100644
--- a/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.h
+++ b/datamgr_service/services/distributeddataservice/rust/extension/cloud_db_impl.h
@@ -35,7 +35,7 @@ public:
     int32_t BatchInsert(const std::string &table, DBVBuckets &&values, DBVBuckets &extends) override;
     int32_t BatchUpdate(const std::string &table, DBVBuckets &&values, DBVBuckets &extends) override;
     int32_t BatchUpdate(const std::string &table, DBVBuckets &&values, const DBVBuckets &extends) override;
-    int32_t BatchDelete(const std::string &table, const DBVBuckets &extends) override;
+    int32_t BatchDelete(const std::string &table, DBVBuckets &extends) override;
     std::shared_ptr<DBCursor> Query(const std::string &table, const DBVBucket &extend) override;
     int32_t Lock() override;
     int32_t Heartbeat() override;
diff --git a/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/BUILD.gn b/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/BUILD.gn
index dd7526a6b1c81305cb9313cfa8861167032debe8..4ac4309e2d1eaddbf0913f5d67b31a297be5cb77 100644
--- a/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/BUILD.gn
@@ -22,7 +22,6 @@ ohos_rust_shared_ffi("ylong_cloud_extension") {
   subsystem_name = "distributeddatamgr"
   part_name = "datamgr_service"
 
-  branch_protector_ret = "pac_ret"
   sanitize = {
     cfi = true
     cfi_cross_dso = true
@@ -39,18 +38,23 @@ ohos_rust_shared_ffi("ylong_cloud_extension") {
   ]
 }
 
-ohos_rust_unittest("rust_ylong_cloud_ext_unit_test") {
-  module_out_path =
-      "distributeddatamgr/datamgr_service/services/rust/ylong_cloud_extension"
-  sources = [ "src/lib.rs" ]
-
-  external_deps = [
-    "hilog:hilog_rust",
-    "ipc:ipc_rust",
-  ]
-  deps = [
-    ":ylong_cloud_extension",
-    "../connect_adapter:conn_adapter",
-  ]
-  rustflags = [ "--cfg=feature=\"test_server_ready\"" ]
+if (use_clang_coverage) {
+  group("rust_ylong_cloud_ext_unit_test") {
+  }
+} else {
+  ohos_rust_unittest("rust_ylong_cloud_ext_unit_test") {
+    module_out_path =
+        "distributeddatamgr/datamgr_service/services/rust/ylong_cloud_extension"
+    sources = [ "src/lib.rs" ]
+
+    external_deps = [
+      "hilog:hilog_rust",
+      "ipc:ipc_rust",
+    ]
+    deps = [
+      ":ylong_cloud_extension",
+      "../connect_adapter:conn_adapter",
+    ]
+    rustflags = [ "--cfg=feature=\"test_server_ready\"" ]
+  }
 }
diff --git a/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/src/ipc_conn/function.rs b/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/src/ipc_conn/function.rs
index f68387e7e1c69043a866e947a46cc7e2045a7bc7..522b80e1449494ac40e466068e6893364d2b468e 100644
--- a/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/src/ipc_conn/function.rs
+++ b/datamgr_service/services/distributeddataservice/rust/ylong_cloud_extension/src/ipc_conn/function.rs
@@ -31,7 +31,7 @@ pub(crate) enum AssetLoaderFunc {
 }
 
 pub(crate) enum CloudServiceFunc {
-    ConnectAssetLoader = 1,
+    ConnectAssetLoader,
     ConnectDatabase,
     GetAppBriefInfo,
     GetServiceInfo,
diff --git a/datamgr_service/services/distributeddataservice/service/BUILD.gn b/datamgr_service/services/distributeddataservice/service/BUILD.gn
index f2b756ecbf2b4a1290b0b5dc05c36400e70744cc..df0103f75aba67c183d2af4e8c77b3dbb4869258 100644
--- a/datamgr_service/services/distributeddataservice/service/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/BUILD.gn
@@ -68,6 +68,7 @@ ohos_shared_library("distributeddatasvc") {
     "${kv_store_distributeddb_path}",
   ]
   sources = [
+    "${dataobject_path}/frameworks/innerkitsimpl/src/object_radar_reporter.cpp",
     "backup/src/backup_manager.cpp",
     "bootstrap/src/bootstrap.cpp",
     "cloud/cloud_service_impl.cpp",
@@ -80,6 +81,7 @@ ohos_shared_library("distributeddatasvc") {
     "common/value_proxy.cpp",
     "common/xcollie.cpp",
     "config/src/config_factory.cpp",
+    "config/src/model/app_id_mapping_config.cpp",
     "config/src/model/backup_config.cpp",
     "config/src/model/checker_config.cpp",
     "config/src/model/cloud_config.cpp",
@@ -101,7 +103,6 @@ ohos_shared_library("distributeddatasvc") {
     "kvdb/query_helper.cpp",
     "kvdb/upgrade.cpp",
     "kvdb/user_delegate.cpp",
-    "matrix/src/auto_sync_matrix.cpp",
     "matrix/src/device_matrix.cpp",
     "matrix/src/matrix_event.cpp",
     "object/object_asset_loader.cpp",
diff --git a/datamgr_service/services/distributeddataservice/service/CMakeLists.txt b/datamgr_service/services/distributeddataservice/service/CMakeLists.txt
index 0781c718e82367a1c100dd1495015a3b0261ebdc..31fe3b6a040a28a2aa8098f36ebe4be95dcb2f18 100644
--- a/datamgr_service/services/distributeddataservice/service/CMakeLists.txt
+++ b/datamgr_service/services/distributeddataservice/service/CMakeLists.txt
@@ -5,7 +5,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y -fno-rtti -fvisibility=hidden -D_GNU_SOURCE")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdata-sections -fPIC -fpic -ffunction-sections -D_GLIBC_MOCK")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--no-as-needed -ldl")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wa,-mbig-obj")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wa,-mbig-obj -Wenum-compare")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat=0 -fpermissive -Wattributes")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=deprecated-declarations -Wno-deprecated-declarations")
diff --git a/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp b/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp
index 1de16accbae411b7b9134adcc900a0a6a4b0090f..be05b0be00f1340427ff2c7ff2f2ad4343641dd9 100644
--- a/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/backup/src/backup_manager.cpp
@@ -15,9 +15,10 @@
 #define LOG_TAG "BackupManager"
 #include "backup_manager.h"
 
+#include <unistd.h>
+
 #include <fstream>
 #include <iostream>
-#include <unistd.h>
 
 #include "backuprule/backup_rule_manager.h"
 #include "crypto_manager.h"
@@ -53,13 +54,12 @@ void BackupManager::Init()
 {
     std::vector<StoreMetaData> metas;
     MetaDataManager::GetInstance().LoadMeta(
-        StoreMetaData::GetPrefix({DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid}), metas, true);
+        StoreMetaData::GetPrefix({ DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid }), metas, true);
     for (auto &meta : metas) {
         if (!meta.isBackup || meta.isDirty) {
-                continue;
+            continue;
         }
-        auto backupPath =
-            DirectoryManager::GetInstance().GetStoreBackupPath(meta) + "/" + AUTO_BACKUP_NAME;
+        auto backupPath = DirectoryManager::GetInstance().GetStoreBackupPath(meta) + "/" + AUTO_BACKUP_NAME;
         switch (GetClearType(meta)) {
             case ROLLBACK:
                 RollBackData(backupPath);
@@ -171,8 +171,7 @@ void BackupManager::KeepData(const std::string &path)
     CopyFile(path, backupPath, true);
 }
 
-void BackupManager::SaveData(
-    const std::string &path, const std::string &key, const SecretKeyMetaData &secretKey)
+void BackupManager::SaveData(const std::string &path, const std::string &key, const SecretKeyMetaData &secretKey)
 {
     auto tmpPath = path + BACKUP_TMP_POSTFIX;
     auto backupPath = path + BACKUP_BK_POSTFIX;
@@ -249,8 +248,7 @@ void BackupManager::CleanData(const std::string &path)
  * */
 BackupManager::ClearType BackupManager::GetClearType(const StoreMetaData &meta)
 {
-    auto backupFile =
-        DirectoryManager::GetInstance().GetStoreBackupPath(meta) + "/" + AUTO_BACKUP_NAME;
+    auto backupFile = DirectoryManager::GetInstance().GetStoreBackupPath(meta) + "/" + AUTO_BACKUP_NAME;
     auto dbKey = meta.GetSecretKey();
     auto backupKey = meta.GetBackupSecretKey();
     auto bkFile = backupFile + BACKUP_BK_POSTFIX;
@@ -289,7 +287,7 @@ void BackupManager::CopyFile(const std::string &oldPath, const std::string &newP
     } else {
         fout.open(newPath, std::ios_base::out | std::ios_base::trunc);
     }
-    char buf[COPY_SIZE] = {0};
+    char buf[COPY_SIZE] = { 0 };
     while (fin.good()) {
         fin.read(buf, COPY_SIZE);
         fout.write(buf, fin.gcount());
diff --git a/datamgr_service/services/distributeddataservice/service/bootstrap/include/bootstrap.h b/datamgr_service/services/distributeddataservice/service/bootstrap/include/bootstrap.h
index 967ad0976e3fe9da45b7ace4171c6b30ba0a084d..50b86fd88dfa0ae9221c5c6fbf0c0f56b9e25c22 100644
--- a/datamgr_service/services/distributeddataservice/service/bootstrap/include/bootstrap.h
+++ b/datamgr_service/services/distributeddataservice/service/bootstrap/include/bootstrap.h
@@ -31,6 +31,7 @@ public:
     API_EXPORT void LoadDirectory();
     API_EXPORT void LoadCloud();
     API_EXPORT void LoadBackup(std::shared_ptr<ExecutorPool> executors);
+    API_EXPORT void LoadAppIdMappings();
 private:
     static constexpr const char *DEFAULT_LABEL = "distributeddata";
     static constexpr const char *DEFAULT_META = "service_meta";
diff --git a/datamgr_service/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp b/datamgr_service/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp
index 8ef60d480e2152bf81dc0bcaafbf7e7fee2a1616..3dda8f457ec897ed05ae5b399b181cd8c1f3542a 100644
--- a/datamgr_service/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp
+++ b/datamgr_service/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp
@@ -24,6 +24,7 @@
 #include "config_factory.h"
 #include "directory/directory_manager.h"
 #include "log_print.h"
+#include "app_id_mapping/app_id_mapping_config_manager.h"
 namespace OHOS {
 namespace DistributedData {
 Bootstrap &Bootstrap::GetInstance()
@@ -167,5 +168,18 @@ void Bootstrap::LoadCloud()
     }
     CloudConfigManager::GetInstance().Initialize(infos);
 }
+
+void Bootstrap::LoadAppIdMappings()
+{
+    auto *appIdMapping = ConfigFactory::GetInstance().GetAppIdMappingConfig();
+    if (appIdMapping == nullptr) {
+        return;
+    }
+    std::vector<AppIdMappingConfigManager::AppMappingInfo> infos;
+    for (auto &info : *appIdMapping) {
+        infos.push_back({ info.srcAppId, info.dstAppId });
+    }
+    AppIdMappingConfigManager::GetInstance().Initialize(infos);
+}
 } // namespace DistributedData
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
index 76237bc9fd9bc1079a79bb5d86fea8a3f757711b..f48a1f651bed90c8240bb491bbab541190cb62d8 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.cpp
@@ -19,6 +19,7 @@
 
 #include <chrono>
 #include <cinttypes>
+
 #include "accesstoken_kit.h"
 #include "account/account_delegate.h"
 #include "checker/checker_manager.h"
@@ -28,6 +29,7 @@
 #include "cloud/sharing_center.h"
 #include "cloud_value_util.h"
 #include "communicator/device_manager_adapter.h"
+#include "device_matrix.h"
 #include "dfx/radar_reporter.h"
 #include "eventcenter/event_center.h"
 #include "hap_token_info.h"
@@ -112,11 +114,13 @@ int32_t CloudServiceImpl::EnableCloud(const std::string &id, const std::map<std:
             continue;
         }
         cloudInfo.apps[bundle].cloudSwitch = (value == SWITCH_ON);
+        ZLOGI("EnableCloud: change app[%{public}s] switch to %{public}d", bundle.c_str(), value);
     }
     if (!MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true)) {
         return ERROR;
     }
     Execute(GenTask(0, cloudInfo.user, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB }));
+    ZLOGI("EnableCloud success, id:%{public}s, count:%{public}zu", Anonymous::Change(id).c_str(), switches.size());
     return SUCCESS;
 }
 
@@ -139,6 +143,7 @@ int32_t CloudServiceImpl::DisableCloud(const std::string &id)
         return ERROR;
     }
     Execute(GenTask(0, cloudInfo.user, { WORK_STOP_CLOUD_SYNC, WORK_RELEASE, WORK_SUB }));
+    ZLOGI("DisableCloud success, id:%{public}s", Anonymous::Change(id).c_str());
     return SUCCESS;
 }
 
@@ -151,6 +156,9 @@ int32_t CloudServiceImpl::ChangeAppSwitch(const std::string &id, const std::stri
     if (status != SUCCESS) {
         return status;
     }
+    if (!cloudInfo.enableCloud) {
+        return SUCCESS;
+    }
     if (cloudInfo.id != id || !cloudInfo.Exist(bundleName)) {
         ZLOGE("invalid args, [input] id:%{public}s, [exist] id:%{public}s, bundleName:%{public}s",
             Anonymous::Change(id).c_str(), Anonymous::Change(cloudInfo.id).c_str(), bundleName.c_str());
@@ -162,8 +170,11 @@ int32_t CloudServiceImpl::ChangeAppSwitch(const std::string &id, const std::stri
     }
     Execute(GenTask(0, cloudInfo.user, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_SUB }));
     if (cloudInfo.enableCloud && appSwitch == SWITCH_ON) {
-        syncManager_.DoCloudSync({ cloudInfo.user, bundleName });
+        SyncManager::SyncInfo info(cloudInfo.user, bundleName);
+        syncManager_.DoCloudSync(info);
     }
+    ZLOGI("ChangeAppSwitch success, id:%{public}s app:%{public}s, switch:%{public}d", Anonymous::Change(id).c_str(),
+        bundleName.c_str(), appSwitch);
     return SUCCESS;
 }
 
@@ -202,11 +213,19 @@ void CloudServiceImpl::DoClean(int32_t user, const SchemaMeta &schemaMeta, int32
             ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str());
             continue;
         }
+        DistributedData::StoreInfo storeInfo;
+        storeInfo.bundleName = meta.bundleName;
+        storeInfo.user = atoi(meta.user.c_str());
+        storeInfo.storeName = meta.storeId;
+        EventCenter::GetInstance().PostEvent(std::make_unique<CloudEvent>(CloudEvent::CLEAN_DATA, storeInfo));
         auto status = store->Clean({}, action, "");
         if (status != E_OK) {
             ZLOGW("remove device data status:%{public}d, user:%{public}d, bundleName:%{public}s, "
                   "storeId:%{public}s",
                 status, static_cast<int>(user), meta.bundleName.c_str(), meta.GetStoreAlias().c_str());
+        } else {
+            ZLOGD("clean success, user:%{public}d, bundleName:%{public}s, storeId:%{public}s",
+                static_cast<int>(user), meta.bundleName.c_str(), meta.GetStoreAlias().c_str());
         }
     }
 }
@@ -262,6 +281,7 @@ int32_t CloudServiceImpl::CheckNotifyConditions(const std::string &id, const std
         return INVALID_ARGUMENT;
     }
     if (!cloudInfo.enableCloud) {
+        ZLOGD("cloud is disabled, id:%{public}s, app:%{public}s ", Anonymous::Change(id).c_str(), bundleName.c_str());
         return CLOUD_DISABLE;
     }
     if (!cloudInfo.Exist(bundleName)) {
@@ -269,6 +289,8 @@ int32_t CloudServiceImpl::CheckNotifyConditions(const std::string &id, const std
         return INVALID_ARGUMENT;
     }
     if (!cloudInfo.apps[bundleName].cloudSwitch) {
+        ZLOGD("cloud switch is disabled, id:%{public}s, app:%{public}s ", Anonymous::Change(id).c_str(),
+            bundleName.c_str());
         return CLOUD_DISABLE_SWITCH;
     }
     return SUCCESS;
@@ -317,18 +339,14 @@ std::map<std::string, std::vector<std::string>> CloudServiceImpl::GetDbInfoFromE
     return dbInfos;
 }
 
-bool CloudServiceImpl::DoKvCloudSync(int32_t userId, const std::string &bundleName)
+bool CloudServiceImpl::DoKvCloudSync(int32_t userId, const std::string &bundleName, int32_t triggerMode)
 {
     auto stores = CheckerManager::GetInstance().GetDynamicStores();
     auto staticStores = CheckerManager::GetInstance().GetStaticStores();
     stores.insert(stores.end(), staticStores.begin(), staticStores.end());
-    bool found = false;
-    for (auto &store : stores) {
-        if (store.bundleName == bundleName || bundleName.empty()) {
-            found = true;
-            break;
-        }
-    }
+    bool found = std::any_of(stores.begin(), stores.end(), [&bundleName](const CheckerManager::StoreInfo &storeInfo) {
+        return bundleName.empty() || storeInfo.bundleName == bundleName;
+    });
     if (!found) {
         return found;
     }
@@ -339,8 +357,10 @@ bool CloudServiceImpl::DoKvCloudSync(int32_t userId, const std::string &bundleNa
         Account::GetInstance()->QueryForegroundUsers(users);
     }
     for (auto user : users) {
-        for (auto &store : stores) {
-            syncManager_.DoCloudSync(SyncManager::SyncInfo(user, store.bundleName, store.storeId));
+        for (const auto &store : stores) {
+            int32_t mode = (store.bundleName != bundleName && triggerMode == MODE_PUSH) ? MODE_CONSISTENCY
+                                                                                        : triggerMode;
+            syncManager_.DoCloudSync(SyncManager::SyncInfo(user, store.bundleName, store.storeId, {}, mode));
         }
     }
     return found;
@@ -381,9 +401,6 @@ int32_t CloudServiceImpl::NotifyDataChange(const std::string &eventId, const std
             ZLOGD("invalid user:%{public}d", user);
             return INVALID_ARGUMENT;
         }
-        if (DoKvCloudSync(cloudInfo.user, exData.info.bundleName)) {
-            continue;
-        }
         auto schemaKey = CloudInfo::GetSchemaKey(user, exData.info.bundleName);
         SchemaMeta schemaMeta;
         if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) {
@@ -395,9 +412,9 @@ int32_t CloudServiceImpl::NotifyDataChange(const std::string &eventId, const std
             ZLOGE("GetDbInfoFromExtraData failed, empty database info.");
             return INVALID_ARGUMENT;
         }
-        for (auto &dbInfo : dbInfos) {
+        for (const auto &dbInfo : dbInfos) {
             syncManager_.DoCloudSync(
-                SyncManager::SyncInfo(cloudInfo.user, exData.info.bundleName, dbInfo.first, dbInfo.second));
+                SyncManager::SyncInfo(cloudInfo.user, exData.info.bundleName, dbInfo.first, dbInfo.second, MODE_PUSH));
         }
     }
     return SUCCESS;
@@ -407,7 +424,7 @@ std::map<std::string, StatisticInfos> CloudServiceImpl::ExecuteStatistics(const
     const CloudInfo &cloudInfo, const SchemaMeta &schemaMeta)
 {
     std::map<std::string, StatisticInfos> result;
-    for (auto& database : schemaMeta.databases) {
+    for (auto &database : schemaMeta.databases) {
         if (storeId.empty() || database.alias == storeId) {
             StoreMetaData meta;
             meta.bundleName = schemaMeta.bundleName;
@@ -438,7 +455,7 @@ StatisticInfos CloudServiceImpl::QueryStatistics(const StoreMetaData &storeMetaD
         return infos;
     }
     infos.reserve(database.tables.size());
-    for (auto& table : database.tables) {
+    for (const auto &table : database.tables) {
         auto [success, info] = QueryTableStatistic(table.name, store);
         if (success) {
             info.table = table.alias;
@@ -453,8 +470,8 @@ std::pair<bool, StatisticInfo> CloudServiceImpl::QueryTableStatistic(const std::
 {
     StatisticInfo info;
     auto sql = BuildStatisticSql(tableName);
-    auto cursor = store->Query(tableName, sql, {});
-    if (cursor == nullptr || cursor->GetCount() != 1 || cursor->MoveToFirst() != E_OK) {
+    auto [errCode, cursor] = store->Query(tableName, sql, {});
+    if (errCode != E_OK || cursor == nullptr || cursor->GetCount() != 1 || cursor->MoveToFirst() != E_OK) {
         ZLOGE("query failed, cursor is nullptr or move to first failed,tableName:%{public}s",
             Anonymous::Change(tableName).c_str());
         return { false, info };
@@ -519,7 +536,7 @@ std::pair<int32_t, std::map<std::string, StatisticInfos>> CloudServiceImpl::Quer
 
 int32_t CloudServiceImpl::SetGlobalCloudStrategy(Strategy strategy, const std::vector<CommonType::Value> &values)
 {
-    if (strategy < 0 || strategy >= Strategy::STRATEGY_BUTT) {
+    if (strategy >= Strategy::STRATEGY_BUTT) {
         ZLOGE("invalid strategy:%{public}d, size:%{public}zu", strategy, values.size());
         return INVALID_ARGUMENT;
     }
@@ -644,13 +661,7 @@ int32_t CloudServiceImpl::OnUserChange(uint32_t code, const std::string &user, c
     return E_OK;
 }
 
-int32_t CloudServiceImpl::OnScreenUnlocked(int32_t user)
-{
-    DoKvCloudSync(user);
-    return E_OK;
-}
-
-int32_t CloudServiceImpl::OnReady(const std::string& device)
+int32_t CloudServiceImpl::OnReady(const std::string &device)
 {
     if (device != DeviceManagerAdapter::CLOUD_DEVICE_UUID) {
         return SUCCESS;
@@ -661,7 +672,7 @@ int32_t CloudServiceImpl::OnReady(const std::string& device)
         return SUCCESS;
     }
     for (auto user : users) {
-        DoKvCloudSync(user);
+        DoKvCloudSync(user, "", MODE_ONLINE);
         Execute(GenTask(0, user, { WORK_CLOUD_INFO_UPDATE, WORK_SCHEMA_UPDATE, WORK_DO_CLOUD_SYNC, WORK_SUB }));
     }
     return SUCCESS;
@@ -700,15 +711,17 @@ std::pair<int32_t, CloudInfo> CloudServiceImpl::GetCloudInfoFromServer(int32_t u
     CloudInfo cloudInfo;
     cloudInfo.user = userId;
     if (!DmAdapter::GetInstance().IsNetworkAvailable()) {
+        ZLOGD("network is not available");
         return { NETWORK_ERROR, cloudInfo };
     }
     auto instance = CloudServer::GetInstance();
     if (instance == nullptr) {
+        ZLOGD("cloud server is nullptr, user:%{public}d", userId);
         return { SERVER_UNAVAILABLE, cloudInfo };
     }
     cloudInfo = instance->GetServerInfo(cloudInfo.user);
     if (!cloudInfo.IsValid()) {
-        ZLOGE("cloud is empty, user%{public}d", cloudInfo.user);
+        ZLOGE("cloud is empty, user:%{public}d", cloudInfo.user);
         return { CLOUD_INFO_INVALID, cloudInfo };
     }
     return { SUCCESS, cloudInfo };
@@ -731,7 +744,7 @@ bool CloudServiceImpl::UpdateCloudInfo(int32_t user)
         ZLOGE("user:%{public}d, status:%{public}d", user, status);
         return false;
     }
-    ZLOGI("[server] id:%{public}s, enableCloud:%{pubic}d, user:%{public}d, app size:%{public}zu",
+    ZLOGI("[server] id:%{public}s, enableCloud:%{public}d, user:%{public}d, app size:%{public}zu",
           Anonymous::Change(cloudInfo.id).c_str(), cloudInfo.enableCloud, cloudInfo.user, cloudInfo.apps.size());
     CloudInfo oldInfo;
     if (!MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetKey(), oldInfo, true)) {
@@ -758,7 +771,6 @@ bool CloudServiceImpl::UpdateSchema(int32_t user)
 {
     auto [status, cloudInfo] = GetCloudInfo(user);
     if (status != SUCCESS) {
-        ZLOGE("user:%{public}d, status:%{public}d", user, status);
         return false;
     }
     auto keys = cloudInfo.GetSchemaKey();
@@ -786,6 +798,7 @@ std::pair<int32_t, SchemaMeta> CloudServiceImpl::GetAppSchemaFromServer(int32_t
 {
     SchemaMeta schemaMeta;
     if (!DmAdapter::GetInstance().IsNetworkAvailable()) {
+        ZLOGD("network is not available");
         return { NETWORK_ERROR, schemaMeta };
     }
     auto instance = CloudServer::GetInstance();
@@ -823,13 +836,14 @@ ExecutorPool::Task CloudServiceImpl::GenTask(int32_t retry, int32_t user, Handle
             return;
         }
         if (!DmAdapter::GetInstance().IsNetworkAvailable()) {
+            ZLOGD("network is not available");
             return;
         }
         bool finished = true;
         std::vector<int32_t> users;
         if (user == 0) {
             auto account = Account::GetInstance();
-            finished = !(account == nullptr) && account->QueryUsers(users);
+            finished = (account != nullptr) && account->QueryUsers(users);
         } else {
             users.push_back(user);
         }
@@ -968,7 +982,7 @@ void CloudServiceImpl::CloudShare(const Event &event)
 }
 
 std::pair<int32_t, std::shared_ptr<DistributedData::Cursor>> CloudServiceImpl::PreShare(
-    const StoreInfo& storeInfo, GenQuery& query)
+    const StoreInfo &storeInfo, GenQuery &query)
 {
     StoreMetaData meta(storeInfo);
     meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
@@ -982,7 +996,7 @@ std::pair<int32_t, std::shared_ptr<DistributedData::Cursor>> CloudServiceImpl::P
         ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str());
         return { GeneralError::E_ERROR, nullptr };
     }
-    return { GeneralError::E_OK, store->PreSharing(query) };
+    return store->PreSharing(query);
 }
 
 bool CloudServiceImpl::ReleaseUserInfo(int32_t user)
@@ -997,7 +1011,8 @@ bool CloudServiceImpl::ReleaseUserInfo(int32_t user)
 
 bool CloudServiceImpl::DoCloudSync(int32_t user)
 {
-    syncManager_.DoCloudSync(user);
+    SyncManager::SyncInfo info(user);
+    syncManager_.DoCloudSync(info);
     return true;
 }
 
@@ -1101,8 +1116,8 @@ std::map<std::string, int32_t> CloudServiceImpl::ConvertAction(const std::map<st
 }
 
 std::pair<int32_t, std::vector<NativeRdb::ValuesBucket>> CloudServiceImpl::AllocResourceAndShare(
-    const std::string& storeId, const DistributedRdb::PredicatesMemo& predicates,
-    const std::vector<std::string>& columns, const Participants& participants)
+    const std::string &storeId, const DistributedRdb::PredicatesMemo &predicates,
+    const std::vector<std::string> &columns, const Participants &participants)
 {
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto hapInfo = GetHapInfo(tokenId);
@@ -1390,7 +1405,7 @@ void CloudServiceImpl::InitSubTask(const Subscription &sub, uint64_t minInterval
     if (executor == nullptr) {
         return;
     }
-    ZLOGI("Subscription Info, subTask:%{public}" PRIu64", user:%{public}d", subTask_, sub.userId);
+    ZLOGI("Subscription Info, subTask:%{public}" PRIu64 ", user:%{public}d", subTask_, sub.userId);
     expire = expire - TIME_BEFORE_SUB; // before 12 hours
     auto now = static_cast<uint64_t>(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
     Duration delay = milliseconds(std::max(expire > now ? expire - now : 0, minInterval));
@@ -1408,7 +1423,7 @@ void CloudServiceImpl::InitSubTask(const Subscription &sub, uint64_t minInterval
 
 int32_t CloudServiceImpl::SetCloudStrategy(Strategy strategy, const std::vector<CommonType::Value> &values)
 {
-    if (strategy < 0 || strategy >= Strategy::STRATEGY_BUTT) {
+    if (strategy >= Strategy::STRATEGY_BUTT) {
         ZLOGE("invalid strategy:%{public}d, size:%{public}zu", strategy, values.size());
         return INVALID_ARGUMENT;
     }
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.h b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.h
index 76476c25305e91d5981d65f3d29ea9b261f64b7f..212b7780d55104c42e564bde3d37af56f54ed0f5 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.h
+++ b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_impl.h
@@ -18,12 +18,13 @@
 
 #include <mutex>
 #include <queue>
+
 #include "cloud/cloud_event.h"
 #include "cloud/cloud_extra_data.h"
 #include "cloud/cloud_info.h"
 #include "cloud/schema_meta.h"
-#include "cloud/subscription.h"
 #include "cloud/sharing_center.h"
+#include "cloud/subscription.h"
 #include "cloud_service_stub.h"
 #include "feature/static_acts.h"
 #include "sync_manager.h"
@@ -67,7 +68,6 @@ public:
     int32_t OnInitialize() override;
     int32_t OnBind(const BindInfo &info) override;
     int32_t OnUserChange(uint32_t code, const std::string &user, const std::string &account) override;
-    int32_t OnScreenUnlocked(int32_t user) override;
     int32_t OnReady(const std::string &device) override;
     int32_t Offline(const std::string &device) override;
 
@@ -158,7 +158,7 @@ private:
         const DistributedData::ExtraData &extraData, const SchemaMeta &schemaMeta);
     std::shared_ptr<DistributedData::SharingCenter> GetSharingHandle(const HapInfo& hapInfo);
     bool GetStoreMetaData(StoreMetaData &meta);
-    bool DoKvCloudSync(int32_t userId, const std::string &bundleName = "");
+    bool DoKvCloudSync(int32_t userId, const std::string &bundleName = "", int32_t triggerMode = 0);
 
     using SaveStrategy = int32_t (*)(const std::vector<CommonType::Value> &values, const HapInfo &hapInfo);
     static const SaveStrategy STRATEGY_SAVERS[Strategy::STRATEGY_BUTT];
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_stub.cpp b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_stub.cpp
index 3fc501882a929211bd9ee09381295247a51a0115..ef5c357e711f63778537a15a1744aacf50294072 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_stub.cpp
+++ b/datamgr_service/services/distributeddataservice/service/cloud/cloud_service_stub.cpp
@@ -15,14 +15,14 @@
 #define LOG_TAG "CloudServiceStub"
 #include "cloud_service_stub.h"
 
-#include "ipc_skeleton.h"
-#include "cloud_types_util.h"
 #include "cloud/cloud_config_manager.h"
+#include "cloud_types_util.h"
+#include "ipc_skeleton.h"
 #include "log_print.h"
 #include "permission/permission_validator.h"
 #include "rdb_types.h"
-#include "utils/anonymous.h"
 #include "tokenid_kit.h"
+#include "utils/anonymous.h"
 namespace OHOS::CloudData {
 using namespace DistributedData;
 using namespace OHOS::Security::AccessToken;
@@ -89,7 +89,7 @@ int32_t CloudServiceStub::OnEnableCloud(MessageParcel &data, MessageParcel &repl
         return IPC_STUB_INVALID_DATA_ERR;
     }
     std::map<std::string, int32_t> localSwitches;
-    for (auto &[bundle, status] : switches) {
+    for (const auto &[bundle, status] : switches) {
         localSwitches.insert_or_assign(CloudConfigManager::GetInstance().ToLocal(bundle), status);
     }
     auto result = EnableCloud(id, localSwitches);
@@ -129,7 +129,7 @@ int32_t CloudServiceStub::OnClean(MessageParcel &data, MessageParcel &reply)
         return IPC_STUB_INVALID_DATA_ERR;
     }
     std::map<std::string, int32_t> localActions;
-    for (auto &[bundle, action] : actions) {
+    for (const auto &[bundle, action] : actions) {
         localActions.insert_or_assign(CloudConfigManager::GetInstance().ToLocal(bundle), action);
     }
     auto result = Clean(id, localActions);
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/cloud_types_util.h b/datamgr_service/services/distributeddataservice/service/cloud/cloud_types_util.h
index 4e151fa9eedc757dcd99554740f6f67f525e3fdc..afb74b6cba7fab57226c791f35e205c389a03d87 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/cloud_types_util.h
+++ b/datamgr_service/services/distributeddataservice/service/cloud/cloud_types_util.h
@@ -17,7 +17,6 @@
 #define OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_TYPES_UTIL_H
 #include "cloud_types.h"
 #include "itypes_util.h"
-#include "cloud_types.h"
 #include "values_bucket.h"
 
 namespace OHOS::ITypesUtil {
@@ -69,4 +68,4 @@ bool Marshalling(const CloudSyncInfo &input, MessageParcel &data);
 template<>
 bool Unmarshalling(CloudSyncInfo &output, MessageParcel &data);
 } // namespace OHOS::ITypesUtil
-#endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_TYPES_UTIL_H
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_TYPES_UTIL_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/cloud_value_util.h b/datamgr_service/services/distributeddataservice/service/cloud/cloud_value_util.h
index 4b3e9cdcdd2f2d3fccce78a3f34ebfbe80233ca5..b9d66441ced0525f97d76d6937963569d4ed4c80 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/cloud_value_util.h
+++ b/datamgr_service/services/distributeddataservice/service/cloud/cloud_value_util.h
@@ -16,9 +16,9 @@
 #ifndef OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_VALUE_UTIL_H
 #define OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_VALUE_UTIL_H
 
+#include "cloud/sharing_center.h"
 #include "cloud_service.h"
 #include "cloud_types.h"
-#include "cloud/sharing_center.h"
 #include "error/general_error.h"
 
 namespace OHOS::CloudData {
@@ -53,4 +53,4 @@ Status Convert(CenterCode code);
 Status Convert(GenErr code);
 } // namespace SharingUtil
 } // namespace OHOS::CloudData
-#endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_VALUE_UTIL_H
+#endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_CLOUD_VALUE_UTIL_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.cpp b/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.cpp
index c52040fa2adaa60ccb2f59510ef536dec96f2b6e..40f41784feb55fe88e45be94bf84cf0c22910270 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.cpp
@@ -18,10 +18,13 @@
 #include <chrono>
 
 #include "account/account_delegate.h"
+#include "bootstrap.h"
+#include "checker/checker_manager.h"
 #include "cloud/cloud_server.h"
 #include "cloud/schema_meta.h"
 #include "cloud/sync_event.h"
 #include "cloud_value_util.h"
+#include "cloud/cloud_lock_event.h"
 #include "device_manager_adapter.h"
 #include "dfx/radar_reporter.h"
 #include "eventcenter/event_center.h"
@@ -40,8 +43,9 @@ using Account = OHOS::DistributedKv::AccountDelegate;
 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 using Defer = EventCenter::Defer;
 std::atomic<uint32_t> SyncManager::genId_ = 0;
-SyncManager::SyncInfo::SyncInfo(int32_t user, const std::string &bundleName, const Store &store, const Tables &tables)
-    : user_(user), bundleName_(bundleName)
+SyncManager::SyncInfo::SyncInfo(
+    int32_t user, const std::string &bundleName, const Store &store, const Tables &tables, int32_t triggerMode)
+    : user_(user), bundleName_(bundleName), triggerMode_(triggerMode)
 {
     if (!store.empty()) {
         tables_[store] = tables;
@@ -90,6 +94,11 @@ void SyncManager::SyncInfo::SetCompensation(bool isCompensation)
     isCompensation_ = isCompensation;
 }
 
+void SyncManager::SyncInfo::SetTriggerMode(int32_t triggerMode)
+{
+    triggerMode_ = triggerMode;
+}
+
 void SyncManager::SyncInfo::SetError(int32_t code) const
 {
     if (async_) {
@@ -132,10 +141,56 @@ bool SyncManager::SyncInfo::Contains(const std::string &storeName)
     return tables_.empty() || tables_.find(storeName) != tables_.end();
 }
 
+std::function<void(const Event &)> SyncManager::GetLockChangeHandler()
+{
+    return [](const Event &event) {
+        auto &evt = static_cast<const CloudLockEvent &>(event);
+        auto storeInfo = evt.GetStoreInfo();
+        auto callback = evt.GetCallback();
+        if (callback == nullptr) {
+            ZLOGE("callback is nullptr. bundleName: %{public}s, storeName: %{public}s, user: %{public}d.",
+                storeInfo.bundleName.c_str(), Anonymous::Change(storeInfo.storeName).c_str(), storeInfo.user);
+            return;
+        }
+        StoreMetaData meta(storeInfo);
+        meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+        if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
+            ZLOGE("not found meta. bundleName: %{public}s, storeName: %{public}s, user: %{public}d.",
+                storeInfo.bundleName.c_str(), Anonymous::Change(storeInfo.storeName).c_str(), storeInfo.user);
+            return;
+        }
+        auto store = GetStore(meta, storeInfo.user);
+        if (store == nullptr) {
+            ZLOGE("failed to get store. bundleName: %{public}s, storeName: %{public}s, user: %{public}d.",
+                storeInfo.bundleName.c_str(), Anonymous::Change(storeInfo.storeName).c_str(), storeInfo.user);
+            return;
+        }
+        if (evt.GetEventId() == CloudEvent::LOCK_CLOUD_CONTAINER) {
+            auto [result, expiredTime] = store->LockCloudDB();
+            callback(result, expiredTime);
+        } else {
+            auto result = store->UnLockCloudDB();
+            callback(result, 0);
+        }
+    };
+}
+
 SyncManager::SyncManager()
 {
+    EventCenter::GetInstance().Subscribe(CloudEvent::LOCK_CLOUD_CONTAINER, GetLockChangeHandler());
+    EventCenter::GetInstance().Subscribe(CloudEvent::UNLOCK_CLOUD_CONTAINER, GetLockChangeHandler());
     EventCenter::GetInstance().Subscribe(CloudEvent::LOCAL_CHANGE, GetClientChangeHandler());
     syncStrategy_ = std::make_shared<NetworkSyncStrategy>();
+    auto metaName = Bootstrap::GetInstance().GetProcessLabel();
+    kvApps_.insert(std::move(metaName));
+    auto stores = CheckerManager::GetInstance().GetStaticStores();
+    for (auto &store : stores) {
+        kvApps_.insert(std::move(store.bundleName));
+    }
+    stores = CheckerManager::GetInstance().GetDynamicStores();
+    for (auto &store : stores) {
+        kvApps_.insert(std::move(store.bundleName));
+    }
 }
 
 SyncManager::~SyncManager()
@@ -210,10 +265,11 @@ GeneralError SyncManager::IsValid(SyncInfo &info, CloudInfo &cloud)
     return E_OK;
 }
 
-std::function<void()> SyncManager::GetPostEventTask(const std::vector<SchemaMeta> &schemas, CloudInfo &cloud,
+std::function<bool()> SyncManager::GetPostEventTask(const std::vector<SchemaMeta> &schemas, CloudInfo &cloud,
     SyncInfo &info, bool retry)
 {
     return [this, &cloud, &info, &schemas, retry]() {
+        bool isPostEvent = false;
         for (auto &schema : schemas) {
             if (!cloud.IsOn(schema.bundleName)) {
                 continue;
@@ -234,12 +290,18 @@ std::function<void()> SyncManager::GetPostEventTask(const std::vector<SchemaMeta
                     continue;
                 }
                 auto query = info.GenerateQuery(database.name, database.GetTableNames());
-                SyncParam syncParam = { info.mode_, info.wait_, info.isCompensation_ };
+                SyncParam syncParam = { info.mode_, info.wait_, info.isCompensation_, info.triggerMode_ };
                 auto evt = std::make_unique<SyncEvent>(std::move(storeInfo),
                     SyncEvent::EventInfo{ syncParam, retry, std::move(query), info.async_ });
                 EventCenter::GetInstance().PostEvent(std::move(evt));
+                isPostEvent = true;
             }
         }
+        if (!isPostEvent) {
+            ZLOGE("schema is invalid, user: %{public}d", cloud.user);
+            info.SetError(E_ERROR);
+        }
+        return isPostEvent;
     };
 }
 
@@ -261,9 +323,7 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount
         UpdateStartSyncInfo(cloudSyncInfos);
         auto code = IsValid(info, cloud);
         if (code != E_OK) {
-            for (const auto &[queryKey, syncId] : cloudSyncInfos) {
-                UpdateFinishSyncInfo(queryKey, syncId, code);
-            }
+            BatchUpdateFinishState(cloudSyncInfos, code);
             return;
         }
 
@@ -273,7 +333,8 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount
             UpdateSchema(info);
             schemas = GetSchemaMeta(cloud, info.bundleName_);
             if (schemas.empty()) {
-                retryer(RETRY_INTERVAL, E_RETRY_TIMEOUT, Status::SCHEMA_INVALID);
+                retryer(RETRY_INTERVAL, E_RETRY_TIMEOUT, E_CLOUD_DISABLED);
+                BatchUpdateFinishState(cloudSyncInfos, E_CLOUD_DISABLED);
                 return;
             }
         }
@@ -282,9 +343,10 @@ ExecutorPool::Task SyncManager::GetSyncTask(int32_t times, bool retry, RefCount
             info.user_ = 0;
         }
         auto task = GetPostEventTask(schemas, cloud, info, retry);
-        if (task != nullptr) {
-            task();
+        if (task != nullptr && task()) {
+            return;
         }
+        BatchUpdateFinishState(cloudSyncInfos, E_ERROR);
     };
 }
 
@@ -312,25 +374,30 @@ std::function<void(const Event &)> SyncManager::GetSyncHandler(Retryer retryer)
         auto store = GetStore(meta, storeInfo.user);
         if (store == nullptr) {
             ZLOGE("store null, storeId:%{public}s", meta.GetStoreAlias().c_str());
-            DoExceptionalCallback(async, details, storeInfo);
-            return;
+            return DoExceptionalCallback(async, details, storeInfo);
         }
         ZLOGD("database:<%{public}d:%{public}s:%{public}s> sync start", storeInfo.user, storeInfo.bundleName.c_str(),
             meta.GetStoreAlias().c_str());
         RadarReporter::Report(
-            { storeInfo.bundleName.c_str(), CLOUD_SYNC, TRIGGER_SYNC, storeInfo.syncId }, "GetSyncHandler", BEGIN);
+            { storeInfo.bundleName.c_str(), CLOUD_SYNC, TRIGGER_SYNC, storeInfo.syncId, evt.GetTriggerMode() },
+            "GetSyncHandler", BEGIN);
         SyncParam syncParam = { evt.GetMode(), evt.GetWait(), evt.IsCompensation() };
         auto status = store->Sync({ SyncInfo::DEFAULT_ID }, *(evt.GetQuery()),
-            evt.AutoRetry() ? RetryCallback(storeInfo, retryer) : GetCallback(evt.GetAsyncDetail(), storeInfo),
+            evt.AutoRetry() ? RetryCallback(storeInfo, retryer, evt.GetTriggerMode())
+                            : GetCallback(evt.GetAsyncDetail(), storeInfo, evt.GetTriggerMode()),
             syncParam);
         if (status != E_OK) {
-            int32_t errCode = status + GenStore::DB_ERR_OFFSET;
-            RadarReporter::Report({ storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId, errCode },
-                "GetSyncHandler", END);
             if (async) {
                 detail.code = status;
                 async(std::move(details));
             }
+            UpdateFinishSyncInfo({ GetAccountId(storeInfo.user), storeInfo.bundleName, "" }, storeInfo.syncId, E_ERROR);
+            if (status == GeneralError::E_NOT_SUPPORT) {
+                return;
+            }
+            int32_t errCode = status + GenStore::DB_ERR_OFFSET;
+            RadarReporter::Report({ storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId,
+                                  evt.GetTriggerMode(), false, errCode }, "GetSyncHandler", END);
         }
     };
 }
@@ -346,6 +413,7 @@ std::function<void(const Event &)> SyncManager::GetClientChangeHandler()
         syncInfo.SetAsyncDetail(evt.GetAsyncDetail());
         syncInfo.SetQuery(evt.GetQuery());
         syncInfo.SetCompensation(evt.IsCompensation());
+        syncInfo.SetTriggerMode(evt.GetTriggerMode());
         auto times = evt.AutoRetry() ? RETRY_TIMES - CLIENT_RETRY_TIMES : RETRY_TIMES;
         executor_->Execute(GetSyncTask(times, evt.AutoRetry(), RefCount(), std::move(syncInfo)));
     };
@@ -360,7 +428,8 @@ SyncManager::Retryer SyncManager::GetRetryer(int32_t times, const SyncInfo &sync
             }
             info.SetError(code);
             RadarReporter::Report(
-                { info.bundleName_.c_str(), CLOUD_SYNC, FINISH_SYNC, info.syncId_, dbCode }, "GetRetryer", END);
+                { info.bundleName_.c_str(), CLOUD_SYNC, FINISH_SYNC, info.syncId_, info.triggerMode_, false, dbCode },
+                "GetRetryer", END);
             return true;
         };
     }
@@ -371,7 +440,8 @@ SyncManager::Retryer SyncManager::GetRetryer(int32_t times, const SyncInfo &sync
         if (code == E_NO_SPACE_FOR_ASSET || code == E_RECODE_LIMIT_EXCEEDED) {
             info.SetError(code);
             RadarReporter::Report(
-                { info.bundleName_.c_str(), CLOUD_SYNC, FINISH_SYNC, info.syncId_, dbCode }, "GetRetryer", END);
+                { info.bundleName_.c_str(), CLOUD_SYNC, FINISH_SYNC, info.syncId_, info.triggerMode_, false, dbCode },
+                "GetRetryer", END);
             return true;
         }
 
@@ -479,7 +549,7 @@ AutoCache::Store SyncManager::GetStore(const StoreMetaData &meta, int32_t user,
         }
         SchemaMeta schemaMeta;
         std::string schemaKey = info.GetSchemaKey(meta.bundleName, meta.instanceId);
-        if (!MetaDataManager::GetInstance().LoadMeta(std::move(schemaKey), schemaMeta, true)) {
+        if (!MetaDataManager::GetInstance().LoadMeta(schemaKey, schemaMeta, true)) {
             ZLOGE("failed, no schema bundleName:%{public}s, storeId:%{public}s", meta.bundleName.c_str(),
                 meta.GetStoreAlias().c_str());
             return nullptr;
@@ -523,7 +593,6 @@ std::vector<std::tuple<QueryKey, uint64_t>> SyncManager::GetCloudSyncInfo(const
             ZLOGW("save cloud info fail, user: %{public}d", cloud.user);
         }
     }
-
     if (info.bundleName_.empty()) {
         for (const auto &it : cloud.apps) {
             QueryKey queryKey{ .accountId = cloud.id, .bundleName = it.first, .storeId = "" };
@@ -546,9 +615,20 @@ void SyncManager::GetLastResults(
     }
 }
 
+bool SyncManager::NeedSaveSyncInfo(const QueryKey &queryKey)
+{
+    if (queryKey.accountId.empty()) {
+        return false;
+    }
+    if (std::find(kvApps_.begin(), kvApps_.end(), queryKey.bundleName) != kvApps_.end()) {
+        return false;
+    }
+    return true;
+}
+
 int32_t SyncManager::QueryLastSyncInfo(const std::vector<QueryKey> &queryKeys, QueryLastResults &results)
 {
-    for (auto &queryKey : queryKeys) {
+    for (const auto &queryKey : queryKeys) {
         std::string storeId = queryKey.storeId;
         QueryKey key{ .accountId = queryKey.accountId, .bundleName = queryKey.bundleName, .storeId = "" };
         lastSyncInfos_.ComputeIfPresent(
@@ -564,6 +644,9 @@ void SyncManager::UpdateStartSyncInfo(const std::vector<std::tuple<QueryKey, uin
 {
     int64_t startTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
     for (const auto &[queryKey, syncId] : cloudSyncInfos) {
+        if (!NeedSaveSyncInfo(queryKey)) {
+            continue;
+        }
         lastSyncInfos_.Compute(queryKey, [id = syncId, startTime](auto &, std::map<SyncId, CloudSyncInfo> &val) {
             val[id] = { .startTime = startTime };
             return !val.empty();
@@ -573,14 +656,21 @@ void SyncManager::UpdateStartSyncInfo(const std::vector<std::tuple<QueryKey, uin
 
 void SyncManager::UpdateFinishSyncInfo(const QueryKey &queryKey, uint64_t syncId, int32_t code)
 {
+    if (!NeedSaveSyncInfo(queryKey)) {
+        return;
+    }
     lastSyncInfos_.ComputeIfPresent(queryKey, [syncId, code](auto &key, std::map<SyncId, CloudSyncInfo> &val) {
+        auto now = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
         for (auto iter = val.begin(); iter != val.end();) {
-            if (iter->first != syncId && iter->second.code != -1) {
+            bool isExpired = ((now - iter->second.startTime) >= EXPIRATION_TIME) && iter->second.code == -1;
+            if ((iter->first != syncId && ((iter->second.code != -1) || isExpired))) {
                 iter = val.erase(iter);
-            } else {
+            } else if (iter->first == syncId) {
                 iter->second.finishTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
                 iter->second.code = code;
                 iter++;
+            } else {
+                iter++;
             }
         }
         return true;
@@ -588,9 +678,9 @@ void SyncManager::UpdateFinishSyncInfo(const QueryKey &queryKey, uint64_t syncId
 }
 
 std::function<void(const GenDetails &result)> SyncManager::GetCallback(const GenAsync &async,
-    const StoreInfo &storeInfo)
+    const StoreInfo &storeInfo, int32_t triggerMode)
 {
-    return [this, async, storeInfo](const GenDetails &result) {
+    return [this, async, storeInfo, triggerMode](const GenDetails &result) {
         if (async != nullptr) {
             async(result);
         }
@@ -606,6 +696,7 @@ std::function<void(const GenDetails &result)> SyncManager::GetCallback(const Gen
 
         auto id = GetAccountId(storeInfo.user);
         if (id.empty()) {
+            ZLOGD("account id is empty");
             return;
         }
         QueryKey queryKey{
@@ -617,8 +708,9 @@ std::function<void(const GenDetails &result)> SyncManager::GetCallback(const Gen
         int32_t code = result.begin()->second.code;
         int32_t dbCode = (result.begin()->second.dbCode == GenStore::DB_ERR_OFFSET) ? 0 : result.begin()->second.dbCode;
         UpdateFinishSyncInfo(queryKey, storeInfo.syncId, code);
-        RadarReporter::Report(
-            { storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId, dbCode }, "GetCallback", END);
+        RadarReporter::Report({ storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId, triggerMode,
+                                  result.begin()->second.changeCount, dbCode },
+            "GetCallback", END);
     };
 }
 
@@ -677,9 +769,9 @@ bool SyncManager::InitDefaultUser(int32_t &user)
 }
 
 std::function<void(const DistributedData::GenDetails &result)> SyncManager::RetryCallback(
-    const StoreInfo &storeInfo, Retryer retryer)
+    const StoreInfo &storeInfo, Retryer retryer, int32_t triggerMode)
 {
-    return [this, retryer, storeInfo](const GenDetails &details) {
+    return [this, retryer, storeInfo, triggerMode](const GenDetails &details) {
         if (details.empty()) {
             ZLOGE("retry, details empty");
             return;
@@ -690,11 +782,21 @@ std::function<void(const DistributedData::GenDetails &result)> SyncManager::Retr
             QueryKey queryKey{ GetAccountId(storeInfo.user), storeInfo.bundleName, "" };
             UpdateFinishSyncInfo(queryKey, storeInfo.syncId, code);
             if (code == E_OK) {
-                RadarReporter::Report(
-                    { storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId }, "RetryCallback", END);
+                RadarReporter::Report({ storeInfo.bundleName.c_str(), CLOUD_SYNC, FINISH_SYNC, storeInfo.syncId,
+                                          triggerMode, details.begin()->second.changeCount },
+                    "RetryCallback", END);
             }
         }
         retryer(GetInterval(code), code, dbCode);
     };
 }
+
+void SyncManager::BatchUpdateFinishState(const std::vector<std::tuple<QueryKey, uint64_t>> &cloudSyncInfos,
+    int32_t code)
+{
+    for (const auto &[queryKey, syncId] : cloudSyncInfos) {
+        UpdateFinishSyncInfo(queryKey, syncId, code);
+    }
+}
+
 } // namespace OHOS::CloudData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.h b/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.h
index e4d7b0e428569a5a4a595d7a209a0906bf823948..2aed28defc06b6dec157b01af17ffc9e6c6d575a 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.h
+++ b/datamgr_service/services/distributeddataservice/service/cloud/sync_manager.h
@@ -46,7 +46,8 @@ public:
         using Stores = std::vector<Store>;
         using Tables = std::vector<std::string>;
         using MutliStoreTables = std::map<Store, Tables>;
-        SyncInfo(int32_t user, const std::string &bundleName = "", const Store &store = "", const Tables &tables = {});
+        explicit SyncInfo(int32_t user, const std::string &bundleName = "", const Store &store = "",
+            const Tables &tables = {}, int32_t triggerMode = 0);
         SyncInfo(int32_t user, const std::string &bundleName, const Stores &stores);
         SyncInfo(int32_t user, const std::string &bundleName, const MutliStoreTables &tables);
         void SetMode(int32_t mode);
@@ -55,6 +56,7 @@ public:
         void SetQuery(std::shared_ptr<GenQuery> query);
         void SetError(int32_t code) const;
         void SetCompensation(bool isCompensation);
+        void SetTriggerMode(int32_t triggerMode);
         std::shared_ptr<GenQuery> GenerateQuery(const std::string &store, const Tables &tables);
         bool Contains(const std::string &storeName);
         inline static constexpr const char *DEFAULT_ID = "default";
@@ -71,6 +73,7 @@ public:
         GenAsync async_;
         std::shared_ptr<GenQuery> query_;
         bool isCompensation_ = false;
+        int32_t triggerMode_ = 0;
     };
     SyncManager();
     ~SyncManager();
@@ -93,13 +96,14 @@ private:
     using GenProgress = DistributedData::GenProgress;
     using GenDetails = DistributedData::GenDetails;
 
-    static constexpr ExecutorPool::Duration RETRY_INTERVAL = std::chrono::seconds(10); // second
+    static constexpr ExecutorPool::Duration RETRY_INTERVAL = std::chrono::seconds(10);  // second
     static constexpr ExecutorPool::Duration LOCKED_INTERVAL = std::chrono::seconds(30); // second
-    static constexpr ExecutorPool::Duration BUSY_INTERVAL = std::chrono::seconds(180); // second
-    static constexpr int32_t RETRY_TIMES = 6; // normal retry
-    static constexpr int32_t CLIENT_RETRY_TIMES = 3; // normal retry
-    static constexpr uint64_t USER_MARK = 0xFFFFFFFF00000000; // high 32 bit
+    static constexpr ExecutorPool::Duration BUSY_INTERVAL = std::chrono::seconds(180);  // second
+    static constexpr int32_t RETRY_TIMES = 6;                                           // normal retry
+    static constexpr int32_t CLIENT_RETRY_TIMES = 3;                                    // normal retry
+    static constexpr uint64_t USER_MARK = 0xFFFFFFFF00000000;                           // high 32 bit
     static constexpr int32_t MV_BIT = 32;
+    static constexpr int32_t EXPIRATION_TIME = 6 * 60 * 60 * 1000;                      // 6 hours
 
     static uint64_t GenerateId(int32_t user);
     static ExecutorPool::Duration GetInterval(int32_t code);
@@ -120,15 +124,18 @@ private:
     void UpdateStartSyncInfo(const std::vector<std::tuple<QueryKey, uint64_t>> &cloudSyncInfos);
     void UpdateFinishSyncInfo(const QueryKey &queryKey, uint64_t syncId, int32_t code);
     std::function<void(const DistributedData::GenDetails &result)> GetCallback(const GenAsync &async,
-        const StoreInfo &storeInfo);
-    std::function<void()> GetPostEventTask(const std::vector<SchemaMeta> &schemas, CloudInfo &cloud, SyncInfo &info,
+        const StoreInfo &storeInfo, int32_t triggerMode);
+    std::function<bool()> GetPostEventTask(const std::vector<SchemaMeta> &schemas, CloudInfo &cloud, SyncInfo &info,
         bool retry);
     void DoExceptionalCallback(const GenAsync &async, GenDetails &details, const StoreInfo &storeInfo);
     bool InitDefaultUser(int32_t &user);
     std::function<void(const DistributedData::GenDetails &result)> RetryCallback(
-        const StoreInfo &storeInfo, Retryer retryer);
+        const StoreInfo &storeInfo, Retryer retryer, int32_t triggerMode);
     static void GetLastResults(
         const std::string &storeId, std::map<SyncId, CloudSyncInfo> &infos, QueryLastResults &results);
+    void BatchUpdateFinishState(const std::vector<std::tuple<QueryKey, uint64_t>> &cloudSyncInfos, int32_t code);
+    bool NeedSaveSyncInfo(const QueryKey &queryKey);
+    std::function<void(const Event &)> GetLockChangeHandler();
 
     static std::atomic<uint32_t> genId_;
     std::shared_ptr<ExecutorPool> executor_;
@@ -136,6 +143,7 @@ private:
     ConcurrentMap<uint64_t, uint64_t> activeInfos_;
     std::shared_ptr<SyncStrategy> syncStrategy_;
     ConcurrentMap<QueryKey, std::map<SyncId, CloudSyncInfo>> lastSyncInfos_;
+    std::set<std::string> kvApps_;
 };
 } // namespace OHOS::CloudData
 #endif // OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_SYNC_MANAGER_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.cpp b/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.cpp
index 043cb5e781247617300924db0ee67bbb3cfe82a4..827bf6289b4be7d47fa519e9e95c39ecafb5178e 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.cpp
@@ -16,17 +16,19 @@
 #define LOG_TAG "NetworkSyncStrategy"
 
 #include "network_sync_strategy.h"
-#include "metadata/meta_data_manager.h"
+
 #include "device_manager_adapter.h"
 #include "error/general_error.h"
-#include "utils/constant.h"
 #include "log_print.h"
+#include "metadata/meta_data_manager.h"
+#include "utils/constant.h"
 namespace OHOS::CloudData {
 using namespace OHOS::DistributedData;
 NetworkSyncStrategy::NetworkSyncStrategy()
 {
     MetaDataManager::GetInstance().Subscribe(
-        StrategyInfo::PREFIX, [this](const std::string &key, const std::string &value, int32_t flag) -> auto {
+        StrategyInfo::PREFIX,
+        [this](const std::string &key, const std::string &value, int32_t flag) -> auto {
             StrategyInfo info;
             StrategyInfo::Unmarshall(value, info);
             ZLOGI("flag:%{public}d, value:%{public}s", flag, value.c_str());
@@ -41,14 +43,20 @@ NetworkSyncStrategy::NetworkSyncStrategy()
                 ZLOGE("ignored operation");
             }
             return true;
-        }, true);
+        },
+        true);
 }
+
 NetworkSyncStrategy::~NetworkSyncStrategy()
 {
     MetaDataManager::GetInstance().Unsubscribe(StrategyInfo::PREFIX);
 }
+
 int32_t NetworkSyncStrategy::CheckSyncAction(const StoreInfo &storeInfo)
 {
+    if (storeInfo.user == StrategyInfo::ROOT_USER) {
+        return E_OK;
+    }
     if (!DeviceManagerAdapter::GetInstance().IsNetworkAvailable()) {
         return E_NETWORK_ERROR;
     }
@@ -125,4 +133,4 @@ NetworkSyncStrategy::StrategyInfo NetworkSyncStrategy::GetStrategy(int32_t user,
     strategies_.Insert(info.bundleName, info);
     return info;
 }
-}
+} // namespace OHOS::CloudData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.h b/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.h
index 2d19ece4aa7fc9a441f7246d8401b155f4ea22a7..af2680a194b31cb6d184cb36bd8e9d5a66d258d1 100644
--- a/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.h
+++ b/datamgr_service/services/distributeddataservice/service/cloud/sync_strategies/network_sync_strategy.h
@@ -36,16 +36,18 @@ public:
         bool Unmarshal(const json &node) override;
         std::string GetKey();
         static constexpr int32_t INVALID_USER = -1;
+        static constexpr int32_t ROOT_USER = 0;
         static constexpr const char *PREFIX = "NETWORK_SYNC_STRATEGY";
     };
     NetworkSyncStrategy();
     ~NetworkSyncStrategy();
-    int32_t CheckSyncAction(const StoreInfo& storeInfo) override;
+    int32_t CheckSyncAction(const StoreInfo &storeInfo) override;
 
     static std::string GetKey(int32_t user);
-    static std::string GetKey(int32_t user, const std::string& bundleName);
+    static std::string GetKey(int32_t user, const std::string &bundleName);
+
 private:
-    StrategyInfo GetStrategy(int32_t user, const std::string& bundleName);
+    StrategyInfo GetStrategy(int32_t user, const std::string &bundleName);
 
     static bool Check(uint32_t strategy);
     static constexpr uint32_t DEFAULT_STRATEGY = WIFI | CELLULAR;
@@ -53,5 +55,5 @@ private:
     int32_t user_ = -1;
     ConcurrentMap<std::string, StrategyInfo> strategies_;
 };
-}
-#endif //OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_NETWORK_SYNC_STRATEGY_H
+} // namespace OHOS::CloudData
+#endif //OHOS_DISTRIBUTED_DATA_SERVICES_CLOUD_NETWORK_SYNC_STRATEGY_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/config/include/config_factory.h b/datamgr_service/services/distributeddataservice/service/config/include/config_factory.h
index e6e4025c67e930ead2e48498875bb0aeb4d677ac..6ebb1e0db025495eb261667e8bbb23d845dc8466 100644
--- a/datamgr_service/services/distributeddataservice/service/config/include/config_factory.h
+++ b/datamgr_service/services/distributeddataservice/service/config/include/config_factory.h
@@ -31,6 +31,7 @@ public:
     API_EXPORT DirectoryConfig *GetDirectoryConfig();
     API_EXPORT BackupConfig *GetBackupConfig();
     API_EXPORT CloudConfig *GetCloudConfig();
+    API_EXPORT std::vector<AppIdMappingConfig> *GetAppIdMappingConfig();
 private:
     static constexpr const char *CONF_PATH = "/system/etc/distributeddata/conf";
     ConfigFactory();
diff --git a/datamgr_service/services/distributeddataservice/service/config/include/model/app_id_mapping_config.h b/datamgr_service/services/distributeddataservice/service/config/include/model/app_id_mapping_config.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0ff96a34640a66077dc4b268ec1359c860ca7bb
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/config/include/model/app_id_mapping_config.h
@@ -0,0 +1,30 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#ifndef OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_APP_ID_MAPPING_CONFIG_H
+#define OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_APP_ID_MAPPING_CONFIG_H
+
+#include "serializable/serializable.h"
+namespace OHOS {
+namespace DistributedData {
+class AppIdMappingConfig final : public Serializable {
+public:
+    std::string srcAppId = "";
+    std::string dstAppId = "";
+    bool Marshal(json &node) const override;
+    bool Unmarshal(const json &node) override;
+};
+} // namespace DistributedData
+} // namespace OHOS
+#endif //OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_APP_ID_MAPPING_CONFIG_H
diff --git a/datamgr_service/services/distributeddataservice/service/config/include/model/global_config.h b/datamgr_service/services/distributeddataservice/service/config/include/model/global_config.h
index c96926e4f5e7d458e058ccf6ef5e73f794743bda..0d974d5bec9b6930904aaa3bbd1a2f962593fa5c 100644
--- a/datamgr_service/services/distributeddataservice/service/config/include/model/global_config.h
+++ b/datamgr_service/services/distributeddataservice/service/config/include/model/global_config.h
@@ -22,6 +22,7 @@
 #include "model/network_config.h"
 #include "model/directory_config.h"
 #include "model/backup_config.h"
+#include "model/app_id_mapping_config.h"
 namespace OHOS {
 namespace DistributedData {
 class GlobalConfig final : public Serializable {
@@ -36,6 +37,7 @@ public:
     DirectoryConfig *directory = nullptr;
     BackupConfig *backup = nullptr;
     CloudConfig *cloud = nullptr;
+    std::vector<AppIdMappingConfig> *appIdMapping = nullptr;
     ~GlobalConfig();
     bool Marshal(json &node) const override;
     bool Unmarshal(const json &node) override;
diff --git a/datamgr_service/services/distributeddataservice/service/config/src/config_factory.cpp b/datamgr_service/services/distributeddataservice/service/config/src/config_factory.cpp
index 733ab0ea95a4eb88e4933481456035b40595c4fa..996f6e585bde9141a1a0e956860a1cb16ad0d99a 100644
--- a/datamgr_service/services/distributeddataservice/service/config/src/config_factory.cpp
+++ b/datamgr_service/services/distributeddataservice/service/config/src/config_factory.cpp
@@ -82,5 +82,10 @@ CloudConfig *ConfigFactory::GetCloudConfig()
 {
     return config_.cloud;
 }
+
+std::vector<AppIdMappingConfig> *ConfigFactory::GetAppIdMappingConfig()
+{
+    return config_.appIdMapping;
+}
 } // namespace DistributedData
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/config/src/model/app_id_mapping_config.cpp b/datamgr_service/services/distributeddataservice/service/config/src/model/app_id_mapping_config.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..001336e61e656c721499af1ce77c3bd6839882d9
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/config/src/model/app_id_mapping_config.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "model/app_id_mapping_config.h"
+namespace OHOS {
+namespace DistributedData {
+bool AppIdMappingConfig::Marshal(Serializable::json &node) const
+{
+    SetValue(node[GET_NAME(srcAppId)], srcAppId);
+    SetValue(node[GET_NAME(dstAppId)], dstAppId);
+    return true;
+}
+bool AppIdMappingConfig::Unmarshal(const Serializable::json &node)
+{
+    GetValue(node, GET_NAME(srcAppId), srcAppId);
+    GetValue(node, GET_NAME(dstAppId), dstAppId);
+    return true;
+}
+} // namespace DistributedData
+} // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/config/src/model/global_config.cpp b/datamgr_service/services/distributeddataservice/service/config/src/model/global_config.cpp
index b3078891e9d5fb031ac1ba036e560ad8ec2722b8..d4ee79710b9cedcc9f8581b168b2d3301693c135 100644
--- a/datamgr_service/services/distributeddataservice/service/config/src/model/global_config.cpp
+++ b/datamgr_service/services/distributeddataservice/service/config/src/model/global_config.cpp
@@ -28,6 +28,7 @@ bool GlobalConfig::Marshal(json &node) const
     SetValue(node[GET_NAME(directory)], directory);
     SetValue(node[GET_NAME(backup)], backup);
     SetValue(node[GET_NAME(cloud)], cloud);
+    SetValue(node[GET_NAME(appIdMapping)], appIdMapping);
     return true;
 }
 
@@ -43,6 +44,7 @@ bool GlobalConfig::Unmarshal(const json &node)
     GetValue(node, GET_NAME(directory), directory);
     GetValue(node, GET_NAME(backup), backup);
     GetValue(node, GET_NAME(cloud), cloud);
+    GetValue(node, GET_NAME(appIdMapping), appIdMapping);
     return true;
 }
 
@@ -54,6 +56,7 @@ GlobalConfig::~GlobalConfig()
     delete directory;
     delete backup;
     delete cloud;
+    delete appIdMapping;
 }
 } // namespace DistributedData
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.cpp
index a54df9368b081e4aea4edbd611d330dc4b30d0e4..dec8551caa0b349d709dd9a97ff697e9fdc60dc4 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.cpp
@@ -16,11 +16,13 @@
 #include "bundle_mgr_proxy.h"
 
 #include "account/account_delegate.h"
+#include "datashare_errno.h"
 #include "datashare_radar_reporter.h"
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
 #include "log_print.h"
 #include "system_ability_definition.h"
+#include "uri_utils.h"
 
 namespace OHOS::DataShare {
 sptr<AppExecFwk::BundleMgrProxy> BundleMgrProxy::GetBundleMgrProxy()
@@ -59,32 +61,39 @@ sptr<IRemoteObject> BundleMgrProxy::CheckBMS()
     return systemAbilityManager->CheckSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
 }
 
-bool BundleMgrProxy::GetBundleInfoFromBMS(
-    const std::string &bundleName, int32_t userId, AppExecFwk::BundleInfo &bundleInfo)
+int BundleMgrProxy::GetBundleInfoFromBMS(
+    const std::string &bundleName, int32_t userId, BundleConfig &bundleConfig)
 {
     auto bundleKey = bundleName + std::to_string(userId);
     auto it = bundleCache_.Find(bundleKey);
     if (it.first) {
-        bundleInfo = it.second;
-        return true;
+        bundleConfig = it.second;
+        return E_OK;
     }
     auto bmsClient = GetBundleMgrProxy();
     if (bmsClient == nullptr) {
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::GET_BMS,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::GET_BMS_FAILED);
         ZLOGE("GetBundleMgrProxy is nullptr!");
-        return false;
+        return E_BMS_NOT_READY;
     }
+    AppExecFwk::BundleInfo bundleInfo;
     bool ret = bmsClient->GetBundleInfo(
         bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO, bundleInfo, userId);
     if (!ret) {
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::GET_BMS,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::GET_BUNDLE_INFP_FAILED);
         ZLOGE("GetBundleInfo failed!bundleName is %{public}s, userId is %{public}d", bundleName.c_str(), userId);
-        return false;
+        return E_BUNDLE_NAME_NOT_EXIST;
     }
-    bundleCache_.Insert(bundleKey, bundleInfo);
-    return true;
+    auto [errCode, bundle] = ConvertToDataShareBundle(bundleInfo);
+    if (errCode != E_OK) {
+        ZLOGE("Profile Unmarshall failed! bundleName:%{public}s", URIUtils::Anonymous(bundle.name).c_str());
+        return errCode;
+    }
+    bundleConfig = bundle;
+    bundleCache_.Insert(bundleKey, bundle);
+    return E_OK;
 }
 
 void BundleMgrProxy::OnProxyDied()
@@ -117,4 +126,92 @@ std::shared_ptr<BundleMgrProxy> BundleMgrProxy::GetInstance()
     static std::shared_ptr<BundleMgrProxy> proxy(new BundleMgrProxy());
     return proxy;
 }
+
+std::pair<int, BundleConfig> BundleMgrProxy::ConvertToDataShareBundle(AppExecFwk::BundleInfo &bundleInfo)
+{
+    BundleConfig bundleConfig;
+    bundleConfig.name = std::move(bundleInfo.name);
+    bundleConfig.singleton = std::move(bundleInfo.singleton);
+    auto [errCode, hapModuleInfos] = ConvertHapModuleInfo(bundleInfo);
+    if (errCode != E_OK) {
+        return std::make_pair(errCode, bundleConfig);
+    }
+    bundleConfig.hapModuleInfos = hapModuleInfos;
+
+    auto [err, extensionInfos] = ConvertExtensionAbility(bundleInfo);
+    if (err != E_OK) {
+        return std::make_pair(err, bundleConfig);
+    }
+    bundleConfig.extensionInfos = extensionInfos;
+    return std::make_pair(E_OK, bundleConfig);
+}
+
+std::pair<int, std::vector<ExtensionAbilityInfo>> BundleMgrProxy::ConvertExtensionAbility(
+    AppExecFwk::BundleInfo &bundleInfo)
+{
+    std::vector<ExtensionAbilityInfo> extensionInfos;
+    for (auto &item : bundleInfo.extensionInfos) {
+        if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
+            continue;
+        }
+        ExtensionAbilityInfo extensionInfo;
+        extensionInfo.type = std::move(item.type);
+        extensionInfo.readPermission = std::move(item.readPermission);
+        extensionInfo.writePermission = std::move(item.writePermission);
+        extensionInfo.uri = std::move(item.uri);
+        extensionInfo.resourcePath = std::move(item.resourcePath);
+        extensionInfo.hapPath = std::move(item.hapPath);
+        ProfileConfig profileConfig;
+        auto [ret, profileInfo] = DataShareProfileConfig::GetDataProperties(
+            item.metadata, extensionInfo.resourcePath, extensionInfo.hapPath, DATA_SHARE_EXTENSION_META);
+        if (ret == NOT_FOUND) {
+            profileConfig.resultCode = NOT_FOUND;
+        }
+        if (ret == ERROR) {
+            profileConfig.resultCode = ERROR;
+            ZLOGE("Profile unmarshall error.uri: %{public}s", URIUtils::Anonymous(extensionInfo.uri).c_str());
+            return std::make_pair(E_ERROR, extensionInfos);
+        }
+        profileConfig.profile = profileInfo;
+        extensionInfo.profileInfo = profileConfig;
+        extensionInfos.emplace_back(extensionInfo);
+    }
+    return std::make_pair(E_OK, extensionInfos);
+}
+
+std::pair<int, std::vector<HapModuleInfo>> BundleMgrProxy::ConvertHapModuleInfo(AppExecFwk::BundleInfo &bundleInfo)
+{
+    std::vector<HapModuleInfo> hapModuleInfos;
+    for (auto &item : bundleInfo.hapModuleInfos) {
+        HapModuleInfo hapModuleInfo;
+        hapModuleInfo.resourcePath = std::move(item.resourcePath);
+        hapModuleInfo.hapPath = std::move(item.hapPath);
+        hapModuleInfo.moduleName = std::move(item.moduleName);
+        std::vector<ProxyData> proxyDatas;
+        for (auto &proxyData : item.proxyDatas) {
+            ProxyData data;
+            data.uri = std::move(proxyData.uri);
+            data.requiredReadPermission = std::move(proxyData.requiredReadPermission);
+            data.requiredWritePermission = std::move(proxyData.requiredWritePermission);
+            ProfileConfig profileConfig;
+            auto [ret, profileInfo] = DataShareProfileConfig::GetDataProperties(
+                std::vector<AppExecFwk::Metadata>{proxyData.metadata}, hapModuleInfo.resourcePath,
+                hapModuleInfo.hapPath, DATA_SHARE_PROPERTIES_META);
+            if (ret == NOT_FOUND) {
+                profileConfig.resultCode = NOT_FOUND;
+            }
+            if (ret == ERROR) {
+                profileConfig.resultCode = ERROR;
+                ZLOGE("Profile unmarshall error.uri: %{public}s", URIUtils::Anonymous(data.uri).c_str());
+                return std::make_pair(E_ERROR, hapModuleInfos);
+            }
+            profileConfig.profile = profileInfo;
+            data.profileInfo = profileConfig;
+            proxyDatas.emplace_back(data);
+        }
+        hapModuleInfo.proxyDatas = proxyDatas;
+        hapModuleInfos.emplace_back(hapModuleInfo);
+    }
+    return std::make_pair(E_OK, hapModuleInfos);
+}
 } // namespace OHOS::DataShare
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.h b/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.h
index a41374053ddcccc3d3fd68b5de122b14f083383c..9b4b325cac565a22567387de6bb53d57d6a3b898 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/bundle_mgr_proxy.h
@@ -22,12 +22,50 @@
 #include "bundle_info.h"
 #include "bundlemgr/bundle_mgr_proxy.h"
 #include "concurrent_map.h"
+#include "data_share_profile_config.h"
+
 namespace OHOS::DataShare {
+struct ProfileConfig {
+    ProfileInfo profile;
+    int resultCode = 0;
+};
+
+struct ProxyData {
+    std::string uri;
+    std::string requiredReadPermission;
+    std::string requiredWritePermission;
+    ProfileConfig profileInfo;
+};
+
+struct HapModuleInfo {
+    std::string resourcePath;
+    std::string hapPath;
+    std::string moduleName;
+    std::vector<ProxyData> proxyDatas;
+};
+
+struct ExtensionAbilityInfo {
+    AppExecFwk::ExtensionAbilityType type = AppExecFwk::ExtensionAbilityType::UNSPECIFIED;
+    std::string readPermission;
+    std::string writePermission;
+    std::string uri;
+    std::string resourcePath;
+    std::string hapPath;
+    ProfileConfig profileInfo;
+};
+
+struct BundleConfig {
+    std::string name;
+    bool singleton = false;
+    std::vector<HapModuleInfo> hapModuleInfos;
+    std::vector<ExtensionAbilityInfo> extensionInfos;
+};
+
 class BundleMgrProxy final : public std::enable_shared_from_this<BundleMgrProxy> {
 public:
     ~BundleMgrProxy();
     static std::shared_ptr<BundleMgrProxy> GetInstance();
-    bool GetBundleInfoFromBMS(const std::string &bundleName, int32_t userId, AppExecFwk::BundleInfo &bundleInfo);
+    int GetBundleInfoFromBMS(const std::string &bundleName, int32_t userId, BundleConfig &bundleConfig);
     void Delete(const std::string &bundleName, int32_t userId);
     sptr<IRemoteObject> CheckBMS();
 
@@ -49,10 +87,15 @@ private:
     };
     sptr<AppExecFwk::BundleMgrProxy> GetBundleMgrProxy();
     void OnProxyDied();
+    std::pair<int, BundleConfig> ConvertToDataShareBundle(AppExecFwk::BundleInfo &bundleInfo);
+    std::pair<int, std::vector<ExtensionAbilityInfo>> ConvertExtensionAbility(AppExecFwk::BundleInfo &bundleInfo);
+    std::pair<int, std::vector<HapModuleInfo>> ConvertHapModuleInfo(AppExecFwk::BundleInfo &bundleInfo);
     std::mutex mutex_;
     sptr<IRemoteObject> proxy_;
     sptr<BundleMgrProxy::ServiceDeathRecipient> deathRecipient_;
-    ConcurrentMap<std::string, AppExecFwk::BundleInfo> bundleCache_;
+    ConcurrentMap<std::string, BundleConfig> bundleCache_;
+    static constexpr const char *DATA_SHARE_EXTENSION_META = "ohos.extension.dataShare";
+    static constexpr const char *DATA_SHARE_PROPERTIES_META = "dataProperties";
 };
 } // namespace OHOS::DataShare
 #endif // DATASHARESERVICE_BUNDLEMGR_PROXY_H
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/context.h b/datamgr_service/services/distributeddataservice/service/data_share/common/context.h
index e347eb03aef9f87265a9279214c5c6b35aa2e47f..25995eaa064c8741f80251cfc2e80874f6fa15d8 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/context.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/context.h
@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-#include "bundle_info.h"
+#include "bundle_mgr_proxy.h"
 
 namespace OHOS::DataShare {
 enum AccessSystemMode : uint8_t {
@@ -53,7 +53,7 @@ public:
     bool needAutoLoadCallerBundleName = false;
     bool isEncryptDb = false;
     AccessSystemMode accessSystemMode = AccessSystemMode::UNDEFINED;
-    OHOS::AppExecFwk::BundleInfo bundleInfo;
+    BundleConfig bundleInfo;
     std::string type = "rdb";
 };
 } // namespace OHOS::DataShare
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.cpp
index 84b9b54437f33dec0edcd422f3407bf06e7341b1..f9ba94f047fb3fd9eef242af3d1c578f67f7d681 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.cpp
@@ -20,9 +20,89 @@
 #include "log_print.h"
 #include "rdb_delegate.h"
 namespace OHOS::DataShare {
-std::shared_ptr<DBDelegate> DBDelegate::Create(DistributedData::StoreMetaData &metaData)
+ExecutorPool::TaskId DBDelegate::taskId_ = ExecutorPool::INVALID_TASK_ID;
+ConcurrentMap<uint32_t, std::map<std::string, std::shared_ptr<DBDelegate::Entity>>> DBDelegate::stores_ = {};
+std::shared_ptr<ExecutorPool> DBDelegate::executor_ = nullptr;
+std::shared_ptr<DBDelegate> DBDelegate::Create(DistributedData::StoreMetaData &metaData,
+    const std::string &extUri, const std::string &backup)
 {
-    return std::make_shared<RdbDelegate>(metaData, NO_CHANGE_VERSION, true);
+    if (metaData.tokenId == 0) {
+        return std::make_shared<RdbDelegate>(metaData, NO_CHANGE_VERSION, true, extUri, backup);
+    }
+    std::shared_ptr<DBDelegate> store;
+    stores_.Compute(metaData.tokenId,
+        [&metaData, &store, extUri, &backup](auto &, std::map<std::string, std::shared_ptr<Entity>> &stores) -> bool {
+            auto it = stores.find(metaData.storeId);
+            if (it != stores.end()) {
+                store = it->second->store_;
+                it->second->time_ = std::chrono::steady_clock::now() + std::chrono::seconds(INTERVAL);
+                return !stores.empty();
+            }
+            store = std::make_shared<RdbDelegate>(metaData, NO_CHANGE_VERSION, true, extUri, backup);
+            if (store->IsInvalid()) {
+                store = nullptr;
+                ZLOGE("creator failed, storeName: %{public}s", metaData.GetStoreAlias().c_str());
+                return false;
+            }
+            auto entity = std::make_shared<Entity>(store);
+            stores.emplace(metaData.storeId, entity);
+            StartTimer();
+            return !stores.empty();
+        });
+    return store;
+}
+
+void DBDelegate::SetExecutorPool(std::shared_ptr<ExecutorPool> executor)
+{
+    executor_ = std::move(executor);
+}
+
+void DBDelegate::GarbageCollect()
+{
+    stores_.EraseIf([](auto &, std::map<std::string, std::shared_ptr<Entity>> &stores) {
+        auto current = std::chrono::steady_clock::now();
+        for (auto it = stores.begin(); it != stores.end();) {
+            // if the store is BUSY we wait more INTERVAL minutes again
+            if (it->second->time_ < current) {
+                it = stores.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        return stores.empty();
+    });
+}
+
+void DBDelegate::StartTimer()
+{
+    if (executor_ == nullptr || taskId_ != Executor::INVALID_TASK_ID) {
+        return;
+    }
+    taskId_ = executor_->Schedule(
+        []() {
+            GarbageCollect();
+            stores_.DoActionIfEmpty([]() {
+                if (executor_ == nullptr || taskId_ == Executor::INVALID_TASK_ID) {
+                    return;
+                }
+                executor_->Remove(taskId_);
+                ZLOGD("remove timer, taskId: %{public}" PRIu64, taskId_);
+                taskId_ = Executor::INVALID_TASK_ID;
+            });
+        },
+        std::chrono::seconds(INTERVAL), std::chrono::seconds(INTERVAL));
+    ZLOGD("start timer, taskId: %{public}" PRIu64, taskId_);
+}
+
+DBDelegate::Entity::Entity(std::shared_ptr<DBDelegate> store)
+{
+    store_ = std::move(store);
+    time_ = std::chrono::steady_clock::now() + std::chrono::seconds(INTERVAL);
+}
+
+void DBDelegate::EraseStoreCache(const int32_t tokenId)
+{
+    stores_.Erase(tokenId);
 }
 
 std::shared_ptr<KvDBDelegate> KvDBDelegate::GetInstance(
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.h b/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.h
index 99f13253ce97be11c1526eead9f60ba1a4f59155..18e4052373940a080830a7a98c574bf72dc35a6a 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/db_delegate.h
@@ -31,19 +31,37 @@
 namespace OHOS::DataShare {
 class DBDelegate {
 public:
-    static std::shared_ptr<DBDelegate> Create(DistributedData::StoreMetaData &metaData);
-    virtual int64_t Insert(const std::string &tableName, const DataShareValuesBucket &valuesBucket) = 0;
-    virtual int64_t Update(const std::string &tableName, const DataSharePredicates &predicate,
-        const DataShareValuesBucket &valuesBucket) = 0;
-    virtual int64_t Delete(const std::string &tableName, const DataSharePredicates &predicate) = 0;
+    using Time = std::chrono::steady_clock::time_point;
+    static std::shared_ptr<DBDelegate> Create(DistributedData::StoreMetaData &metaData,
+        const std::string &extUri = "", const std::string &backup = "");
     virtual std::pair<int, std::shared_ptr<DataShareResultSet>> Query(const std::string &tableName,
         const DataSharePredicates &predicates, const std::vector<std::string> &columns,
         const int32_t callingPid) = 0;
     virtual std::string Query(
         const std::string &sql, const std::vector<std::string> &selectionArgs = std::vector<std::string>()) = 0;
     virtual std::shared_ptr<NativeRdb::ResultSet> QuerySql(const std::string &sql) = 0;
+    virtual bool IsInvalid() = 0;
+    static void SetExecutorPool(std::shared_ptr<ExecutorPool> executor);
+    static void EraseStoreCache(const int32_t tokenId);
+    virtual std::pair<int64_t, int64_t> InsertEx(const std::string &tableName,
+        const DataShareValuesBucket &valuesBucket) = 0;
+    virtual std::pair<int64_t, int64_t> UpdateEx(const std::string &tableName,
+        const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket) = 0;
+    virtual std::pair<int64_t, int64_t> DeleteEx(const std::string &tableName,
+        const DataSharePredicates &predicate) = 0;
 private:
+    static void GarbageCollect();
+    static void StartTimer();
+    struct Entity {
+        explicit Entity(std::shared_ptr<DBDelegate> store);
+        std::shared_ptr<DBDelegate> store_;
+        Time time_;
+    };
     static constexpr int NO_CHANGE_VERSION = -1;
+    static constexpr int64_t INTERVAL = 20; //seconds
+    static ConcurrentMap<uint32_t, std::map<std::string, std::shared_ptr<Entity>>> stores_;
+    static std::shared_ptr<ExecutorPool> executor_;
+    static ExecutorPool::TaskId taskId_;
 };
 
 class Id : public DistributedData::Serializable {
@@ -107,6 +125,7 @@ public:
         std::string &result) = 0;
     virtual int32_t GetBatch(const std::string &collectionName, const std::string &filter,
         const std::string &projection, std::vector<std::string> &result) = 0;
+    virtual void NotifyBackup() = 0;
 };
 } // namespace OHOS::DataShare
 #endif // DATASHARESERVICE_DB_DELEGATE_H
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.cpp
index 8a7c7f388c33d92c22ff14c4e8235419fd4e6c4f..2328285df370c1f67f2b2bcc51788ba1d3e28416 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.cpp
@@ -34,7 +34,7 @@ void ExtensionAbilityManager::SetExecutorPool(std::shared_ptr<ExecutorPool> exec
 }
 
 int32_t ExtensionAbilityManager::ConnectExtension(const std::string &uri, const std::string &bundleName,
-    const sptr<IRemoteObject> &callback)
+    const sptr<IRemoteObject> &callback, AAFwk::WantParams &wantParams)
 {
     auto absent = connectCallbackCache_.ComputeIfAbsent(bundleName, [callback](const std::string &) {
         return std::move(callback);
@@ -44,32 +44,38 @@ int32_t ExtensionAbilityManager::ConnectExtension(const std::string &uri, const
             bundleName.c_str(), URIUtils::Anonymous(uri).c_str());
         return E_ERROR;
     }
-    ErrCode ret = ExtensionMgrProxy::GetInstance()->Connect(uri, callback, nullptr);
+    ErrCode ret = ExtensionMgrProxy::GetInstance()->Connect(uri, callback, nullptr, wantParams);
     if (ret != E_OK) {
         ZLOGE("Connect ability failed, ret:%{public}d, uri:%{public}s, bundleName:%{public}s",
             ret, URIUtils::Anonymous(uri).c_str(), bundleName.c_str());
         connectCallbackCache_.Erase(bundleName);
         return E_ERROR;
     }
+    Disconnect(bundleName, MAX_WAIT_DISCONNECT_TIME);
     return E_OK;
 }
 
 void ExtensionAbilityManager::DelayDisconnect(const std::string &bundleName)
 {
-    executor_->Schedule(std::chrono::seconds(WAIT_DISCONNECT_TIME), [bundleName, this]() {
+    Disconnect(bundleName, WAIT_DISCONNECT_TIME);
+}
+
+void ExtensionAbilityManager::Disconnect(const std::string &bundleName, int time)
+{
+    executor_->Schedule(std::chrono::seconds(time), [bundleName, this]() {
         ZLOGI("Delay disconnect %{public}s", bundleName.c_str());
-        connectCallbackCache_.ComputeIfPresent(bundleName, [bundleName](const std::string &,
-            sptr<IRemoteObject> &disconnect) {
-            if (disconnect == nullptr) {
-                ZLOGI("Delay disconnect nullptr %{public}s", bundleName.c_str());
+        connectCallbackCache_.ComputeIfPresent(bundleName,
+            [bundleName](const std::string &, sptr<IRemoteObject> &disconnect) {
+                if (disconnect == nullptr) {
+                    ZLOGI("Delay disconnect nullptr %{public}s", bundleName.c_str());
+                    return false;
+                }
+                auto ret = ExtensionMgrProxy::GetInstance()->DisConnect(disconnect);
+                if (ret != E_OK) {
+                    ZLOGE("Delay disConnect failed bundleName: %{public}s, ret: %{public}d", bundleName.c_str(), ret);
+                }
                 return false;
-            }
-            auto ret = ExtensionMgrProxy::GetInstance()->DisConnect(disconnect);
-            if (ret != E_OK) {
-                ZLOGE("Delay disConnect failed bundleName: %{public}s, ret: %{public}d", bundleName.c_str(), ret);
-            }
-            return false;
-        });
+            });
     });
 }
 } // namespace OHOS::DataShare
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.h b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.h
index 0640fa6e823c683d0aaea94efcbd767131ae0873..a78e4e20cac0d275089080e5fe3f088161cede3d 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_ability_manager.h
@@ -19,6 +19,7 @@
 #include "concurrent_map.h"
 #include "executor_pool.h"
 #include "iremote_object.h"
+#include "want.h"
 
 namespace OHOS::DataShare {
 class ExtensionAbilityManager {
@@ -26,13 +27,15 @@ public:
     static ExtensionAbilityManager &GetInstance();
     void SetExecutorPool(std::shared_ptr<ExecutorPool> executor);
     int32_t ConnectExtension(const std::string &uri, const std::string &bundleName,
-        const sptr<IRemoteObject> &callback);
+        const sptr<IRemoteObject> &callback, AAFwk::WantParams &wantParams);
     void DelayDisconnect(const std::string &bundleName);
 
 private:
+    void Disconnect(const std::string &bundleName, int time);
     std::shared_ptr<ExecutorPool> executor_ = nullptr;
     ConcurrentMap<std::string, sptr<IRemoteObject>> connectCallbackCache_;
     static constexpr int WAIT_DISCONNECT_TIME = 5;
+    static constexpr int MAX_WAIT_DISCONNECT_TIME = 30;
 };
 } // namespace OHOS::DataShare
 #endif // DATASHARESERVICE_EXTENSION_ABILITY_MANAGER_H
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.cpp
index 9256abd3defb0b6d761e2992f93707538d078954..6a48232a4598c1175220a89d5797bccdf2429b38 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.cpp
@@ -32,13 +32,15 @@ ExtensionConnectAdaptor::ExtensionConnectAdaptor() : data_(std::make_shared<Bloc
     callback_ = new (std::nothrow) CallbackImpl(data_);
 }
 
-bool ExtensionConnectAdaptor::DoConnect(const std::string &uri, const std::string &bundleName)
+bool ExtensionConnectAdaptor::DoConnect(const std::string &uri, const std::string &bundleName,
+    AAFwk::WantParams &wantParams)
 {
     data_->Clear();
     if (callback_ == nullptr) {
         return false;
     }
-    ErrCode ret = ExtensionAbilityManager::GetInstance().ConnectExtension(uri, bundleName, callback_->AsObject());
+    ErrCode ret = ExtensionAbilityManager::GetInstance().ConnectExtension(uri, bundleName,
+        callback_->AsObject(), wantParams);
     if (ret != ERR_OK) {
         ZLOGE("connect ability failed, ret = %{public}d, uri: %{public}s", ret,
             URIUtils::Anonymous(uri).c_str());
@@ -51,13 +53,13 @@ bool ExtensionConnectAdaptor::DoConnect(const std::string &uri, const std::strin
 }
 
 bool ExtensionConnectAdaptor::TryAndWait(const std::string &uri, const std::string &bundleName,
-    int maxWaitTime)
+    AAFwk::WantParams &wantParams, int maxWaitTime)
 {
     ExtensionConnectAdaptor strategy;
     return AppConnectManager::Wait(
         bundleName, maxWaitTime,
-        [&uri, &bundleName, &strategy]() {
-            return strategy.DoConnect(uri, bundleName);
+        [&uri, &bundleName, &strategy, &wantParams]() {
+            return strategy.DoConnect(uri, bundleName, wantParams);
         },
         [&strategy]() {
             strategy.Disconnect();
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.h b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.h
index e36d61ed694c170175b0770716cd726229aaa82c..ad585d10a1b3f9b03977b628b86ccb7e12a39d0b 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_connect_adaptor.h
@@ -19,15 +19,16 @@
 #include "ability_connect_callback_interface.h"
 #include "block_data.h"
 #include "context.h"
+#include "want.h"
 namespace OHOS::DataShare {
 class ExtensionConnectAdaptor {
 public:
-    static bool TryAndWait(const std::string &uri, const std::string &bundleName,
+    static bool TryAndWait(const std::string &uri, const std::string &bundleName, AAFwk::WantParams &wantParams,
         int maxWaitTime = 2);
     ExtensionConnectAdaptor();
 private:
     void Disconnect();
-    bool DoConnect(const std::string &uri, const std::string &bundleName);
+    bool DoConnect(const std::string &uri, const std::string &bundleName, AAFwk::WantParams &wantParams);
     std::shared_ptr<BlockData<bool>> data_;
     sptr<AAFwk::IAbilityConnection> callback_ = nullptr;
 };
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.cpp
index 3303346e9a23b2e79349a56551d811950e7938d9..1d7f44d10edfe8e256e7b60eab7e9d995254ea43 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.cpp
@@ -49,10 +49,12 @@ std::shared_ptr<ExtensionMgrProxy> ExtensionMgrProxy::GetInstance()
 }
 
 int ExtensionMgrProxy::Connect(
-    const std::string &uri, const sptr<IRemoteObject> &connect, const sptr<IRemoteObject> &callerToken)
+    const std::string &uri, const sptr<IRemoteObject> &connect, const sptr<IRemoteObject> &callerToken,
+    AAFwk::WantParams &wantParams)
 {
     AAFwk::Want want;
     want.SetUri(uri);
+    want.SetParams(wantParams);
     std::lock_guard<std::mutex> lock(mutex_);
     if (ConnectSA()) {
         int ret = proxy_->ConnectAbilityCommon(want, connect, callerToken, AppExecFwk::ExtensionAbilityType::DATASHARE);
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.h b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.h
index a93a4c903b98086b7cc028f0770c495708d40217..21bda2ddb44049777f2843c05e6edc56e25f2309 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/extension_mgr_proxy.h
@@ -20,6 +20,7 @@
 #include <string>
 
 #include "extension_manager_proxy.h"
+#include "want.h"
 namespace OHOS::DataShare {
 class ExtensionMgrProxy final : public std::enable_shared_from_this<ExtensionMgrProxy> {
 public:
@@ -27,7 +28,8 @@ public:
     ExtensionMgrProxy() = default;
     ~ExtensionMgrProxy();
     static std::shared_ptr<ExtensionMgrProxy> GetInstance();
-    int Connect(const std::string &uri, const sptr<IRemoteObject> &connect, const sptr<IRemoteObject> &callerToken);
+    int Connect(const std::string &uri, const sptr<IRemoteObject> &connect,
+        const sptr<IRemoteObject> &callerToken, AAFwk::WantParams &wantParams);
     int DisConnect(sptr<IRemoteObject> connect);
 private:
     using Proxy = AAFwk::ExtensionManagerProxy;
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.cpp
index 9e36164adaed8b19c14a2ccf6743d041f5f5cc3a..23aa6a6119c406daf5700de16df913598af56b33 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -13,6 +13,12 @@
  * limitations under the License.
  */
 #define LOG_TAG "KvAdaptor"
+
+#include <cstddef>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
 #include "kv_delegate.h"
 
 #include "datashare_errno.h"
@@ -24,6 +30,103 @@
 
 namespace OHOS::DataShare {
 constexpr int WAIT_TIME = 30;
+
+// If using multi-process access, back up dataShare.db.map as well. Check config file to see whether
+// using multi-process maccess
+const char* g_backupFiles[] = {
+    "dataShare.db",
+    "dataShare.db.redo",
+    "dataShare.db.safe",
+    "dataShare.db.undo",
+};
+const char* BACKUP_SUFFIX = ".backup";
+
+// If isBackUp is true, remove db backup files. Otherwise remove source db files.
+void KvDelegate::RemoveDbFile(bool isBackUp)
+{
+    for (auto &fileName: g_backupFiles) {
+        std::string dbPath = path_ + "/" + fileName;
+        if (isBackUp) {
+            dbPath += BACKUP_SUFFIX;
+        }
+        if (std::filesystem::exists(dbPath)) {
+            std::error_code ec;
+            bool success = std::filesystem::remove(dbPath, ec);
+            if (!success) {
+                ZLOGE("failed to remove file %{public}s, err: %{public}s", fileName, ec.message().c_str());
+            }
+        }
+    }
+}
+
+bool KvDelegate::CopyFile(bool isBackup)
+{
+    std::filesystem::copy_options options = std::filesystem::copy_options::overwrite_existing;
+    std::error_code code;
+    bool ret = true;
+    for (auto &fileName : g_backupFiles) {
+        std::string src = path_ + "/" + fileName;
+        std::string dst = src;
+        isBackup ? dst.append(BACKUP_SUFFIX) : src.append(BACKUP_SUFFIX);
+        // If src doesn't exist, error will be returned through `std::error_code`
+        bool copyRet = std::filesystem::copy_file(src, dst, options, code);
+        if (!copyRet) {
+            ZLOGE("failed to copy file %{public}s, isBackup %{public}d, err: %{public}s",
+                fileName, isBackup, code.message().c_str());
+            ret = false;
+            RemoveDbFile(isBackup);
+            break;
+        }
+    }
+    return ret;
+}
+
+// Restore database data when it is broken somehow. Some failure of insertion / deletion / updates will be considered
+// as database files damage, and therefore trigger the process of restoration.
+void KvDelegate::Restore()
+{
+    // No need to lock because this inner method will only be called when upper methods lock up
+    CopyFile(false);
+    ZLOGD("finish restoring kv");
+}
+
+// Backup database data by copying its key files. This mechanism might be costly, but acceptable when updating
+// contents of KV database happens not so frequently now.
+void KvDelegate::Backup()
+{
+    // No need to lock because this inner method will only be called when upper methods lock up
+    ZLOGD("backup kv");
+    if (hasChange_) {
+        CopyFile(true);
+        hasChange_ = false;
+    }
+    ZLOGD("finish backing up kv");
+}
+
+// Set hasChange_ to true. Caller can use this to control when to back up db.
+void OHOS::DataShare::KvDelegate::NotifyBackup()
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    hasChange_ = true;
+}
+
+// The return val indicates whether the database has been restored
+bool KvDelegate::RestoreIfNeed(int32_t dbStatus)
+{
+    // No need to lock because this inner method will only be called when upper methods lock up
+    if (dbStatus == GRD_INVALID_FILE_FORMAT || dbStatus == GRD_REBUILD_DATABASE) {
+        if (db_ != NULL) {
+            GRD_DBClose(db_, GRD_DB_CLOSE);
+            db_ = nullptr;
+            isInitDone_ = false;
+        }
+        // If db is NULL, it has been closed.
+        Restore();
+        return true;
+    }
+    return false;
+}
+
 int64_t KvDelegate::Upsert(const std::string &collectionName, const std::string &filter, const std::string &value)
 {
     std::lock_guard<decltype(mutex_)> lock(mutex_);
@@ -33,7 +136,8 @@ int64_t KvDelegate::Upsert(const std::string &collectionName, const std::string
     }
     int count = GRD_UpsertDoc(db_, collectionName.c_str(), filter.c_str(), value.c_str(), 0);
     if (count <= 0) {
-        ZLOGE("GRD_UpSertDoc failed，status %{public}d", count);
+        ZLOGE("GRD_UpSertDoc failed,status %{public}d", count);
+        RestoreIfNeed(count);
         return count;
     }
     Flush();
@@ -52,12 +156,16 @@ int32_t KvDelegate::Delete(const std::string &collectionName, const std::string
     int32_t status = GetBatch(collectionName, filter, "{\"id_\": true}", queryResults);
     if (status != E_OK) {
         ZLOGE("db GetBatch failed, %{public}s %{public}d", filter.c_str(), status);
+        // `GetBatch` should decide whether to restore before errors are returned, so skip restoration here.
         return status;
     }
     for (auto &result : queryResults) {
         auto count = GRD_DeleteDoc(db_, collectionName.c_str(), result.c_str(), 0);
         if (count < 0) {
-            ZLOGE("GRD_UpSertDoc failed，status %{public}d %{public}s", count, result.c_str());
+            ZLOGE("GRD_DeleteDoc failed,status %{public}d %{public}s", count, result.c_str());
+            if (RestoreIfNeed(count)) {
+                return count;
+            }
             continue;
         }
     }
@@ -79,7 +187,8 @@ bool KvDelegate::Init()
     int status = GRD_DBOpen(
         (path_ + "/dataShare.db").c_str(), nullptr, GRD_DB_OPEN_CREATE | GRD_DB_OPEN_CHECK_FOR_ABNORMAL, &db_);
     if (status != GRD_OK || db_ == nullptr) {
-        ZLOGE("GRD_DBOpen failed，status %{public}d", status);
+        ZLOGE("GRD_DBOpen failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return false;
     }
     if (executors_ != nullptr) {
@@ -89,17 +198,22 @@ bool KvDelegate::Init()
             db_ = nullptr;
             isInitDone_ = false;
             taskId_ = ExecutorPool::INVALID_TASK_ID;
+            Backup();
         });
     }
     status = GRD_CreateCollection(db_, TEMPLATE_TABLE, nullptr, 0);
     if (status != GRD_OK) {
-        ZLOGE("GRD_CreateCollection template table failed，status %{public}d", status);
+        // If opeaning db succeeds, it is rare to fail to create tables
+        ZLOGE("GRD_CreateCollection template table failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return false;
     }
 
     status = GRD_CreateCollection(db_, DATA_TABLE, nullptr, 0);
     if (status != GRD_OK) {
-        ZLOGE("GRD_CreateCollection data table failed，status %{public}d", status);
+        // If opeaning db succeeds, it is rare to fail to create tables
+        ZLOGE("GRD_CreateCollection data table failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return false;
     }
     isInitDone_ = true;
@@ -112,7 +226,7 @@ KvDelegate::~KvDelegate()
     if (isInitDone_) {
         int status = GRD_DBClose(db_, 0);
         if (status != GRD_OK) {
-            ZLOGE("GRD_DBClose failed，status %{public}d", status);
+            ZLOGE("GRD_DBClose failed,status %{public}d", status);
         }
     }
 }
@@ -124,7 +238,7 @@ int32_t KvDelegate::Upsert(const std::string &collectionName, const KvData &valu
         int version = -1;
         if (GetVersion(collectionName, id, version)) {
             if (value.GetVersion() <= version) {
-                ZLOGE("GetVersion failed，%{public}s id %{private}s %{public}d %{public}d", collectionName.c_str(),
+                ZLOGE("GetVersion failed,%{public}s id %{private}s %{public}d %{public}d", collectionName.c_str(),
                       id.c_str(), value.GetVersion(), version);
                 return E_VERSION_NOT_NEWER;
             }
@@ -152,7 +266,7 @@ bool KvDelegate::GetVersion(const std::string &collectionName, const std::string
     }
     VersionData data(-1);
     if (!DistributedData::Serializable::Unmarshall(value, data)) {
-        ZLOGE("Unmarshall failed，data %{public}s", value.c_str());
+        ZLOGE("Unmarshall failed,data %{public}s", value.c_str());
         return false;
     }
     version = data.GetVersion();
@@ -173,20 +287,23 @@ int32_t KvDelegate::Get(
     GRD_ResultSet *resultSet = nullptr;
     int status = GRD_FindDoc(db_, collectionName.c_str(), query, 0, &resultSet);
     if (status != GRD_OK || resultSet == nullptr) {
-        ZLOGE("GRD_FindDoc failed，status %{public}d", status);
+        ZLOGE("GRD_FindDoc failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return status;
     }
     status = GRD_Next(resultSet);
     if (status != GRD_OK) {
         GRD_FreeResultSet(resultSet);
-        ZLOGE("GRD_Next failed，status %{public}d", status);
+        ZLOGE("GRD_Next failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return status;
     }
     char *value = nullptr;
     status = GRD_GetValue(resultSet, &value);
     if (status != GRD_OK || value == nullptr) {
         GRD_FreeResultSet(resultSet);
-        ZLOGE("GRD_GetValue failed，status %{public}d", status);
+        ZLOGE("GRD_GetValue failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return status;
     }
     result = value;
@@ -199,7 +316,8 @@ void KvDelegate::Flush()
 {
     int status = GRD_Flush(db_, GRD_DB_FLUSH_ASYNC);
     if (status != GRD_OK) {
-        ZLOGE("GRD_Flush failed，status %{public}d", status);
+        ZLOGE("GRD_Flush failed,status %{public}d", status);
+        RestoreIfNeed(status);
     }
 }
 
@@ -217,7 +335,8 @@ int32_t KvDelegate::GetBatch(const std::string &collectionName, const std::strin
     GRD_ResultSet *resultSet;
     int status = GRD_FindDoc(db_, collectionName.c_str(), query, GRD_DOC_ID_DISPLAY, &resultSet);
     if (status != GRD_OK || resultSet == nullptr) {
-        ZLOGE("GRD_UpSertDoc failed，status %{public}d", status);
+        ZLOGE("GRD_FindDoc failed,status %{public}d", status);
+        RestoreIfNeed(status);
         return status;
     }
     char *value = nullptr;
@@ -225,7 +344,8 @@ int32_t KvDelegate::GetBatch(const std::string &collectionName, const std::strin
         status = GRD_GetValue(resultSet, &value);
         if (status != GRD_OK || value == nullptr) {
             GRD_FreeResultSet(resultSet);
-            ZLOGE("GRD_GetValue failed，status %{public}d", status);
+            ZLOGE("GRD_GetValue failed,status %{public}d", status);
+            RestoreIfNeed(status);
             return status;
         }
         result.emplace_back(value);
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.h b/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.h
index e3d19e08c05494f4b95f8f69798145115a15cc95..13499f70d9e24d15e50c2016a9a86361a3a98f0c 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/kv_delegate.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -36,18 +36,25 @@ public:
         std::string &result) override;
     int32_t GetBatch(const std::string &collectionName, const std::string &filter, const std::string &projection,
         std::vector<std::string> &result) override;
+    void NotifyBackup() override;
 
 private:
     bool Init();
     bool GetVersion(const std::string &collectionName, const std::string &filter, int &version);
     int64_t Upsert(const std::string &collectionName, const std::string &filter, const std::string &value);
     void Flush();
+    bool RestoreIfNeed(int32_t dbStatus);
+    void Backup();
+    void Restore();
+    void RemoveDbFile(bool isBackUp);
+    bool CopyFile(bool isBackup);
     std::recursive_mutex mutex_;
     std::string path_;
     GRD_DB *db_ = nullptr;
     bool isInitDone_ = false;
     std::shared_ptr<ExecutorPool> executors_ = nullptr;
     ExecutorPool::TaskId taskId_ = ExecutorPool::INVALID_TASK_ID;
+    bool hasChange_ = false;
 };
 } // namespace OHOS::DataShare
 #endif // DATASHARESERVICE_KV_DELEGATE_H
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp
index 603c9fcfc90dda8729b8e00849f1a1f9c3b76aab..013ce8b05cd1971d7f9994d3ef3a0201ec52d6ea 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.cpp
@@ -16,21 +16,28 @@
 #include "rdb_delegate.h"
 
 #include "crypto_manager.h"
+#include "datashare_errno.h"
 #include "datashare_radar_reporter.h"
 #include "device_manager_adapter.h"
+#include "extension_connect_adaptor.h"
+#include "int_wrapper.h"
 #include "metadata/meta_data_manager.h"
 #include "metadata/store_meta_data.h"
 #include "metadata/secret_key_meta_data.h"
 #include "resultset_json_formatter.h"
 #include "log_print.h"
+#include "rdb_errno.h"
 #include "rdb_utils.h"
 #include "scheduler_manager.h"
+#include "string_wrapper.h"
 #include "utils/anonymous.h"
+#include "want_params.h"
 
 namespace OHOS::DataShare {
-constexpr static int32_t MAX_RESULTSET_COUNT = 16;
+constexpr static int32_t MAX_RESULTSET_COUNT = 32;
 constexpr static int64_t TIMEOUT_TIME = 500;
 std::atomic<int32_t> RdbDelegate::resultSetCount = 0;
+ConcurrentMap<uint32_t, int32_t> RdbDelegate::resultSetCallingPids;
 enum REMIND_TIMER_ARGS : int32_t {
     ARG_DB_PATH = 0,
     ARG_VERSION,
@@ -61,6 +68,7 @@ RdbStoreConfig RdbDelegate::GetConfig(const DistributedData::StoreMetaData &meta
 {
     RdbStoreConfig config(meta.dataDir);
     config.SetCreateNecessary(false);
+    config.SetHaMode(meta.haMode);
     config.SetBundleName(meta.bundleName);
     if (meta.isEncrypt) {
         DistributedData::SecretKeyMetaData secretKeyMeta;
@@ -76,22 +84,46 @@ RdbStoreConfig RdbDelegate::GetConfig(const DistributedData::StoreMetaData &meta
     return config;
 }
 
-RdbDelegate::RdbDelegate(const DistributedData::StoreMetaData &meta, int version, bool registerFunction)
+RdbDelegate::RdbDelegate(const DistributedData::StoreMetaData &meta, int version,
+    bool registerFunction, const std::string &extUriData, const std::string &backup)
 {
+    tokenId_ = meta.tokenId;
+    bundleName_ = meta.bundleName;
+    storeName_ = meta.storeId;
+    extUri_ = extUriData;
+    haMode_ = meta.haMode;
+    backup_ = backup;
+
     RdbStoreConfig config = GetConfig(meta, registerFunction);
     DefaultOpenCallback callback;
     store_ = RdbHelper::GetRdbStore(config, version, callback, errCode_);
     if (errCode_ != E_OK) {
         ZLOGW("GetRdbStore failed, errCode is %{public}d, dir is %{public}s", errCode_,
             DistributedData::Anonymous::Change(meta.dataDir).c_str());
+        RdbDelegate::TryAndSend(errCode_);
     }
 }
 
-int64_t RdbDelegate::Insert(const std::string &tableName, const DataShareValuesBucket &valuesBucket)
+void RdbDelegate::TryAndSend(int errCode)
+{
+    if (errCode != E_SQLITE_CORRUPT || (haMode_ == HAMode::SINGLE && (backup_ != DUAL_WRITE && backup_ != PERIODIC))) {
+        return;
+    }
+    ZLOGE("Database corruption. BundleName: %{public}s. StoreName: %{public}s. ExtUri: %{public}s",
+        bundleName_.c_str(), storeName_.c_str(), DistributedData::Anonymous::Change(extUri_).c_str());
+    AAFwk::WantParams params;
+    params.SetParam("BundleName", AAFwk::String::Box(bundleName_));
+    params.SetParam("StoreName", AAFwk::String::Box(storeName_));
+    params.SetParam("StoreStatus", AAFwk::Integer::Box(1));
+    ExtensionConnectAdaptor::TryAndWait(extUri_, bundleName_, params);
+}
+
+std::pair<int64_t, int64_t> RdbDelegate::InsertEx(const std::string &tableName,
+    const DataShareValuesBucket &valuesBucket)
 {
     if (store_ == nullptr) {
         ZLOGE("store is null");
-        return 0;
+        return std::make_pair(E_DB_ERROR, 0);
     }
     int64_t rowId = 0;
     ValuesBucket bucket = RdbDataShareAdapter::RdbUtils::ToValuesBucket(valuesBucket);
@@ -100,15 +132,21 @@ int64_t RdbDelegate::Insert(const std::string &tableName, const DataShareValuesB
         ZLOGE("Insert failed %{public}s %{public}d", tableName.c_str(), ret);
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_CALL_RDB,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::INSERT_RDB_ERROR);
+        if (ret == E_SQLITE_ERROR) {
+            EraseStoreCache(tokenId_);
+        }
+        RdbDelegate::TryAndSend(ret);
+        return std::make_pair(E_DB_ERROR, rowId);
     }
-    return rowId;
+    return std::make_pair(E_OK, rowId);
 }
-int64_t RdbDelegate::Update(
+
+std::pair<int64_t, int64_t> RdbDelegate::UpdateEx(
     const std::string &tableName, const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
 {
     if (store_ == nullptr) {
         ZLOGE("store is null");
-        return 0;
+        return std::make_pair(E_DB_ERROR, 0);
     }
     int changeCount = 0;
     ValuesBucket bucket = RdbDataShareAdapter::RdbUtils::ToValuesBucket(valuesBucket);
@@ -118,14 +156,20 @@ int64_t RdbDelegate::Update(
         ZLOGE("Update failed  %{public}s %{public}d", tableName.c_str(), ret);
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_CALL_RDB,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::UPDATE_RDB_ERROR);
+        if (ret == E_SQLITE_ERROR) {
+            EraseStoreCache(tokenId_);
+        }
+        RdbDelegate::TryAndSend(ret);
+        return std::make_pair(E_DB_ERROR, changeCount);
     }
-    return changeCount;
+    return std::make_pair(E_OK, changeCount);
 }
-int64_t RdbDelegate::Delete(const std::string &tableName, const DataSharePredicates &predicate)
+
+std::pair<int64_t, int64_t> RdbDelegate::DeleteEx(const std::string &tableName, const DataSharePredicates &predicate)
 {
     if (store_ == nullptr) {
         ZLOGE("store is null");
-        return 0;
+        return std::make_pair(E_DB_ERROR, 0);
     }
     int changeCount = 0;
     RdbPredicates predicates = RdbDataShareAdapter::RdbUtils::ToPredicates(predicate, tableName);
@@ -134,9 +178,15 @@ int64_t RdbDelegate::Delete(const std::string &tableName, const DataSharePredica
         ZLOGE("Delete failed  %{public}s %{public}d", tableName.c_str(), ret);
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_CALL_RDB,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::DELETE_RDB_ERROR);
+        if (ret == E_SQLITE_ERROR) {
+            EraseStoreCache(tokenId_);
+        }
+        RdbDelegate::TryAndSend(ret);
+        return std::make_pair(E_DB_ERROR, changeCount);
     }
-    return changeCount;
+    return std::make_pair(E_OK, changeCount);
 }
+
 std::pair<int, std::shared_ptr<DataShareResultSet>> RdbDelegate::Query(const std::string &tableName,
     const DataSharePredicates &predicates, const std::vector<std::string> &columns,
     const int32_t callingPid)
@@ -147,20 +197,29 @@ std::pair<int, std::shared_ptr<DataShareResultSet>> RdbDelegate::Query(const std
     }
     int count = resultSetCount.fetch_add(1);
     ZLOGD("start query %{public}d", count);
-    if (count > MAX_RESULTSET_COUNT) {
-        ZLOGE("resultSetCount is full");
+    if (count > MAX_RESULTSET_COUNT && IsLimit(count, callingPid)) {
         resultSetCount--;
-        return std::make_pair(E_ERROR, nullptr);
+        return std::make_pair(E_RESULTSET_BUSY, nullptr);
     }
     RdbPredicates rdbPredicates = RdbDataShareAdapter::RdbUtils::ToPredicates(predicates, tableName);
     std::shared_ptr<NativeRdb::ResultSet> resultSet = store_->QueryByStep(rdbPredicates, columns);
     if (resultSet == nullptr) {
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_CALL_RDB,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::QUERY_RDB_ERROR);
-        ZLOGE("Query failed %{public}s", tableName.c_str());
+        ZLOGE("Query failed %{public}s, pid: %{public}d", tableName.c_str(), callingPid);
         resultSetCount--;
         return std::make_pair(E_ERROR, nullptr);
     }
+    int err = resultSet->GetRowCount(count);
+    RdbDelegate::TryAndSend(err);
+    if (err == E_SQLITE_ERROR) {
+        ZLOGE("query failed, err:%{public}d, pid:%{public}d", E_SQLITE_ERROR, callingPid);
+        EraseStoreCache(tokenId_);
+    }
+    resultSetCallingPids.Compute(callingPid, [](const uint32_t &, int32_t &value) {
+        ++value;
+        return true;
+    });
     int64_t beginTime = std::chrono::duration_cast<std::chrono::milliseconds>(
         std::chrono::system_clock::now().time_since_epoch()).count();
     auto bridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
@@ -173,6 +232,10 @@ std::pair<int, std::shared_ptr<DataShareResultSet>> RdbDelegate::Query(const std
             ZLOGE("pid %{public}d query time is %{public}" PRId64 ", %{public}d resultSet is used.", callingPid,
                 (endTime - beginTime), resultSetCount.load());
         }
+        resultSetCallingPids.ComputeIfPresent(callingPid, [](const uint32_t &, int32_t &value) {
+            --value;
+            return value > 0;
+        });
         delete p;
     }};
     return std::make_pair(E_OK, result);
@@ -189,6 +252,11 @@ std::string RdbDelegate::Query(const std::string &sql, const std::vector<std::st
         ZLOGE("Query failed %{private}s", sql.c_str());
         return "";
     }
+    int rowCount;
+    if (resultSet->GetRowCount(rowCount) == E_SQLITE_ERROR) {
+        ZLOGE("query failed, err:%{public}d", E_SQLITE_ERROR);
+        EraseStoreCache(tokenId_);
+    }
     ResultSetJsonFormatter formatter(std::move(resultSet));
     return DistributedData::Serializable::Marshall(formatter);
 }
@@ -199,6 +267,43 @@ std::shared_ptr<NativeRdb::ResultSet> RdbDelegate::QuerySql(const std::string &s
         ZLOGE("store is null");
         return nullptr;
     }
-    return store_->QuerySql(sql);
+    auto resultSet = store_->QuerySql(sql);
+    if (resultSet == nullptr) {
+        ZLOGE("Query failed %{private}s", sql.c_str());
+        return resultSet;
+    }
+    int rowCount;
+    if (resultSet->GetRowCount(rowCount) == E_SQLITE_ERROR) {
+        ZLOGE("query failed, err:%{public}d", E_SQLITE_ERROR);
+        EraseStoreCache(tokenId_);
+    }
+    return resultSet;
+}
+
+bool RdbDelegate::IsInvalid()
+{
+    return store_ == nullptr;
+}
+
+bool RdbDelegate::IsLimit(int count, const int32_t callingPid)
+{
+    bool isFull = true;
+    for (int32_t retryCount = 0; retryCount < RETRY; retryCount++) {
+        std::this_thread::sleep_for(WAIT_TIME);
+        if (resultSetCount.load() <= MAX_RESULTSET_COUNT) {
+            isFull = false;
+            break;
+        }
+    }
+    if (!isFull) {
+        return false;
+    }
+    std::string logStr;
+    resultSetCallingPids.ForEach([&logStr](const uint32_t &key, const int32_t &value) {
+        logStr += std::to_string(key) + ":" + std::to_string(value) + ";";
+        return false;
+    });
+    ZLOGE("resultSetCount is full, pid: %{public}d, owner is %{public}s", callingPid, logStr.c_str());
+    return true;
 }
 } // namespace OHOS::DataShare
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.h b/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.h
index cef51a9cc2c16acde425d45dc09f4d84f4308d76..adb3d3b133980e7a7aa5cadab78faee3ec1831be 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/rdb_delegate.h
@@ -31,22 +31,38 @@ namespace OHOS::DataShare {
 using namespace OHOS::NativeRdb;
 class RdbDelegate final : public DBDelegate {
 public:
-    explicit RdbDelegate(const DistributedData::StoreMetaData &meta, int version, bool registerFunction);
-    int64_t Insert(const std::string &tableName, const DataShareValuesBucket &valuesBucket) override;
-    int64_t Update(const std::string &tableName, const DataSharePredicates &predicate,
-        const DataShareValuesBucket &valuesBucket) override;
-    int64_t Delete(const std::string &tableName, const DataSharePredicates &predicate) override;
+    explicit RdbDelegate(const DistributedData::StoreMetaData &meta, int version,
+        bool registerFunction, const std::string &extUri, const std::string &backup);
     std::pair<int, std::shared_ptr<DataShareResultSet>> Query(const std::string &tableName,
         const DataSharePredicates &predicates, const std::vector<std::string> &columns,
         const int32_t callingPid) override;
     std::string Query(const std::string &sql, const std::vector<std::string> &selectionArgs) override;
     std::shared_ptr<NativeRdb::ResultSet> QuerySql(const std::string &sql) override;
-
+    bool IsInvalid() override;
+    std::pair<int64_t, int64_t> InsertEx(const std::string &tableName,
+        const DataShareValuesBucket &valuesBucket) override;
+    std::pair<int64_t, int64_t> UpdateEx(const std::string &tableName,
+        const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket) override;
+    std::pair<int64_t, int64_t> DeleteEx(const std::string &tableName,
+        const DataSharePredicates &predicate) override;
 private:
+    void TryAndSend(int errCode);
     RdbStoreConfig GetConfig(const DistributedData::StoreMetaData &meta, bool registerFunction);
+    bool IsLimit(int count, const int32_t callingPid);
     static std::atomic<int32_t> resultSetCount;
+    static ConcurrentMap<uint32_t, int32_t> resultSetCallingPids;
+    static constexpr std::chrono::milliseconds WAIT_TIME = std::chrono::milliseconds(50);
     std::shared_ptr<RdbStore> store_;
     int errCode_ = E_OK;
+    static constexpr int RETRY = 3;
+    static constexpr const char *DUAL_WRITE = "dualWrite";
+    static constexpr const char *PERIODIC = "periodic";
+    uint32_t tokenId_;
+    std::string bundleName_;
+    std::string storeName_;
+    int32_t haMode_;
+    std::string extUri_;
+    std::string backup_;
 };
 class DefaultOpenCallback : public RdbOpenCallback {
 public:
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/common/uri_utils.cpp b/datamgr_service/services/distributeddataservice/service/data_share/common/uri_utils.cpp
index 8fb91826922fc63b34002af3d7586fc0d6cb21a2..26447121a82615ea7304cef1f41d75bec5b845f9 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/common/uri_utils.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/common/uri_utils.cpp
@@ -72,7 +72,7 @@ void URIUtils::FormatUri(std::string &uri)
     uri.resize(pos);
 }
 
-UriConfig URIUtils::GetUriConfig(const std::string &uri)
+__attribute__((no_sanitize("cfi"))) UriConfig URIUtils::GetUriConfig(const std::string &uri)
 {
     UriConfig uriConfig;
     Uri uriTemp(uri);
@@ -107,7 +107,7 @@ std::pair<bool, uint32_t> URIUtils::Strtoul(const std::string &str)
     char* end = nullptr;
     errno = 0;
     data = strtoul(str.c_str(), &end, 10);
-    if (errno == ERANGE || end == str || *end != '\0') {
+    if (errno == ERANGE || end == nullptr || end == str || *end != '\0') {
         return std::make_pair(false, data);
     }
     return std::make_pair(true, data);
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data/template_data.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data/template_data.cpp
index 4236f4d7b370f28199c9e7f443bd267756cced00..eb63f4111728c95a87a6c3dfd8129d855af7d828 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data/template_data.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data/template_data.cpp
@@ -132,6 +132,7 @@ bool TemplateData::Delete(const std::string &bundleName, const int32_t userId)
         ZLOGE("db DeleteById failed, %{public}d", status);
         return false;
     }
+    delegate->NotifyBackup();
     return true;
 }
 
@@ -149,6 +150,7 @@ bool TemplateData::Add(const std::string &uri, const int32_t userId, const std::
         ZLOGE("db Upsert failed, %{public}d", status);
         return false;
     }
+    delegate->NotifyBackup();
     return true;
 }
 
@@ -166,6 +168,7 @@ bool TemplateData::Delete(
         ZLOGE("db DeleteById failed, %{public}d", status);
         return false;
     }
+    delegate->NotifyBackup();
     return true;
 }
 
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.cpp
index 4d951df554fa6ec26be2389488dab78729d05234..98783ade7fe562899cf3adffe406f973356b793a 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.cpp
@@ -41,9 +41,9 @@ DataProviderConfig::DataProviderConfig(const std::string &uri, uint32_t callerTo
     uriConfig_ = URIUtils::GetUriConfig(providerInfo_.uri);
 }
 
-std::pair<int, BundleInfo> DataProviderConfig::GetBundleInfo()
+std::pair<int, BundleConfig> DataProviderConfig::GetBundleInfo()
 {
-    BundleInfo bundleInfo;
+    BundleConfig bundleInfo;
     providerInfo_.bundleName = uriConfig_.authority;
     if (providerInfo_.bundleName.empty()) {
         if (uriConfig_.pathSegments.empty()) {
@@ -51,11 +51,9 @@ std::pair<int, BundleInfo> DataProviderConfig::GetBundleInfo()
         }
         providerInfo_.bundleName = uriConfig_.pathSegments[0];
     }
-    if (!BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
-        providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo)) {
-        return std::make_pair(E_BUNDLE_NAME_NOT_EXIST, bundleInfo);
-    }
-    return std::make_pair(E_OK, bundleInfo);
+    auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
+        providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo);
+    return std::make_pair(ret, bundleInfo);
 }
 
 int DataProviderConfig::GetFromProxyData()
@@ -77,8 +75,8 @@ int DataProviderConfig::GetFromProxyData()
     }
     for (auto &hapModuleInfo : bundleInfo.hapModuleInfos) {
         auto &proxyDatas = hapModuleInfo.proxyDatas;
-        std::sort(proxyDatas.begin(), proxyDatas.end(), [](const AppExecFwk::ProxyData &curr,
-            const AppExecFwk::ProxyData &prev) {
+        std::sort(proxyDatas.begin(), proxyDatas.end(), [](const ProxyData &curr,
+            const ProxyData &prev) {
             return curr.uri.length() > prev.uri.length();
         });
         for (auto &data : proxyDatas) {
@@ -88,17 +86,15 @@ int DataProviderConfig::GetFromProxyData()
             }
             providerInfo_.readPermission = std::move(data.requiredReadPermission);
             providerInfo_.writePermission = std::move(data.requiredWritePermission);
-            auto [ret, profileInfo] = DataShareProfileConfig::GetDataProperties(
-                std::vector<AppExecFwk::Metadata>{data.metadata}, hapModuleInfo.resourcePath,
-                hapModuleInfo.hapPath, DATA_SHARE_PROPERTIES_META);
-            if (ret == NOT_FOUND) {
+            auto profileInfo = data.profileInfo;
+            if (profileInfo.resultCode == NOT_FOUND) {
                 return E_OK;
             }
-            if (ret == ERROR) {
+            if (profileInfo.resultCode == ERROR) {
                 ZLOGE("Profile unmarshall error.uri: %{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
                 return E_ERROR;
             }
-            return GetFromDataProperties(profileInfo, hapModuleInfo.moduleName);
+            return GetFromDataProperties(profileInfo.profile, hapModuleInfo.moduleName);
         }
     }
     return E_URI_NOT_EXIST;
@@ -114,6 +110,8 @@ int DataProviderConfig::GetFromDataProperties(const ProfileInfo &profileInfo,
     providerInfo_.tableName = profileInfo.tableName;
     providerInfo_.type = profileInfo.type;
     providerInfo_.storeMetaDataFromUri = profileInfo.storeMetaDataFromUri;
+    providerInfo_.backup = profileInfo.backup;
+    providerInfo_.extensionUri = profileInfo.extUri;
     if (profileInfo.tableConfig.empty()) {
         return E_OK;
     }
@@ -144,11 +142,12 @@ int DataProviderConfig::GetFromExtension()
         ZLOGE("Uri path failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
         return E_URI_NOT_EXIST;
     }
-    BundleInfo bundleInfo;
-    if (!BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
-        providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo)) {
+    BundleConfig bundleInfo;
+    auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
+        providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo);
+    if (ret != E_OK) {
         ZLOGE("BundleInfo failed! bundleName: %{public}s", providerInfo_.bundleName.c_str());
-        return E_BUNDLE_NAME_NOT_EXIST;
+        return ret;
     }
     providerInfo_.singleton = bundleInfo.singleton;
     providerInfo_.allowEmptyPermission = true;
@@ -159,16 +158,15 @@ int DataProviderConfig::GetFromExtension()
         providerInfo_.hasExtension = true;
         providerInfo_.readPermission = std::move(item.readPermission);
         providerInfo_.writePermission = std::move(item.writePermission);
-        auto [ret, profileInfo] = DataShareProfileConfig::GetDataProperties(
-            item.metadata, item.resourcePath, item.hapPath, DATA_SHARE_EXTENSION_META);
-        if (ret == NOT_FOUND) {
+        auto profileInfo = item.profileInfo;
+        if (profileInfo.resultCode == NOT_FOUND) {
             return E_OK;
         }
-        if (ret == ERROR) {
+        if (profileInfo.resultCode == ERROR) {
             ZLOGE("Profile Unmarshall failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
             return E_ERROR;
         }
-        return GetFromExtensionProperties(profileInfo, providerInfo_.moduleName);
+        return GetFromExtensionProperties(profileInfo.profile, providerInfo_.moduleName);
     }
     return E_URI_NOT_EXIST;
 }
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.h b/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.h
index dd2f5966405e16dcab22dd4f44f500006796875d..794cfe0650ca6c77fed175d507520afd7ff74bf3 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_provider_config.h
@@ -18,6 +18,7 @@
 #include <map>
 #include <string>
 
+#include "common/bundle_mgr_proxy.h"
 #include "account/account_delegate.h"
 #include "bundle_mgr_proxy.h"
 #include "data_share_profile_config.h"
@@ -25,7 +26,6 @@
 #include "uri_utils.h"
 
 namespace OHOS::DataShare {
-using BundleInfo = OHOS::AppExecFwk::BundleInfo;
 using ExtensionAbility = OHOS::AppExecFwk::ExtensionAbilityInfo;
 class DataProviderConfig {
 public:
@@ -41,6 +41,8 @@ public:
         std::string readPermission;
         std::string writePermission;
         std::string type = "rdb";
+        std::string backup;
+        std::string extensionUri;
         bool singleton = false;
         bool hasExtension = false;
         bool allowEmptyPermission = false;
@@ -56,7 +58,7 @@ private:
     int GetFromDataProperties(const ProfileInfo &profileInfo, const std::string &moduleName);
     int GetFromExtensionProperties(const ProfileInfo &profileInfo, const std::string &moduleName);
     void GetMetaDataFromUri();
-    std::pair<int, BundleInfo> GetBundleInfo();
+    std::pair<int, BundleConfig> GetBundleInfo();
     enum class PATH_PARAM : int32_t {
         BUNDLE_NAME = 0,
         MODULE_NAME,
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.cpp
index d604a832557e6f05b4d1e6fc7c53326c8aa2b076..b8c2927a025c75b811e99c5d66a3cc94668157c8 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.cpp
@@ -50,7 +50,8 @@ std::pair<int, DistributedData::StoreMetaData> DataShareDbConfig::GetMetaData(co
         if (!hasExtension) {
             return std::pair(NativeRdb::E_DB_NOT_EXIST, metaData);
         }
-        ExtensionConnectAdaptor::TryAndWait(uri, bundleName);
+        AAFwk::WantParams wantParams;
+        ExtensionConnectAdaptor::TryAndWait(uri, bundleName, wantParams);
         auto [succ, meta] = QueryMetaData(bundleName, storeName, userId);
         if (!succ) {
             return std::pair(NativeRdb::E_DB_NOT_EXIST, meta);
@@ -61,21 +62,22 @@ std::pair<int, DistributedData::StoreMetaData> DataShareDbConfig::GetMetaData(co
 }
 
 std::tuple<int, DistributedData::StoreMetaData, std::shared_ptr<DBDelegate>> DataShareDbConfig::GetDbConfig(
-    const std::string &uri, bool hasExtension, const std::string &bundleName, const std::string &storeName,
-    int32_t userId)
+    DbConfig &dbConfig)
 {
-    auto [errCode, metaData] = GetMetaData(uri, bundleName, storeName, userId, hasExtension);
+    auto [errCode, metaData] = GetMetaData(dbConfig.uri, dbConfig.bundleName, dbConfig.storeName,
+        dbConfig.userId, dbConfig.hasExtension);
     if (errCode != E_OK) {
         ZLOGE("DB not exist,bundleName:%{public}s,storeName:%{public}s,user:%{public}d,err:%{public}d,uri:%{public}s",
-            bundleName.c_str(), storeName.c_str(), userId, errCode, URIUtils::Anonymous(uri).c_str());
+            dbConfig.bundleName.c_str(), dbConfig.storeName.c_str(), dbConfig.userId, errCode,
+            URIUtils::Anonymous(dbConfig.uri).c_str());
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_MATEDATA_EXISTS,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::META_DATA_NOT_EXISTS);
         return std::make_tuple(errCode, metaData, nullptr);
     }
-    auto dbDelegate = DBDelegate::Create(metaData);
+    auto dbDelegate = DBDelegate::Create(metaData, dbConfig.extUri, dbConfig.backup);
     if (dbDelegate == nullptr) {
         ZLOGE("Create delegate fail, bundleName:%{public}s, userId:%{public}d, uri:%{public}s",
-            bundleName.c_str(), userId, URIUtils::Anonymous(uri).c_str());
+            dbConfig.bundleName.c_str(), dbConfig.userId, URIUtils::Anonymous(dbConfig.uri).c_str());
         return std::make_tuple(E_ERROR, metaData, nullptr);
     }
     return std::make_tuple(E_OK, metaData, dbDelegate);
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.h b/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.h
index 441e9cfe20c447d4451318ca0344869a959b779b..c038a4cbd62d5148d98beb169ea335908774230e 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_db_config.h
@@ -28,9 +28,16 @@
 namespace OHOS::DataShare {
 class DataShareDbConfig {
 public:
-    std::tuple<int, DistributedData::StoreMetaData, std::shared_ptr<DBDelegate>> GetDbConfig(
-        const std::string &uri, bool hasExtension, const std::string &bundleName,
-        const std::string &storeName, int32_t userId);
+    struct DbConfig {
+        std::string uri;
+        std::string extUri;
+        std::string bundleName;
+        std::string storeName;
+        std::string backup;
+        int32_t userId;
+        bool hasExtension;
+    };
+    std::tuple<int, DistributedData::StoreMetaData, std::shared_ptr<DBDelegate>> GetDbConfig(DbConfig &dbConfig);
     std::pair<int, DistributedData::StoreMetaData> GetMetaData(const std::string &uri,
         const std::string &bundleName, const std::string &storeName, int32_t userId, bool hasExtension);
 private:
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.cpp
index f179186de6da658a74d5461f62ba0b2d915a46a2..fde20bd1128af33f4e3bb2496aac5c778fc91e38 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.cpp
@@ -24,6 +24,7 @@
 #include <unistd.h>
 
 #include "bundle_mgr_proxy.h"
+#include "datashare_errno.h"
 #include "log_print.h"
 #include "uri_utils.h"
 #include "utils/anonymous.h"
@@ -75,6 +76,9 @@ bool ProfileInfo::Marshal(json &node) const
     SetValue(node[GET_NAME(type)], type);
     SetValue(node[GET_NAME(launchInfos)], launchInfos);
     SetValue(node[GET_NAME(storeMetaDataFromUri)], storeMetaDataFromUri);
+    SetValue(node[GET_NAME(launchForCleanData)], launchForCleanData);
+    SetValue(node[GET_NAME(backup)], backup);
+    SetValue(node[GET_NAME(extUri)], extUri);
     return true;
 }
 
@@ -86,6 +90,9 @@ bool ProfileInfo::Unmarshal(const json &node)
     GetValue(node, GET_NAME(type), type);
     GetValue(node, GET_NAME(launchInfos), launchInfos);
     GetValue(node, GET_NAME(storeMetaDataFromUri), storeMetaDataFromUri);
+    GetValue(node, GET_NAME(launchForCleanData), launchForCleanData);
+    GetValue(node, GET_NAME(backup), backup);
+    GetValue(node, GET_NAME(extUri), extUri);
     std::string path;
     auto ret = GetValue(node, GET_NAME(path), path);
     if (ret) {
@@ -243,8 +250,9 @@ std::string DataShareProfileConfig::ReadProfile(const std::string &resPath)
 bool DataShareProfileConfig::GetProfileInfo(const std::string &calledBundleName, int32_t currentUserId,
     std::map<std::string, ProfileInfo> &profileInfos)
 {
-    AppExecFwk::BundleInfo bundleInfo;
-    if (!BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(calledBundleName, currentUserId, bundleInfo)) {
+    BundleConfig bundleInfo;
+    if (BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(calledBundleName,
+        currentUserId, bundleInfo) != E_OK) {
         ZLOGE("data share GetBundleInfoFromBMS failed! bundleName: %{public}s, currentUserId = %{public}d",
               calledBundleName.c_str(), currentUserId);
         return false;
@@ -253,12 +261,11 @@ bool DataShareProfileConfig::GetProfileInfo(const std::string &calledBundleName,
         if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
             continue;
         }
-        auto [ret, profileInfo] = GetDataProperties(item.metadata, item.resourcePath,
-            item.hapPath, DATA_SHARE_EXTENSION_META);
-        if (ret == ERROR || ret == NOT_FOUND) {
+        auto profileInfo = item.profileInfo;
+        if (profileInfo.resultCode == ERROR || profileInfo.resultCode == NOT_FOUND) {
             continue;
         }
-        profileInfos[item.uri] = profileInfo;
+        profileInfos[item.uri] = profileInfo.profile;
     }
     return true;
 }
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.h b/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.h
index fb5e631a98819681dc5f31effb59be3d2e52f504..9fc6df898af97bb4db84fbae61b63d2e535fb641 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_profile_config.h
@@ -50,8 +50,11 @@ struct ProfileInfo : public DistributedData::Serializable {
     std::string tableName;
     std::string scope = "module";
     std::string type = "rdb";
+    std::string backup;
+    std::string extUri;
     std::vector<LaunchInfo> launchInfos;
     bool storeMetaDataFromUri = false;
+    bool launchForCleanData = false;
     bool Marshal(json &node) const override;
     bool Unmarshal(const json &node) override;
 };
@@ -63,7 +66,7 @@ enum AccessCrossMode : uint8_t {
     USER_MAX,
 };
 
-class API_EXPORT DataShareProfileConfig {
+class DataShareProfileConfig {
 public:
     constexpr static int8_t TABLE_MATCH_PRIORITY = 3;
     constexpr static int8_t STORE_MATCH_PRIORITY = 2;
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.cpp
index 57e063904b79e71a9156f465d9421ac22901d4ac..c57d403dcb636a09d88f13c11509feecdca1b22b 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.cpp
@@ -38,7 +38,9 @@
 #include "dump/dump_manager.h"
 #include "extension_ability_manager.h"
 #include "hap_token_info.h"
+#include "if_system_ability_manager.h"
 #include "ipc_skeleton.h"
+#include "iservice_registry.h"
 #include "log_print.h"
 #include "metadata/auto_launch_meta_data.h"
 #include "metadata/meta_data_manager.h"
@@ -48,6 +50,8 @@
 #include "scheduler_manager.h"
 #include "subscriber_managers/published_data_subscriber_manager.h"
 #include "sys_event_subscriber.h"
+#include "system_ability_definition.h"
+#include "system_ability_status_change_stub.h"
 #include "template_data.h"
 #include "utils/anonymous.h"
 #include "xcollie.h"
@@ -58,6 +62,29 @@ using DumpManager = OHOS::DistributedData::DumpManager;
 using ProviderInfo = DataProviderConfig::ProviderInfo;
 using namespace OHOS::DistributedData;
 __attribute__((used)) DataShareServiceImpl::Factory DataShareServiceImpl::factory_;
+class DataShareServiceImpl::SystemAbilityStatusChangeListener
+    : public SystemAbilityStatusChangeStub {
+public:
+    SystemAbilityStatusChangeListener()
+    {
+    }
+    ~SystemAbilityStatusChangeListener() = default;
+    void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
+    void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override
+    {
+    }
+};
+
+void DataShareServiceImpl::SystemAbilityStatusChangeListener::OnAddSystemAbility(
+    int32_t systemAbilityId, const std::string &deviceId)
+{
+    if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
+        return;
+    }
+    ZLOGI("Common event service start. saId:%{public}d", systemAbilityId);
+    InitSubEvent();
+}
+
 DataShareServiceImpl::Factory::Factory()
 {
     FeatureSystem::GetInstance().RegisterCreator("data_share", []() {
@@ -69,24 +96,24 @@ DataShareServiceImpl::Factory::Factory()
 
 DataShareServiceImpl::Factory::~Factory() {}
 
-int32_t DataShareServiceImpl::Insert(const std::string &uri, const DataShareValuesBucket &valuesBucket)
+std::pair<int32_t, int32_t> DataShareServiceImpl::InsertEx(const std::string &uri, const std::string &extUri,
+    const DataShareValuesBucket &valuesBucket)
 {
-    ZLOGD("Insert enter.");
     XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     if (GetSilentProxyStatus(uri, false) != E_OK) {
         ZLOGW("silent proxy disable, %{public}s", URIUtils::Anonymous(uri).c_str());
-        return ERROR;
+        return std::make_pair(ERROR, 0);
     }
-    auto callBack = [&uri, &valuesBucket, this](ProviderInfo &providerInfo,
-            DistributedData::StoreMetaData &metaData, std::shared_ptr<DBDelegate> dbDelegate) -> int32_t {
-        auto ret = dbDelegate->Insert(providerInfo.tableName, valuesBucket);
-        if (ret > 0) {
+    auto callBack = [&uri, &valuesBucket, this](ProviderInfo &providerInfo, DistributedData::StoreMetaData &metaData,
+        std::shared_ptr<DBDelegate> dbDelegate) -> std::pair<int32_t, int32_t> {
+        auto [errCode, ret] = dbDelegate->InsertEx(providerInfo.tableName, valuesBucket);
+        if (errCode == E_OK && ret > 0) {
             NotifyChange(uri);
             RdbSubscriberManager::GetInstance().Emit(uri, providerInfo.currentUserId, metaData);
         }
-        return ret;
+        return std::make_pair(errCode, ret);
     };
-    return Execute(uri, IPCSkeleton::GetCallingTokenID(), false, callBack);
+    return ExecuteEx(uri, extUri, IPCSkeleton::GetCallingTokenID(), false, callBack);
 }
 
 bool DataShareServiceImpl::NotifyChange(const std::string &uri)
@@ -109,51 +136,52 @@ bool DataShareServiceImpl::NotifyChange(const std::string &uri)
     return true;
 }
 
-int32_t DataShareServiceImpl::Update(const std::string &uri, const DataSharePredicates &predicate,
-    const DataShareValuesBucket &valuesBucket)
+std::pair<int32_t, int32_t> DataShareServiceImpl::UpdateEx(const std::string &uri, const std::string &extUri,
+    const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket)
 {
-    ZLOGD("Update enter.");
     XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     if (GetSilentProxyStatus(uri, false) != E_OK) {
         ZLOGW("silent proxy disable, %{public}s", URIUtils::Anonymous(uri).c_str());
-        return ERROR;
+        return std::make_pair(ERROR, 0);
     }
     auto callBack = [&uri, &predicate, &valuesBucket, this](ProviderInfo &providerInfo,
-            DistributedData::StoreMetaData &metaData, std::shared_ptr<DBDelegate> dbDelegate) -> int32_t {
-        auto ret = dbDelegate->Update(providerInfo.tableName, predicate, valuesBucket);
-        if (ret > 0) {
+        DistributedData::StoreMetaData &metaData,
+        std::shared_ptr<DBDelegate> dbDelegate) -> std::pair<int32_t, int32_t> {
+        auto [errCode, ret] = dbDelegate->UpdateEx(providerInfo.tableName, predicate, valuesBucket);
+        if (errCode == E_OK && ret > 0) {
             NotifyChange(uri);
             RdbSubscriberManager::GetInstance().Emit(uri, providerInfo.currentUserId, metaData);
         }
-        return ret;
+        return std::make_pair(errCode, ret);
     };
-    return Execute(uri, IPCSkeleton::GetCallingTokenID(), false, callBack);
+    return ExecuteEx(uri, extUri, IPCSkeleton::GetCallingTokenID(), false, callBack);
 }
 
-int32_t DataShareServiceImpl::Delete(const std::string &uri, const DataSharePredicates &predicate)
+std::pair<int32_t, int32_t> DataShareServiceImpl::DeleteEx(const std::string &uri, const std::string &extUri,
+    const DataSharePredicates &predicate)
 {
     XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     if (GetSilentProxyStatus(uri, false) != E_OK) {
         ZLOGW("silent proxy disable, %{public}s", URIUtils::Anonymous(uri).c_str());
-        return ERROR;
+        return std::make_pair(ERROR, 0);
     }
-    auto callBack = [&uri, &predicate, this](ProviderInfo &providerInfo,
-            DistributedData::StoreMetaData &metaData, std::shared_ptr<DBDelegate> dbDelegate) -> int32_t {
-        auto ret = dbDelegate->Delete(providerInfo.tableName, predicate);
-        if (ret > 0) {
+    auto callBack = [&uri, &predicate, this](ProviderInfo &providerInfo, DistributedData::StoreMetaData &metaData,
+        std::shared_ptr<DBDelegate> dbDelegate) -> std::pair<int32_t, int32_t> {
+        auto [errCode, ret] = dbDelegate->DeleteEx(providerInfo.tableName, predicate);
+        if (errCode == E_OK && ret > 0) {
             NotifyChange(uri);
             RdbSubscriberManager::GetInstance().Emit(uri, providerInfo.currentUserId, metaData);
         }
-        return ret;
+        return std::make_pair(errCode, ret);
     };
-    return Execute(uri, IPCSkeleton::GetCallingTokenID(), false, callBack);
+    return ExecuteEx(uri, extUri, IPCSkeleton::GetCallingTokenID(), false, callBack);
 }
 
-std::shared_ptr<DataShareResultSet> DataShareServiceImpl::Query(const std::string &uri,
+std::shared_ptr<DataShareResultSet> DataShareServiceImpl::Query(const std::string &uri, const std::string &extUri,
     const DataSharePredicates &predicates, const std::vector<std::string> &columns, int &errCode)
 {
-    ZLOGD("Query enter.");
-    XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
+    XCollie xcollie(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__),
+        HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     if (GetSilentProxyStatus(uri, false) != E_OK) {
         ZLOGW("silent proxy disable, %{public}s", URIUtils::Anonymous(uri).c_str());
         return nullptr;
@@ -161,13 +189,14 @@ std::shared_ptr<DataShareResultSet> DataShareServiceImpl::Query(const std::strin
     std::shared_ptr<DataShareResultSet> resultSet;
     auto callingPid = IPCSkeleton::GetCallingPid();
     auto callBack = [&uri, &predicates, &columns, &resultSet, &callingPid](ProviderInfo &providerInfo,
-            DistributedData::StoreMetaData &, std::shared_ptr<DBDelegate> dbDelegate) -> int32_t {
+            DistributedData::StoreMetaData &, std::shared_ptr<DBDelegate> dbDelegate) -> std::pair<int32_t, int32_t> {
         auto [err, result] = dbDelegate->Query(providerInfo.tableName,
             predicates, columns, callingPid);
         resultSet = std::move(result);
-        return err;
+        return std::make_pair(err, E_OK);
     };
-    errCode = Execute(uri, IPCSkeleton::GetCallingTokenID(), true, callBack);
+    auto [errVal, status] = ExecuteEx(uri, extUri, IPCSkeleton::GetCallingTokenID(), true, callBack);
+    errCode = errVal;
     return resultSet;
 }
 
@@ -498,13 +527,25 @@ int32_t DataShareServiceImpl::OnBind(const BindInfo &binderInfo)
     KvDBDelegate::GetInstance(false, saveMeta.dataDir, binderInfo.executors);
     SchedulerManager::GetInstance().SetExecutorPool(binderInfo.executors);
     ExtensionAbilityManager::GetInstance().SetExecutorPool(binderInfo.executors);
-    InitSubEvent();
+    DBDelegate::SetExecutorPool(binderInfo.executors);
+    SubscribeCommonEvent();
     SubscribeTimeChanged();
     SubscribeChange();
     ZLOGI("end");
     return E_OK;
 }
 
+void DataShareServiceImpl::SubscribeCommonEvent()
+{
+    sptr<ISystemAbilityManager> systemManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (systemManager == nullptr) {
+        ZLOGE("System mgr is nullptr");
+        return;
+    }
+    sptr<SystemAbilityStatusChangeListener> callback(new SystemAbilityStatusChangeListener());
+    systemManager->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, callback);
+}
+
 void DataShareServiceImpl::SubscribeChange()
 {
     EventCenter::GetInstance().Subscribe(RemoteChangeEvent::RDB_META_SAVE, [this](const Event &event) {
@@ -535,16 +576,36 @@ void DataShareServiceImpl::SaveLaunchInfo(const std::string &bundleName, const s
         }
         std::string extUri = uri;
         extUri.insert(strlen(EXT_URI_SCHEMA), "/");
+        StoreMetaData meta = MakeMetaData(bundleName, userId, deviceId);
+        if (value.launchInfos.empty()) {
+            meta.storeId = "";
+            AutoLaunchMetaData autoLaunchMetaData = {};
+            std::vector<std::string> tempData = {};
+            autoLaunchMetaData.datas.emplace(extUri, tempData);
+            autoLaunchMetaData.launchForCleanData = value.launchForCleanData;
+            MetaDataManager::GetInstance().SaveMeta(meta.GetAutoLaunchKey(), autoLaunchMetaData, true);
+            ZLOGI("Without launchInfos, save meta end, bundleName = %{public}s.", bundleName.c_str());
+            continue;
+        }
         for (const auto &launchInfo : value.launchInfos) {
-            AutoLaunchMetaData &autoLaunchMetaData = maps[launchInfo.storeId];
+            AutoLaunchMetaData autoLaunchMetaData = {};
             autoLaunchMetaData.datas.emplace(extUri, launchInfo.tableNames);
+            autoLaunchMetaData.launchForCleanData = value.launchForCleanData;
+            meta.storeId = launchInfo.storeId;
+            MetaDataManager::GetInstance().SaveMeta(meta.GetAutoLaunchKey(), autoLaunchMetaData, true);
         }
     }
-    StoreMetaData meta = MakeMetaData(bundleName, userId, deviceId);
-    for (const auto &[storeId, value] : maps) {
-        meta.storeId = storeId;
-        MetaDataManager::GetInstance().SaveMeta(meta.GetAutoLaunchKey(), value, true);
+}
+
+bool DataShareServiceImpl::AllowCleanDataLaunchApp(const Event &event, bool launchForCleanData)
+{
+    auto &evt = static_cast<const RemoteChangeEvent &>(event);
+    auto dataInfo = evt.GetDataInfo();
+    // 1 means CLOUD_DATA_CLEAN
+    if (dataInfo.changeType == 1) {
+        return launchForCleanData; // Applications can be started by default
     }
+    return true;
 }
 
 void DataShareServiceImpl::AutoLaunch(const Event &event)
@@ -554,21 +615,30 @@ void DataShareServiceImpl::AutoLaunch(const Event &event)
     StoreMetaData meta = MakeMetaData(dataInfo.bundleName, dataInfo.userId, dataInfo.deviceId, dataInfo.storeId);
     AutoLaunchMetaData autoLaunchMetaData;
     if (!MetaDataManager::GetInstance().LoadMeta(std::move(meta.GetAutoLaunchKey()), autoLaunchMetaData, true)) {
-        return;
+        meta.storeId = "";
+        if (!MetaDataManager::GetInstance().LoadMeta(std::move(meta.GetAutoLaunchKey()), autoLaunchMetaData, true)) {
+            ZLOGE("No launch meta without storeId, bundleName = %{public}s.", dataInfo.bundleName.c_str());
+            return;
+        }
     }
-    if (autoLaunchMetaData.datas.empty()) {
+    if (autoLaunchMetaData.datas.empty() || !AllowCleanDataLaunchApp(event, autoLaunchMetaData.launchForCleanData)) {
         return;
     }
-    std::vector<std::string> uris;
     for (const auto &[uri, metaTables] : autoLaunchMetaData.datas) {
-        for (const auto &table : dataInfo.tables)
-        if (std::find(metaTables.begin(), metaTables.end(), table) != metaTables.end()) {
-            uris.emplace_back(uri);
-            break;
+        if (dataInfo.tables.empty() && dataInfo.changeType == 1) {
+            ZLOGI("Start to connect extension, bundlename = %{public}s.", dataInfo.bundleName.c_str());
+            AAFwk::WantParams wantParams;
+            ExtensionConnectAdaptor::TryAndWait(uri, dataInfo.bundleName, wantParams);
+            return;
+        }
+        for (const auto &table : dataInfo.tables) {
+            if (std::find(metaTables.begin(), metaTables.end(), table) != metaTables.end()) {
+                ZLOGI("Find table, start to connect extension, bundlename = %{public}s.", dataInfo.bundleName.c_str());
+                AAFwk::WantParams wantParams;
+                ExtensionConnectAdaptor::TryAndWait(uri, dataInfo.bundleName, wantParams);
+                break;
+            }
         }
-    }
-    for (const auto &uri : uris) {
-        ExtensionConnectAdaptor::TryAndWait(uri, dataInfo.bundleName);
     }
 }
 
@@ -602,6 +672,8 @@ int32_t DataShareServiceImpl::DataShareStatic::OnAppUninstall(const std::string
     TemplateData::Delete(bundleName, user);
     NativeRdb::RdbHelper::ClearCache();
     BundleMgrProxy::GetInstance()->Delete(bundleName, user);
+    uint32_t tokenId = Security::AccessToken::AccessTokenKit::GetHapTokenID(user, bundleName, index);
+    DBDelegate::EraseStoreCache(tokenId);
     return E_OK;
 }
 
@@ -630,6 +702,15 @@ int32_t DataShareServiceImpl::DataShareStatic::OnAppUpdate(const std::string &bu
     return E_OK;
 }
 
+int32_t DataShareServiceImpl::DataShareStatic::OnClearAppStorage(const std::string &bundleName,
+    int32_t user, int32_t index, int32_t tokenId)
+{
+    ZLOGI("ClearAppStorage user=%{public}d, index=%{public}d, token:0x%{public}x, bundleName=%{public}s",
+        user, index, tokenId, bundleName.c_str());
+    DBDelegate::EraseStoreCache(tokenId);
+    return E_OK;
+}
+
 int32_t DataShareServiceImpl::OnAppUninstall(const std::string &bundleName, int32_t user, int32_t index)
 {
     ZLOGI("AppUninstall user=%{public}d, index=%{public}d, bundleName=%{public}s",
@@ -745,7 +826,8 @@ int32_t DataShareServiceImpl::EnableSilentProxy(const std::string &uri, bool ena
 
 int32_t DataShareServiceImpl::GetSilentProxyStatus(const std::string &uri, bool isCreateHelper)
 {
-    XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
+    XCollie xcollie(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__),
+        HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     uint32_t callerTokenId = IPCSkeleton::GetCallingTokenID();
     if (isCreateHelper) {
         auto errCode = GetBMSAndMetaDataStatus(uri, callerTokenId);
@@ -776,7 +858,8 @@ int32_t DataShareServiceImpl::GetSilentProxyStatus(const std::string &uri, bool
 int32_t DataShareServiceImpl::RegisterObserver(const std::string &uri,
     const sptr<OHOS::IRemoteObject> &remoteObj)
 {
-    XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG);
+    XCollie xcollie(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__),
+        HiviewDFX::XCOLLIE_FLAG_LOG);
     auto callerTokenId = IPCSkeleton::GetCallingTokenID();
     DataProviderConfig providerConfig(uri, callerTokenId);
     auto [errCode, providerInfo] = providerConfig.GetProviderInfo();
@@ -809,7 +892,8 @@ int32_t DataShareServiceImpl::RegisterObserver(const std::string &uri,
 int32_t DataShareServiceImpl::UnregisterObserver(const std::string &uri,
     const sptr<OHOS::IRemoteObject> &remoteObj)
 {
-    XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG);
+    XCollie xcollie(std::string(LOG_TAG) + "::" + std::string(__FUNCTION__),
+        HiviewDFX::XCOLLIE_FLAG_LOG);
     auto callerTokenId = IPCSkeleton::GetCallingTokenID();
     DataProviderConfig providerConfig(uri, callerTokenId);
     auto [errCode, providerInfo] = providerConfig.GetProviderInfo();
@@ -839,37 +923,42 @@ int32_t DataShareServiceImpl::UnregisterObserver(const std::string &uri,
     return obsMgrClient->UnregisterObserver(Uri(uri), obServer);
 }
 
-int32_t DataShareServiceImpl::Execute(const std::string &uri, const int32_t tokenId,
-    bool isRead, ExecuteCallback callback)
+std::pair<int32_t, int32_t> DataShareServiceImpl::ExecuteEx(const std::string &uri, const std::string &extUri,
+    const int32_t tokenId, bool isRead, ExecuteCallbackEx callback)
 {
     DataProviderConfig providerConfig(uri, tokenId);
-    auto [errCode, provider] = providerConfig.GetProviderInfo();
+    auto [errCode, providerInfo] = providerConfig.GetProviderInfo();
     if (errCode != E_OK) {
         ZLOGE("Provider failed! token:0x%{public}x,ret:%{public}d,uri:%{public}s", tokenId,
-            errCode, URIUtils::Anonymous(provider.uri).c_str());
+            errCode, URIUtils::Anonymous(providerInfo.uri).c_str());
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_GET_SUPPLIER,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::SUPPLIER_ERROR);
-        return errCode;
+        return std::make_pair(errCode, 0);
     }
-    std::string permission = isRead ? provider.readPermission : provider.writePermission;
+    std::string permission = isRead ? providerInfo.readPermission : providerInfo.writePermission;
     if (!permission.empty() && !PermitDelegate::VerifyPermission(permission, tokenId)) {
         ZLOGE("Permission denied! token:0x%{public}x, permission:%{public}s, uri:%{public}s",
-            tokenId, permission.c_str(), URIUtils::Anonymous(provider.uri).c_str());
+            tokenId, permission.c_str(), URIUtils::Anonymous(providerInfo.uri).c_str());
         RADAR_REPORT(__FUNCTION__, RadarReporter::SILENT_ACCESS, RadarReporter::PROXY_PERMISSION,
             RadarReporter::FAILED, RadarReporter::ERROR_CODE, RadarReporter::PERMISSION_DENIED_ERROR);
-        return ERROR_PERMISSION_DENIED;
+        return std::make_pair(ERROR_PERMISSION_DENIED, 0);
     }
     DataShareDbConfig dbConfig;
-    auto [code, metaData, dbDelegate] = dbConfig.GetDbConfig(provider.uri,
-        provider.hasExtension, provider.bundleName, provider.storeName,
-        provider.singleton ? 0 : provider.currentUserId);
+    std::string extensionUri = extUri;
+    if (extensionUri.empty()) {
+        extensionUri = providerInfo.extensionUri;
+    }
+    DataShareDbConfig::DbConfig config {providerInfo.uri, extensionUri, providerInfo.bundleName,
+        providerInfo.storeName, providerInfo.backup,
+        providerInfo.singleton ? 0 : providerInfo.currentUserId, providerInfo.hasExtension};
+    auto [code, metaData, dbDelegate] = dbConfig.GetDbConfig(config);
     if (code != E_OK) {
         ZLOGE("Get dbConfig fail,bundleName:%{public}s,tableName:%{public}s,tokenId:0x%{public}x, uri:%{public}s",
-            provider.bundleName.c_str(), provider.tableName.c_str(), tokenId,
-            URIUtils::Anonymous(provider.uri).c_str());
-        return code;
+            providerInfo.bundleName.c_str(), providerInfo.tableName.c_str(), tokenId,
+            URIUtils::Anonymous(providerInfo.uri).c_str());
+        return std::make_pair(code, 0);
     }
-    return callback(provider, metaData, dbDelegate);
+    return callback(providerInfo, metaData, dbDelegate);
 }
 
 int32_t DataShareServiceImpl::GetBMSAndMetaDataStatus(const std::string &uri, const int32_t tokenId)
@@ -884,7 +973,7 @@ int32_t DataShareServiceImpl::GetBMSAndMetaDataStatus(const std::string &uri, co
     if (errCode != E_OK) {
         ZLOGE("CalledInfo failed! token:0x%{public}x,ret:%{public}d,uri:%{public}s", tokenId,
             errCode, URIUtils::Anonymous(calledInfo.uri).c_str());
-        return E_BMS_NOT_READY;
+        return errCode;
     }
     DataShareDbConfig dbConfig;
     auto [code, metaData] = dbConfig.GetMetaData(calledInfo.uri, calledInfo.bundleName,
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.h b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.h
index 261f51c7c5052ec833dfb867d79926490c3f83be..634322ccc33dfffdce4aec9b3f9960d1892f85a1 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_impl.h
@@ -42,19 +42,15 @@
 #include "visibility.h"
 
 namespace OHOS::DataShare {
-class API_EXPORT DataShareServiceImpl : public DataShareServiceStub {
+class DataShareServiceImpl : public DataShareServiceStub {
 public:
     using Handler = std::function<void(int, std::map<std::string, std::vector<std::string>> &)>;
-    using ExecuteCallback = std::function<int32_t(DataProviderConfig::ProviderInfo &,
+    using ExecuteCallbackEx = std::function<std::pair<int32_t, int32_t>(DataProviderConfig::ProviderInfo &,
         DistributedData::StoreMetaData &, std::shared_ptr<DBDelegate>)>;
     DataShareServiceImpl() = default;
     virtual ~DataShareServiceImpl();
-    int32_t Insert(const std::string &uri, const DataShareValuesBucket &valuesBucket) override;
-    int32_t Update(const std::string &uri, const DataSharePredicates &predicate,
-                   const DataShareValuesBucket &valuesBucket) override;
-    int32_t Delete(const std::string &uri, const DataSharePredicates &predicate) override;
-    std::shared_ptr<DataShareResultSet> Query(const std::string &uri, const DataSharePredicates &predicates,
-                                              const std::vector<std::string> &columns, int &errCode) override;
+    std::shared_ptr<DataShareResultSet> Query(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicates, const std::vector<std::string> &columns, int &errCode) override;
     int32_t AddTemplate(const std::string &uri, const int64_t subscriberId, const Template &tplt) override;
     int32_t DelTemplate(const std::string &uri, const int64_t subscriberId) override;
     std::vector<OperationResult> Publish(const Data &data, const std::string &bundleNameOfProvider) override;
@@ -87,14 +83,21 @@ public:
     int32_t GetSilentProxyStatus(const std::string &uri, bool isCreateHelper) override;
     int32_t RegisterObserver(const std::string &uri, const sptr<OHOS::IRemoteObject> &remoteObj) override;
     int32_t UnregisterObserver(const std::string &uri, const sptr<OHOS::IRemoteObject> &remoteObj) override;
-
+    std::pair<int32_t, int32_t> InsertEx(const std::string &uri, const std::string &extUri,
+        const DataShareValuesBucket &valuesBucket) override;
+    std::pair<int32_t, int32_t> UpdateEx(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket) override;
+    std::pair<int32_t, int32_t> DeleteEx(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicate) override;
 private:
+    class SystemAbilityStatusChangeListener;
     using StaticActs = DistributedData::StaticActs;
     class DataShareStatic : public StaticActs {
     public:
         ~DataShareStatic() override {};
         int32_t OnAppUninstall(const std::string &bundleName, int32_t user, int32_t index) override;
         int32_t OnAppUpdate(const std::string &bundleName, int32_t user, int32_t index) override;
+        int32_t OnClearAppStorage(const std::string &bundleName, int32_t user, int32_t index, int32_t tokenId) override;
     };
     class Factory {
     public:
@@ -108,18 +111,21 @@ private:
         TimerReceiver() = default;
         explicit TimerReceiver(const EventFwk::CommonEventSubscribeInfo &subscriberInfo);
         virtual ~TimerReceiver() = default;
-        virtual void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override;
+        void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override;
     };
     void RegisterDataShareServiceInfo();
     void RegisterHandler();
     bool SubscribeTimeChanged();
     bool NotifyChange(const std::string &uri);
     bool GetCallerBundleName(std::string &bundleName);
-    int32_t Execute(const std::string &uri, const int32_t tokenId, bool isRead, ExecuteCallback callback);
+    std::pair<int32_t, int32_t> ExecuteEx(const std::string &uri, const std::string &extUri, const int32_t tokenId,
+        bool isRead, ExecuteCallbackEx callback);
     int32_t GetBMSAndMetaDataStatus(const std::string &uri, const int32_t tokenId);
-    void InitSubEvent();
+    void SubscribeCommonEvent();
+    static void InitSubEvent();
     void AutoLaunch(const DistributedData::Event &event);
     void SubscribeChange();
+    bool AllowCleanDataLaunchApp(const DistributedData::Event &event, bool launchForCleanData);
     static void SaveLaunchInfo(const std::string &bundleName, const std::string &userId,
         const std::string &deviceId);
     static DistributedData::StoreMetaData MakeMetaData(const std::string &bundleName, const std::string &userId,
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.cpp b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.cpp
index acad4229d5262bfed6a1b5f3109158be5396386b..df4b59e5218ff04fd9902f32dd85095244578f32 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.cpp
@@ -38,52 +38,55 @@ bool DataShareServiceStub::CheckInterfaceToken(MessageParcel &data)
     return true;
 }
 
-int32_t DataShareServiceStub::OnInsert(MessageParcel &data, MessageParcel &reply)
+int32_t DataShareServiceStub::OnInsertEx(MessageParcel &data, MessageParcel &reply)
 {
     std::string uri;
+    std::string extUri;
     DataShareValuesBucket bucket;
-    if (!ITypesUtil::Unmarshal(data, uri, bucket.valuesMap)) {
+    if (!ITypesUtil::Unmarshal(data, uri, extUri, bucket.valuesMap)) {
         ZLOGE("Unmarshal uri:%{public}s bucket size:%{public}zu", DistributedData::Anonymous::Change(uri).c_str(),
             bucket.valuesMap.size());
         return IPC_STUB_INVALID_DATA_ERR;
     }
-    int32_t status = Insert(uri, bucket);
-    if (!ITypesUtil::Marshal(reply, status)) {
-        ZLOGE("Marshal status:0x%{public}x", status);
+    auto [errCode, status] = InsertEx(uri, extUri, bucket);
+    if (!ITypesUtil::Marshal(reply, errCode, status)) {
+        ZLOGE("Marshal errCode: 0x%{public}x, status: 0x%{public}x", errCode, status);
         return IPC_STUB_WRITE_PARCEL_ERR;
     }
     return 0;
 }
 
-int32_t DataShareServiceStub::OnUpdate(MessageParcel &data, MessageParcel &reply)
+int32_t DataShareServiceStub::OnUpdateEx(MessageParcel &data, MessageParcel &reply)
 {
     std::string uri;
+    std::string extUri;
     DataSharePredicates predicate;
     DataShareValuesBucket bucket;
-    if (!ITypesUtil::Unmarshal(data, uri, predicate, bucket.valuesMap)) {
+    if (!ITypesUtil::Unmarshal(data, uri, extUri, predicate, bucket.valuesMap)) {
         ZLOGE("Unmarshal uri:%{public}s bucket size:%{public}zu", DistributedData::Anonymous::Change(uri).c_str(),
             bucket.valuesMap.size());
         return IPC_STUB_INVALID_DATA_ERR;
     }
-    int32_t status = Update(uri, predicate, bucket);
-    if (!ITypesUtil::Marshal(reply, status)) {
-        ZLOGE("Marshal status:0x%{public}x", status);
+    auto [errCode, status] = UpdateEx(uri, extUri, predicate, bucket);
+    if (!ITypesUtil::Marshal(reply, errCode, status)) {
+        ZLOGE("Marshal errCode: 0x%{public}x, status: 0x%{public}x", errCode, status);
         return IPC_STUB_WRITE_PARCEL_ERR;
     }
     return 0;
 }
 
-int32_t DataShareServiceStub::OnDelete(MessageParcel &data, MessageParcel &reply)
+int32_t DataShareServiceStub::OnDeleteEx(MessageParcel &data, MessageParcel &reply)
 {
     std::string uri;
+    std::string extUri;
     DataSharePredicates predicate;
-    if (!ITypesUtil::Unmarshal(data, uri, predicate)) {
+    if (!ITypesUtil::Unmarshal(data, uri, extUri, predicate)) {
         ZLOGE("Unmarshal uri:%{public}s", DistributedData::Anonymous::Change(uri).c_str());
         return IPC_STUB_INVALID_DATA_ERR;
     }
-    int32_t status = Delete(uri, predicate);
-    if (!ITypesUtil::Marshal(reply, status)) {
-        ZLOGE("Marshal status:0x%{public}x", status);
+    auto [errCode, status] = DeleteEx(uri, extUri, predicate);
+    if (!ITypesUtil::Marshal(reply, errCode, status)) {
+        ZLOGE("Marshal errCode: 0x%{public}x, status: 0x%{public}x", errCode, status);
         return IPC_STUB_WRITE_PARCEL_ERR;
     }
     return 0;
@@ -92,15 +95,16 @@ int32_t DataShareServiceStub::OnDelete(MessageParcel &data, MessageParcel &reply
 int32_t DataShareServiceStub::OnQuery(MessageParcel &data, MessageParcel &reply)
 {
     std::string uri;
+    std::string extUri;
     DataSharePredicates predicate;
     std::vector<std::string> columns;
-    if (!ITypesUtil::Unmarshal(data, uri, predicate, columns)) {
+    if (!ITypesUtil::Unmarshal(data, uri, extUri, predicate, columns)) {
         ZLOGE("Unmarshal uri:%{public}s columns size:%{public}zu", DistributedData::Anonymous::Change(uri).c_str(),
             columns.size());
         return IPC_STUB_INVALID_DATA_ERR;
     }
     int status = 0;
-    auto result = ISharedResultSet::WriteToParcel(Query(uri, predicate, columns, status), reply);
+    auto result = ISharedResultSet::WriteToParcel(Query(uri, extUri, predicate, columns, status), reply);
     if (!ITypesUtil::Marshal(reply, status)) {
         ZLOGE("Marshal status:0x%{public}x", status);
         return IPC_STUB_WRITE_PARCEL_ERR;
@@ -327,7 +331,7 @@ int DataShareServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, Me
         std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
     }
     auto callingPid = IPCSkeleton::GetCallingPid();
-    if (code != DATA_SHARE_SERVICE_CMD_QUERY) {
+    if (code != DATA_SHARE_SERVICE_CMD_QUERY && code != DATA_SHARE_SERVICE_CMD_GET_SILENT_PROXY_STATUS) {
         ZLOGI("code:%{public}u, callingPid:%{public}d", code, callingPid);
     }
     if (!CheckInterfaceToken(data)) {
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.h b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.h
index 9daede9747bfc18d822379b19c8b7a9a84c7fd2c..d13b2099344894592e4804216ed2b2ef2a231625 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/data_share_service_stub.h
@@ -29,9 +29,6 @@ public:
 private:
     static constexpr std::chrono::milliseconds TIME_THRESHOLD = std::chrono::milliseconds(500);
     static bool CheckInterfaceToken(MessageParcel& data);
-    int32_t OnInsert(MessageParcel& data, MessageParcel& reply);
-    int32_t OnUpdate(MessageParcel& data, MessageParcel& reply);
-    int32_t OnDelete(MessageParcel& data, MessageParcel& reply);
     int32_t OnQuery(MessageParcel& data, MessageParcel& reply);
     int32_t OnAddTemplate(MessageParcel& data, MessageParcel& reply);
     int32_t OnDelTemplate(MessageParcel& data, MessageParcel& reply);
@@ -51,11 +48,11 @@ private:
     int32_t OnGetSilentProxyStatus(MessageParcel& data, MessageParcel& reply);
     int32_t OnRegisterObserver(MessageParcel& data, MessageParcel& reply);
     int32_t OnUnregisterObserver(MessageParcel& data, MessageParcel& reply);
+    int32_t OnInsertEx(MessageParcel& data, MessageParcel& reply);
+    int32_t OnUpdateEx(MessageParcel& data, MessageParcel& reply);
+    int32_t OnDeleteEx(MessageParcel& data, MessageParcel& reply);
     using RequestHandle = int (DataShareServiceStub::*)(MessageParcel &, MessageParcel &);
     static constexpr RequestHandle HANDLERS[DATA_SHARE_SERVICE_CMD_MAX] = {
-        &DataShareServiceStub::OnInsert,
-        &DataShareServiceStub::OnDelete,
-        &DataShareServiceStub::OnUpdate,
         &DataShareServiceStub::OnQuery,
         &DataShareServiceStub::OnAddTemplate,
         &DataShareServiceStub::OnDelTemplate,
@@ -74,7 +71,10 @@ private:
         &DataShareServiceStub::OnSetSilentSwitch,
         &DataShareServiceStub::OnGetSilentProxyStatus,
         &DataShareServiceStub::OnRegisterObserver,
-        &DataShareServiceStub::OnUnregisterObserver};
+        &DataShareServiceStub::OnUnregisterObserver,
+        &DataShareServiceStub::OnInsertEx,
+        &DataShareServiceStub::OnDeleteEx,
+        &DataShareServiceStub::OnUpdateEx};
     static constexpr int SLEEP_TIME = 300;
     static constexpr int TRY_TIMES = 5;
     std::atomic<bool> isReady_ = false;
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/idata_share_service.h b/datamgr_service/services/distributeddataservice/service/data_share/idata_share_service.h
index aa2da754aa2d58a7de165d45381b069222b72295..e57489fecdeda12978ad666a1fd1518c064aacc6 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/idata_share_service.h
+++ b/datamgr_service/services/distributeddataservice/service/data_share/idata_share_service.h
@@ -30,9 +30,6 @@ namespace OHOS::DataShare {
 class IDataShareService {
 public:
     enum {
-        DATA_SHARE_SERVICE_CMD_INSERT,
-        DATA_SHARE_SERVICE_CMD_DELETE,
-        DATA_SHARE_SERVICE_CMD_UPDATE,
         DATA_SHARE_SERVICE_CMD_QUERY,
         DATA_SHARE_SERVICE_CMD_ADD_TEMPLATE,
         DATA_SHARE_SERVICE_CMD_DEL_TEMPLATE,
@@ -52,18 +49,17 @@ public:
         DATA_SHARE_SERVICE_CMD_GET_SILENT_PROXY_STATUS,
         DATA_SHARE_SERVICE_CMD_REGISTER_OBSERVER,
         DATA_SHARE_SERVICE_CMD_UNREGISTER_OBSERVER,
+        DATA_SHARE_SERVICE_CMD_INSERTEX,
+        DATA_SHARE_SERVICE_CMD_DELETEEX,
+        DATA_SHARE_SERVICE_CMD_UPDATEEX,
         DATA_SHARE_SERVICE_CMD_MAX
     };
 
     enum { DATA_SHARE_ERROR = -1, DATA_SHARE_OK = 0 };
     DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.DataShare.IDataShareService");
 
-    virtual int32_t Insert(const std::string &uri, const DataShareValuesBucket &valuesBucket) = 0;
-    virtual int32_t Update(
-        const std::string &uri, const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket) = 0;
-    virtual int32_t Delete(const std::string &uri, const DataSharePredicates &predicate) = 0;
-    virtual std::shared_ptr<DataShareResultSet> Query(const std::string &uri, const DataSharePredicates &predicates,
-        const std::vector<std::string> &columns, int &errCode) = 0;
+    virtual std::shared_ptr<DataShareResultSet> Query(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicates, const std::vector<std::string> &columns, int &errCode) = 0;
     virtual int32_t AddTemplate(const std::string &uri, const int64_t subscriberId, const Template &tplt) = 0;
     virtual int32_t DelTemplate(const std::string &uri, const int64_t subscriberId) = 0;
     virtual std::vector<OperationResult> Publish(const Data &data, const std::string &bundleNameOfProvider) = 0;
@@ -91,6 +87,12 @@ public:
     virtual int32_t RegisterObserver(const std::string &uri, const sptr<OHOS::IRemoteObject> &remoteObj) = 0;
     virtual int32_t UnregisterObserver(const std::string &uri,
         const sptr<OHOS::IRemoteObject> &remoteObj) = 0;
+    virtual std::pair<int32_t, int32_t> InsertEx(
+        const std::string &uri, const std::string &extUri, const DataShareValuesBucket &valuesBucket) = 0;
+    virtual std::pair<int32_t, int32_t> UpdateEx(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicate, const DataShareValuesBucket &valuesBucket) = 0;
+    virtual std::pair<int32_t, int32_t> DeleteEx(const std::string &uri, const std::string &extUri,
+        const DataSharePredicates &predicate) = 0;
 };
 } // namespace OHOS::DataShare
 #endif // DISTRIBUTEDDATAFWK_IDATA_SHARE_SERVICE_H
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_proxy/load_config_from_data_proxy_node_strategy.cpp b/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_proxy/load_config_from_data_proxy_node_strategy.cpp
index 17f7436699c185b32f13f09f8d53b19616f9c09d..c796152ca0fcd267f999c1d713a424cecacb7785 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_proxy/load_config_from_data_proxy_node_strategy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_proxy/load_config_from_data_proxy_node_strategy.cpp
@@ -30,8 +30,8 @@ bool LoadConfigFromDataProxyNodeStrategy::operator()(std::shared_ptr<Context> co
         return false;
     }
     context->type = PUBLISHED_DATA_TYPE;
-    if (!BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
-        context->calledBundleName, context->currentUserId, context->bundleInfo)) {
+    if (BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
+        context->calledBundleName, context->currentUserId, context->bundleInfo) != E_OK) {
         ZLOGE("GetBundleInfoFromBMS failed! bundleName: %{public}s", context->calledBundleName.c_str());
         context->errCode = E_BUNDLE_NAME_NOT_EXIST;
         return false;
@@ -40,9 +40,9 @@ bool LoadConfigFromDataProxyNodeStrategy::operator()(std::shared_ptr<Context> co
         context->permission = "reject";
         return true;
     }
-    for (auto &hapModuleInfo : context->bundleInfo.hapModuleInfos) {
+    for (auto const &hapModuleInfo : context->bundleInfo.hapModuleInfos) {
         auto proxyDatas = hapModuleInfo.proxyDatas;
-        for (auto &proxyData : proxyDatas) {
+        for (auto const &proxyData : proxyDatas) {
             if (proxyData.uri != context->uri) {
                 continue;
             }
@@ -51,13 +51,11 @@ bool LoadConfigFromDataProxyNodeStrategy::operator()(std::shared_ptr<Context> co
             if (context->permission.empty()) {
                 context->permission = "reject";
             }
-            auto [ret, properties] = DataShareProfileConfig::GetDataProperties(
-                std::vector<AppExecFwk::Metadata>{proxyData.metadata}, hapModuleInfo.resourcePath,
-                hapModuleInfo.hapPath, DATA_SHARE_PROPERTIES_META);
-            if (ret == ERROR || ret == NOT_FOUND) {
+            auto properties = proxyData.profileInfo;
+            if (properties.resultCode == ERROR || properties.resultCode == NOT_FOUND) {
                 return true;
             }
-            GetContextInfoFromDataProperties(properties, hapModuleInfo.moduleName, context);
+            GetContextInfoFromDataProperties(properties.profile, hapModuleInfo.moduleName, context);
             return true;
         }
     }
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_share/load_config_from_data_share_bundle_info_strategy.cpp b/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_share/load_config_from_data_share_bundle_info_strategy.cpp
index f9b2c72d2c50773b92bc4adc7428d586ef361955..edec38acfeb2429d138807b0cb733194e73b98aa 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_share/load_config_from_data_share_bundle_info_strategy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/strategies/data_share/load_config_from_data_share_bundle_info_strategy.cpp
@@ -18,6 +18,7 @@
 
 #include "bundle_mgr_proxy.h"
 #include "data_share_profile_config.h"
+#include "datashare_errno.h"
 #include "log_print.h"
 #include "uri_utils.h"
 #include "utils/anonymous.h"
@@ -79,25 +80,24 @@ bool LoadConfigFromDataShareBundleInfoStrategy::operator()(std::shared_ptr<Conte
         ZLOGE("LoadConfigFromUri failed! bundleName: %{public}s", context->calledBundleName.c_str());
         return false;
     }
-    if (!BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
-        context->calledBundleName, context->currentUserId, context->bundleInfo)) {
+    if (BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
+        context->calledBundleName, context->currentUserId, context->bundleInfo) != E_OK) {
         ZLOGE("GetBundleInfoFromBMS failed! bundleName: %{public}s", context->calledBundleName.c_str());
         return false;
     }
-    for (auto &item : context->bundleInfo.extensionInfos) {
+    for (auto const &item : context->bundleInfo.extensionInfos) {
         if (item.type == AppExecFwk::ExtensionAbilityType::DATASHARE) {
             context->permission = context->isRead ? item.readPermission : item.writePermission;
 
-            auto [ret, profileInfo] = DataShareProfileConfig::GetDataProperties(item.metadata,
-                item.resourcePath, item.hapPath, DATA_SHARE_EXTENSION_META);
-            if (ret == NOT_FOUND) {
+            auto profileInfo = item.profileInfo;
+            if (profileInfo.resultCode == NOT_FOUND) {
                 return true; // optional meta data config
             }
-            if (ret == ERROR) {
+            if (profileInfo.resultCode == ERROR) {
                 ZLOGE("parse failed! %{public}s", context->calledBundleName.c_str());
                 return false;
             }
-            LoadConfigFromProfile(profileInfo, context);
+            LoadConfigFromProfile(profileInfo.profile, context);
             return true;
         }
     }
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/strategies/general/load_config_data_info_strategy.cpp b/datamgr_service/services/distributeddataservice/service/data_share/strategies/general/load_config_data_info_strategy.cpp
index f47d62e3cd7a15d36f4d5b7d00c7d5d0521a4d9e..a48ad89a8b816ac787683b9bb4c7f8c4eddf3f62 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/strategies/general/load_config_data_info_strategy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/strategies/general/load_config_data_info_strategy.cpp
@@ -54,7 +54,8 @@ bool LoadConfigNormalDataInfoStrategy::operator()(std::shared_ptr<Context> conte
     DistributedData::StoreMetaData metaData;
     if (!QueryMetaData(context->calledBundleName, context->calledStoreName, metaData, context->currentUserId)) {
         // connect extension and retry
-        ExtensionConnectAdaptor::TryAndWait(context->uri, context->calledBundleName);
+        AAFwk::WantParams wantParams;
+        ExtensionConnectAdaptor::TryAndWait(context->uri, context->calledBundleName, wantParams);
         if (!QueryMetaData(context->calledBundleName, context->calledStoreName, metaData, context->currentUserId)) {
             ZLOGE("QueryMetaData fail, %{public}s", DistributedData::Anonymous::Change(context->uri).c_str());
             context->errCode = NativeRdb::E_DB_NOT_EXIST;
@@ -74,7 +75,8 @@ bool LoadConfigSingleDataInfoStrategy::operator()(std::shared_ptr<Context> conte
     DistributedData::StoreMetaData metaData;
     if (!QueryMetaData(context->calledBundleName, context->calledStoreName, metaData, 0)) {
         // connect extension and retry
-        ExtensionConnectAdaptor::TryAndWait(context->uri, context->calledBundleName);
+        AAFwk::WantParams wantParams;
+        ExtensionConnectAdaptor::TryAndWait(context->uri, context->calledBundleName, wantParams);
         if (!QueryMetaData(context->calledBundleName, context->calledStoreName, metaData, 0)) {
             ZLOGE("QueryMetaData fail, %{public}s", DistributedData::Anonymous::Change(context->uri).c_str());
             context->errCode = NativeRdb::E_DB_NOT_EXIST;
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/subscriber_managers/rdb_subscriber_manager.cpp b/datamgr_service/services/distributeddataservice/service/data_share/subscriber_managers/rdb_subscriber_manager.cpp
index 1ff14c391bd30541e7bf9fb97700ca1408ac367b..3ad175de106b39a0bd6a852a84ad1fd1cb8090f6 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/subscriber_managers/rdb_subscriber_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/subscriber_managers/rdb_subscriber_manager.cpp
@@ -248,14 +248,19 @@ void RdbSubscriberManager::Emit(const std::string &uri, int32_t userId,
     if (!URIUtils::IsDataProxyURI(uri)) {
         return;
     }
-    rdbCache_.ForEach([&uri, &userId, &metaData, this](const Key &key, std::vector<ObserverNode> &val) {
+    bool hasObserver = false;
+    rdbCache_.ForEach([&uri, &userId, &metaData, &hasObserver, this](const Key &key, std::vector<ObserverNode> &val) {
         if (key.uri != uri) {
             return false;
         }
+        hasObserver = true;
         Notify(key, userId, val, metaData.dataDir, metaData.version);
         SetObserverNotifyOnEnabled(val);
         return false;
     });
+    if (!hasObserver) {
+        return;
+    }
     SchedulerManager::GetInstance().Execute(
         uri, userId, metaData.dataDir, metaData.version, metaData.bundleName);
 }
@@ -321,7 +326,7 @@ int RdbSubscriberManager::Notify(const Key &key, int32_t userId, const std::vect
     DistributedData::StoreMetaData meta;
     meta.dataDir = rdbDir;
     meta.bundleName = key.bundleName;
-    auto delegate = DBDelegate::Create(meta);
+    auto delegate = DBDelegate::Create(meta, key.uri);
     if (delegate == nullptr) {
         ZLOGE("Create fail %{public}s %{public}s", DistributedData::Anonymous::Change(key.uri).c_str(),
             key.bundleName.c_str());
diff --git a/datamgr_service/services/distributeddataservice/service/data_share/sys_event_subscriber.cpp b/datamgr_service/services/distributeddataservice/service/data_share/sys_event_subscriber.cpp
index e802950ae503f0cb4b2b71ef4e649eb6adcf40d1..b0fe15ee2318ac49b302c0b461f0fdd80de88cd6 100644
--- a/datamgr_service/services/distributeddataservice/service/data_share/sys_event_subscriber.cpp
+++ b/datamgr_service/services/distributeddataservice/service/data_share/sys_event_subscriber.cpp
@@ -47,7 +47,9 @@ void SysEventSubscriber::NotifyDataShareReady()
     AAFwk::Want want;
     want.SetAction("usual.event.DATA_SHARE_READY");
     EventFwk::CommonEventData CommonEventData { want };
-    if (!EventFwk::CommonEventManager::PublishCommonEvent(CommonEventData)) {
+    EventFwk::CommonEventPublishInfo publishInfo;
+    publishInfo.SetSticky(true);
+    if (!EventFwk::CommonEventManager::PublishCommonEvent(CommonEventData, publishInfo)) {
         ZLOGE("Notify dataShare ready failed.");
         return;
     }
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.cpp
index c50f1236e7fcc67a7406fdc3a0c26aef0efe1e67..fc72e1cfc6c4bcd37d5d8c26c80ab6a9124fc93d 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.cpp
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.cpp
@@ -23,132 +23,24 @@
 #include "log_print.h"
 #include "user_delegate.h"
 #include "utils/anonymous.h"
-
+#include "metadata/store_meta_data.h"
+#include "metadata/meta_data_manager.h"
 namespace OHOS::DistributedData {
+using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 class AuthHandlerStub : public AuthHandler {
 public:
     // override for mock auth in current version, need remove in the future
     bool CheckAccess(
-        int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId) override;
-
+        int localUserId, int peerUserId, const std::string &peerDeviceId,
+        int32_t authType, bool isSend = true) override;
 private:
     bool IsUserActive(const std::vector<UserStatus> &users, int32_t userId);
+    bool CheckUsers(int localUserId, int peerUserId, const std::string &peerDeviceId);
     static constexpr pid_t UID_CAPACITY = 10000;
     static constexpr int SYSTEM_USER = 0;
 };
 
-bool AuthHandler::CheckAccess(
-    int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId)
-{
-    auto group = GetGroupInfo(localUserId, appId, peerDeviceId);
-    if (group.groupType < GroupType::ALL_GROUP) {
-        ZLOGE("failed to parse group %{public}s)", group.groupId.c_str());
-        return false;
-    }
-    auto groupManager = GetGmInstance();
-    if (groupManager == nullptr || groupManager->checkAccessToGroup == nullptr) {
-        ZLOGE("failed to get group manager");
-        return false;
-    }
-    auto ret = groupManager->checkAccessToGroup(localUserId, appId.c_str(), group.groupId.c_str());
-    ZLOGD("check access to group ret:%{public}d", ret);
-    return ret == HC_SUCCESS;
-}
-
-int32_t AuthHandler::GetGroupType(
-    int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId)
-{
-    auto group = GetGroupInfo(localUserId, appId, peerDeviceId);
-    if (group.groupType < GroupType::ALL_GROUP) {
-        ZLOGE("failed to parse group json(%{public}d)", group.groupType);
-    }
-    return group.groupType;
-}
-
-AuthHandler::RelatedGroup AuthHandler::GetGroupInfo(
-    int32_t localUserId, const std::string &appId, const std::string &peerDeviceId)
-{
-    auto groupManager = GetGmInstance();
-    if (groupManager == nullptr || groupManager->getRelatedGroups == nullptr || groupManager->destroyInfo == nullptr) {
-        ZLOGE("failed to get group manager");
-        return {};
-    }
-    char *groupInfo = nullptr;
-    uint32_t groupNum = 0;
-    ZLOGI("get related groups, user:%{public}d, app:%{public}s", localUserId, appId.c_str());
-    auto ret = groupManager->getRelatedGroups(localUserId, appId.c_str(), peerDeviceId.c_str(), &groupInfo, &groupNum);
-    if (groupInfo == nullptr) {
-        ZLOGE("failed to get related groups, ret:%{public}d", ret);
-        return {};
-    }
-    ZLOGI("get related group json :%{public}s", groupInfo);
-    std::vector<RelatedGroup> groups;
-    RelatedGroup::Unmarshall(groupInfo, groups);
-    groupManager->destroyInfo(&groupInfo);
-
-    // same account has priority
-    std::sort(groups.begin(), groups.end(),
-        [](const RelatedGroup &group1, const RelatedGroup &group2) { return group1.groupType < group2.groupType; });
-    if (!groups.empty()) {
-        ZLOGI("get group type:%{public}d", groups.front().groupType);
-        return groups.front();
-    }
-    ZLOGD("there is no group to access to peer device:%{public}s", Anonymous::Change(peerDeviceId).c_str());
-    return {};
-}
-
-std::vector<std::string> AuthHandler::GetTrustedDevicesByType(
-    AUTH_GROUP_TYPE type, int32_t localUserId, const std::string &appId)
-{
-    auto groupManager = GetGmInstance();
-    if (groupManager == nullptr || groupManager->getRelatedGroups == nullptr
-        || groupManager->getTrustedDevices == nullptr || groupManager->destroyInfo == nullptr) {
-        ZLOGE("failed to get group manager");
-        return {};
-    }
-
-    char *groupsJson = nullptr;
-    uint32_t groupNum = 0;
-    ZLOGI("get joined groups, user:%{public}d, app:%{public}s, type:%{public}d", localUserId, appId.c_str(), type);
-    auto ret = groupManager->getJoinedGroups(localUserId, appId.c_str(), type, &groupsJson, &groupNum);
-    if (groupsJson == nullptr) {
-        ZLOGE("failed to get joined groups, ret:%{public}d", ret);
-        return {};
-    }
-    ZLOGI("get joined group json :%{public}s", groupsJson);
-    std::vector<RelatedGroup> groups;
-    RelatedGroup::Unmarshall(groupsJson, groups);
-    groupManager->destroyInfo(&groupsJson);
-
-    std::vector<std::string> trustedDevices;
-    for (const auto &group : groups) {
-        if (group.groupType != type) {
-            continue;
-        }
-        char *devicesJson = nullptr;
-        uint32_t devNum = 0;
-        ret = groupManager->getTrustedDevices(localUserId, appId.c_str(), group.groupId.c_str(), &devicesJson, &devNum);
-        if (devicesJson == nullptr) {
-            ZLOGE("failed to get trusted devicesJson, ret:%{public}d", ret);
-            return {};
-        }
-        ZLOGI("get trusted device json:%{public}s", devicesJson);
-        std::vector<TrustDevice> devices;
-        TrustDevice::Unmarshall(devicesJson, devices);
-        groupManager->destroyInfo(&devicesJson);
-        for (const auto &item : devices) {
-            auto &dmAdapter = DeviceManagerAdapter::GetInstance();
-            auto networkId = dmAdapter.ToNetworkID(item.authId);
-            auto uuid = dmAdapter.GetUuidByNetworkId(networkId);
-            trustedDevices.push_back(uuid);
-        }
-    }
-
-    return trustedDevices;
-}
-
-bool AuthHandlerStub::CheckAccess(
-    int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId)
+bool AuthHandlerStub::CheckUsers(int localUserId, int peerUserId, const std::string &peerDeviceId)
 {
     if (localUserId == SYSTEM_USER) {
         return peerUserId == SYSTEM_USER;
@@ -159,6 +51,17 @@ bool AuthHandlerStub::CheckAccess(
     return peerUserId != SYSTEM_USER && IsUserActive(localUsers, localUserId) && IsUserActive(peerUsers, peerUserId);
 }
 
+bool AuthHandlerStub::CheckAccess(
+    int localUserId, int peerUserId, const std::string &peerDeviceId, int32_t authType, bool isSend)
+{
+    if (authType == static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT) &&
+        !DmAdapter::GetInstance().IsSameAccount(peerDeviceId)) {
+        ZLOGE("CheckAccess failed.");
+        return false;
+    }
+    return CheckUsers(localUserId, peerUserId, peerDeviceId);
+}
+
 bool AuthHandlerStub::IsUserActive(const std::vector<UserStatus> &users, int32_t userId)
 {
     for (const auto &user : users) {
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.h b/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.h
index e6335c071bf53563dd6db3c00029283a03336f31..11a931993306d0ad1a572a482b3a8844af107666 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.h
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/auth_delegate.h
@@ -32,57 +32,7 @@ enum AUTH_GROUP_TYPE {
 class AuthHandler {
 public:
     virtual bool CheckAccess(
-        int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId);
-    virtual int32_t GetGroupType(
-        int localUserId, int peerUserId, const std::string &peerDeviceId, const std::string &appId);
-    virtual std::vector<std::string> GetTrustedDevicesByType(
-        AUTH_GROUP_TYPE type, int32_t localUserId, const std::string &appId);
-
-private:
-    struct RelatedGroup final : public Serializable {
-        int32_t groupType = -1;
-        std::string groupId;
-        RelatedGroup()
-        {
-        }
-        ~RelatedGroup()
-        {
-        }
-        RelatedGroup(const RelatedGroup &) = default;
-        RelatedGroup &operator=(const RelatedGroup &) = default;
-        bool Marshal(json &node) const override
-        {
-            SetValue(node[GET_NAME(groupType)], groupType);
-            SetValue(node[GET_NAME(groupId)], groupId);
-            return true;
-        }
-
-        bool Unmarshal(const json &node) override
-        {
-            GetValue(node, GET_NAME(groupType), groupType);
-            GetValue(node, GET_NAME(groupId), groupId);
-            return true;
-        }
-    };
-
-    struct TrustDevice final : public Serializable {
-        std::string authId; // udid
-        TrustDevice() = default;
-        TrustDevice(const TrustDevice &) = default;
-        TrustDevice &operator=(const TrustDevice &) = default;
-        bool Marshal(json &node) const override
-        {
-            SetValue(node[GET_NAME(authId)], authId);
-            return true;
-        }
-
-        bool Unmarshal(const json &node) override
-        {
-            GetValue(node, GET_NAME(authId), authId);
-            return true;
-        }
-    };
-    static RelatedGroup GetGroupInfo(int32_t localUserId, const std::string &appId, const std::string &peerDeviceId);
+        int localUserId, int peerUserId, const std::string &peerDeviceId, int32_t authType, bool isSend = true);
 };
 
 class AuthDelegate {
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
index be9c07e48e300decd0404f91cd959d19d2e203da..9d24138d4fc87b52eb7c5ebd08371f3f5e6ee817 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
@@ -37,7 +37,7 @@
 #include "utils/anonymous.h"
 #include "water_version_manager.h"
 #include "device_manager_adapter.h"
-#include "utils/anonymous.h"
+#include "app_id_mapping/app_id_mapping_config_manager.h"
 
 namespace OHOS::DistributedKv {
 using namespace DistributedData;
@@ -49,6 +49,31 @@ using ClearMode = DistributedDB::ClearMode;
 using DMAdapter = DistributedData::DeviceManagerAdapter;
 using DBInterceptedData = DistributedDB::InterceptedData;
 constexpr int UUID_WIDTH = 4;
+const std::map<DBStatus, KVDBGeneralStore::GenErr> KVDBGeneralStore::dbStatusMap_ = {
+    { DBStatus::OK, GenErr::E_OK },
+    { DBStatus::CLOUD_NETWORK_ERROR, GenErr::E_NETWORK_ERROR },
+    { DBStatus::CLOUD_LOCK_ERROR, GenErr::E_LOCKED_BY_OTHERS },
+    { DBStatus::CLOUD_FULL_RECORDS, GenErr::E_RECODE_LIMIT_EXCEEDED },
+    { DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT, GenErr::E_NO_SPACE_FOR_ASSET },
+    { DBStatus::CLOUD_SYNC_TASK_MERGED, GenErr::E_SYNC_TASK_MERGED },
+    { DBStatus::BUSY, GenErr::E_DB_ERROR },
+    { DBStatus::DB_ERROR, GenErr::E_DB_ERROR },
+    { DBStatus::INVALID_ARGS, GenErr::E_INVALID_ARGS },
+    { DBStatus::NOT_FOUND, GenErr::E_RECORD_NOT_FOUND },
+    { DBStatus::INVALID_VALUE_FIELDS, GenErr::E_INVALID_VALUE_FIELDS },
+    { DBStatus::INVALID_FIELD_TYPE, GenErr::E_INVALID_FIELD_TYPE },
+    { DBStatus::CONSTRAIN_VIOLATION, GenErr::E_CONSTRAIN_VIOLATION },
+    { DBStatus::INVALID_FORMAT, GenErr::E_INVALID_FORMAT },
+    { DBStatus::INVALID_QUERY_FORMAT, GenErr::E_INVALID_QUERY_FORMAT },
+    { DBStatus::INVALID_QUERY_FIELD, GenErr::E_INVALID_QUERY_FIELD },
+    { DBStatus::NOT_SUPPORT, GenErr::E_NOT_SUPPORT },
+    { DBStatus::TIME_OUT, GenErr::E_TIME_OUT },
+    { DBStatus::OVER_MAX_LIMITS, GenErr::E_OVER_MAX_LIMITS },
+    { DBStatus::EKEYREVOKED_ERROR, GenErr::E_SECURITY_LEVEL_ERROR },
+    { DBStatus::SECURITY_OPTION_CHECK_ERROR, GenErr::E_SECURITY_LEVEL_ERROR },
+};
+
+constexpr uint32_t LOCK_TIMEOUT = 3600; // second
 static DBSchema GetDBSchema(const Database &database)
 {
     DBSchema schema;
@@ -136,6 +161,9 @@ KVDBGeneralStore::KVDBGeneralStore(const StoreMetaData &meta)
           meta.instanceId)
 {
     observer_.storeId_ = meta.storeId;
+    StoreMetaDataLocal local;
+    MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), local, true);
+    isPublic_ = local.isPublic;
     DBStatus status = DBStatus::NOT_FOUND;
     manager_.SetKvStoreConfig({ meta.dataDir });
     std::unique_lock<decltype(rwMutex_)> lock(rwMutex_);
@@ -153,7 +181,6 @@ KVDBGeneralStore::KVDBGeneralStore(const StoreMetaData &meta)
     SetDBReceiveDataInterceptor(meta.storeType);
     delegate_->RegisterObserver({}, DistributedDB::OBSERVER_CHANGES_FOREIGN, &observer_);
     delegate_->RegisterObserver({}, DistributedDB::OBSERVER_CHANGES_CLOUD, &observer_);
-    InitWaterVersion(meta);
     if (DeviceMatrix::GetInstance().IsDynamic(meta) || DeviceMatrix::GetInstance().IsStatics(meta)) {
         delegate_->SetRemotePushFinishedNotify([meta](const DistributedDB::RemotePushNotifyInfo &info) {
             DeviceMatrix::GetInstance().OnExchanged(info.deviceId, meta, DeviceMatrix::ChangeType::CHANGE_REMOTE);
@@ -238,14 +265,17 @@ bool KVDBGeneralStore::IsBound()
     return isBound_;
 }
 
-int32_t KVDBGeneralStore::Close()
+int32_t KVDBGeneralStore::Close(bool isForce)
 {
-    std::unique_lock<decltype(rwMutex_)> lock(rwMutex_);
+    std::unique_lock<decltype(rwMutex_)> lock(rwMutex_, std::chrono::seconds(isForce ? LOCK_TIMEOUT : 0));
+    if (!lock) {
+        return GeneralError::E_BUSY;
+    }
+
     if (delegate_ == nullptr) {
         return GeneralError::E_OK;
     }
-    int32_t count = delegate_->GetTaskCount();
-    if (count > 0) {
+    if (!isForce && delegate_->GetTaskCount() > 0) {
         return GeneralError::E_BUSY;
     }
     if (delegate_ != nullptr) {
@@ -285,15 +315,15 @@ int32_t KVDBGeneralStore::Replace(const std::string &table, VBucket &&value)
     return GeneralError::E_NOT_SUPPORT;
 }
 
-std::shared_ptr<Cursor> KVDBGeneralStore::Query(
+std::pair<int32_t, std::shared_ptr<Cursor>> KVDBGeneralStore::Query(
     __attribute__((unused)) const std::string &table, const std::string &sql, Values &&args)
 {
-    return nullptr;
+    return { GeneralError::E_NOT_SUPPORT, nullptr };
 }
 
-std::shared_ptr<Cursor> KVDBGeneralStore::Query(const std::string &table, GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> KVDBGeneralStore::Query(const std::string &table, GenQuery &query)
 {
-    return nullptr;
+    return { GeneralError::E_NOT_SUPPORT, nullptr };
 }
 
 int32_t KVDBGeneralStore::MergeMigratedData(const std::string &tableName, VBuckets &&values)
@@ -320,20 +350,14 @@ KVDBGeneralStore::DBSyncCallback KVDBGeneralStore::GetDBSyncCompleteCB(DetailAsy
     };
 }
 
-DBStatus KVDBGeneralStore::CloudSync(const Devices &devices, int32_t mode, DetailAsync async, int64_t wait)
+DBStatus KVDBGeneralStore::CloudSync(
+    const Devices &devices, DistributedDB::SyncMode cloudSyncMode, DetailAsync async, int64_t wait)
 {
-    auto syncMode = GeneralStore::GetSyncMode(static_cast<uint32_t>(mode));
-    if (syncMode < CLOUD_BEGIN || syncMode >= CLOUD_END) {
-        ZLOGE("Do not need to cloud sync! devices count:%{public}zu, the 1st:%{public}s, syncMode:%{public}d",
-            devices.size(), devices.empty() ? "null" : Anonymous::Change(*devices.begin()).c_str(), syncMode);
-        return DBStatus::DB_ERROR;
-    }
     DistributedDB::CloudSyncOption syncOption;
     syncOption.devices = devices;
-    syncOption.mode = DistributedDB::SyncMode(syncMode);
+    syncOption.mode = cloudSyncMode;
     syncOption.waitTime = wait;
     syncOption.lockAction = DistributedDB::LockAction::NONE;
-    syncOption.merge = GeneralStore::GetHighMode(static_cast<uint32_t>(mode)) == HighMode::AUTO_SYNC_MODE;
     if (storeInfo_.user == 0) {
         std::vector<int32_t> users;
         AccountDelegate::GetInstance()->QueryUsers(users);
@@ -346,6 +370,7 @@ DBStatus KVDBGeneralStore::CloudSync(const Devices &devices, int32_t mode, Detai
 
 int32_t KVDBGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm)
 {
+    auto syncMode = GeneralStore::GetSyncMode(syncParm.mode);
     std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
     if (delegate_ == nullptr) {
         ZLOGE("store already closed! devices count:%{public}zu, the 1st:%{public}s, mode:%{public}d", devices.size(),
@@ -353,12 +378,12 @@ int32_t KVDBGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAs
         return GeneralError::E_ALREADY_CLOSED;
     }
     DBStatus dbStatus;
-    auto syncMode = GeneralStore::GetSyncMode(syncParm.mode);
+    auto dbMode = DistributedDB::SyncMode(syncMode);
     if (syncMode > NEARBY_END && syncMode < CLOUD_END) {
         if (!enableCloud_) {
             return GeneralError::E_NOT_SUPPORT;
         }
-        dbStatus = CloudSync(devices, syncParm.mode, async, syncParm.wait);
+        dbStatus = CloudSync(devices, dbMode, async, syncParm.wait);
     } else {
         if (devices.empty()) {
             ZLOGE("Devices is empty! mode:%{public}d", syncParm.mode);
@@ -378,7 +403,6 @@ int32_t KVDBGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAs
             dbStatus =
                 delegate_->UnSubscribeRemoteQuery(devices, GetDBSyncCompleteCB(std::move(async)), dbQuery, false);
         } else if (syncMode < NEARBY_END) {
-            auto dbMode = DistributedDB::SyncMode(syncMode);
             if (kvQuery->IsEmpty()) {
                 dbStatus = delegate_->Sync(devices, dbMode, GetDBSyncCompleteCB(std::move(async)), false);
             } else {
@@ -394,6 +418,12 @@ int32_t KVDBGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAs
 
 void KVDBGeneralStore::SetEqualIdentifier(const std::string &appId, const std::string &storeId)
 {
+    std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
+    if (delegate_ == nullptr) {
+        ZLOGE("store already closed! appId:%{public}s storeId:%{public}s", appId.c_str(),
+            Anonymous::Change(storeId).c_str());
+        return;
+    }
     std::vector<std::string> sameAccountDevs {};
     std::vector<std::string> defaultAccountDevs {};
     auto uuids = DMAdapter::ToUUID(DMAdapter::GetInstance().GetRemoteDevices());
@@ -401,18 +431,20 @@ void KVDBGeneralStore::SetEqualIdentifier(const std::string &appId, const std::s
     GetIdentifierParams(defaultAccountDevs, uuids, NO_ACCOUNT);
     if (!sameAccountDevs.empty()) {
         auto accountId = AccountDelegate::GetInstance()->GetUnencryptedAccountId();
-        auto syncIdentifier = KvManager::GetKvStoreIdentifier(accountId, appId, storeId);
-        ZLOGI("same account set compatible identifier store:%{public}s, user:%{public}s, device:%{public}.10s",
-            Anonymous::Change(storeId).c_str(), Anonymous::Change(accountId).c_str(),
-            DistributedData::Serializable::Marshall(sameAccountDevs).c_str());
-        delegate_->SetEqualIdentifier(syncIdentifier, sameAccountDevs);
+        auto convertedIds = AppIdMappingConfigManager::GetInstance().Convert(appId, accountId);
+        auto identifier = KvManager::GetKvStoreIdentifier(convertedIds.second, convertedIds.first, storeId);
+        ZLOGI("same account store:%{public}s, user:%{public}s, device:%{public}.10s, appId:%{public}s",
+            Anonymous::Change(storeId).c_str(), Anonymous::Change(convertedIds.second).c_str(),
+            DistributedData::Serializable::Marshall(sameAccountDevs).c_str(), convertedIds.first.c_str());
+        delegate_->SetEqualIdentifier(identifier, sameAccountDevs);
     }
     if (!defaultAccountDevs.empty()) {
-        auto syncIdentifier = KvManager::GetKvStoreIdentifier(defaultAccountId, appId, storeId);
-        ZLOGI("no account set compatible identifier store:%{public}s, device:%{public}.10s",
+        auto convertedIds = AppIdMappingConfigManager::GetInstance().Convert(appId, defaultAccountId);
+        auto identifier = KvManager::GetKvStoreIdentifier(convertedIds.second, convertedIds.first, storeId);
+        ZLOGI("no account store:%{public}s, device:%{public}.10s, appId:%{public}s",
             Anonymous::Change(storeId).c_str(),
-            DistributedData::Serializable::Marshall(defaultAccountDevs).c_str());
-        delegate_->SetEqualIdentifier(syncIdentifier, defaultAccountDevs);
+            DistributedData::Serializable::Marshall(defaultAccountDevs).c_str(), convertedIds.first.c_str());
+        delegate_->SetEqualIdentifier(identifier, defaultAccountDevs);
     }
 }
 
@@ -431,9 +463,9 @@ void KVDBGeneralStore::GetIdentifierParams(std::vector<std::string> &devices,
     ZLOGI("devices size: %{public}zu", devices.size());
 }
 
-std::shared_ptr<Cursor> KVDBGeneralStore::PreSharing(GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> KVDBGeneralStore::PreSharing(GenQuery &query)
 {
-    return nullptr;
+    return { GeneralError::E_NOT_SUPPORT, nullptr };
 }
 
 int32_t KVDBGeneralStore::Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName)
@@ -450,7 +482,8 @@ int32_t KVDBGeneralStore::Clean(const std::vector<std::string> &devices, int32_t
     DBStatus status = OK;
     switch (mode) {
         case CLOUD_INFO:
-            status = delegate_->RemoveDeviceData("", static_cast<ClearMode>(CLOUD_INFO));
+            status = delegate_->RemoveDeviceData(
+                "", isPublic_ ? static_cast<ClearMode>(CLOUD_DATA) : static_cast<ClearMode>(CLOUD_INFO));
             break;
         case CLOUD_DATA:
             status = delegate_->RemoveDeviceData("", static_cast<ClearMode>(CLOUD_DATA));
@@ -467,7 +500,7 @@ int32_t KVDBGeneralStore::Clean(const std::vector<std::string> &devices, int32_t
         default:
             return GeneralError::E_ERROR;
     }
-    return status == DistributedDB::OK ? GeneralError::E_OK : GeneralError::E_ERROR;
+    return ConvertStatus(status);
 }
 
 int32_t KVDBGeneralStore::Watch(int32_t origin, Watcher &watcher)
@@ -530,23 +563,11 @@ int32_t KVDBGeneralStore::SetTrackerTable(
 
 KVDBGeneralStore::GenErr KVDBGeneralStore::ConvertStatus(DistributedDB::DBStatus status)
 {
-    switch (status) {
-        case DBStatus::OK:
-            return GenErr::E_OK;
-        case DBStatus::CLOUD_NETWORK_ERROR:
-            return GenErr::E_NETWORK_ERROR;
-        case DBStatus::CLOUD_LOCK_ERROR:
-            return GenErr::E_LOCKED_BY_OTHERS;
-        case DBStatus::CLOUD_FULL_RECORDS:
-            return GenErr::E_RECODE_LIMIT_EXCEEDED;
-        case DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT:
-            return GenErr::E_NO_SPACE_FOR_ASSET;
-        case DBStatus::CLOUD_SYNC_TASK_MERGED:
-            return GenErr::E_SYNC_TASK_MERGED;
-        default:
-            ZLOGI("status:0x%{public}x", status);
-            break;
+    auto it = dbStatusMap_.find(status);
+    if (it != dbStatusMap_.end()) {
+        return it->second;
     }
+    ZLOGI("status:0x%{public}x", status);
     return GenErr::E_ERROR;
 }
 
@@ -584,23 +605,6 @@ std::vector<std::string> KVDBGeneralStore::GetWaterVersion(const std::string &de
     return res;
 }
 
-void KVDBGeneralStore::InitWaterVersion(const StoreMetaData &meta)
-{
-    CheckerManager::StoreInfo info = { atoi(meta.user.c_str()), meta.tokenId, meta.bundleName, meta.storeId };
-    bool isDynamic = CheckerManager::GetInstance().IsDynamic(info);
-    bool isStatic = CheckerManager::GetInstance().IsStatic(info);
-    if (!isDynamic && !isStatic) {
-        return;
-    }
-    delegate_->SetGenCloudVersionCallback([info](auto &originVersion) {
-        return WaterVersionManager::GetInstance().GetWaterVersion(info.bundleName, info.storeId);
-    });
-    callback_ = [meta]() {
-        auto event = std::make_unique<CloudSyncFinishedEvent>(CloudEvent::CLOUD_SYNC_FINISHED, meta);
-        EventCenter::GetInstance().PostEvent(std::move(event));
-    };
-}
-
 void KVDBGeneralStore::ObserverProxy::OnChange(DBOrigin origin, const std::string &originalId, DBChangeData &&data)
 {
     if (!HasWatcher()) {
@@ -651,12 +655,11 @@ void KVDBGeneralStore::ObserverProxy::ConvertChangeData(const std::list<DBEntry>
 
 KVDBGeneralStore::DBProcessCB KVDBGeneralStore::GetDBProcessCB(DetailAsync async)
 {
-    return [async, callback = callback_](const std::map<std::string, SyncProcess> &processes) {
-        if (!async && !callback) {
+    return [async](const std::map<std::string, SyncProcess> &processes) {
+        if (!async) {
             return;
         }
         DistributedData::GenDetails details;
-        bool downloadFinished = false;
         for (auto &[id, process] : processes) {
             auto &detail = details[id];
             detail.progress = process.process;
@@ -672,16 +675,15 @@ KVDBGeneralStore::DBProcessCB KVDBGeneralStore::GetDBProcessCB(DetailAsync async
                 table.download.success = value.downLoadInfo.successCount;
                 table.download.failed = value.downLoadInfo.failCount;
                 table.download.untreated = table.download.total - table.download.success - table.download.failed;
-                downloadFinished = downloadFinished ||
-                                   (process.process == FINISHED && value.downLoadInfo.successCount > 0);
+                detail.changeCount = (process.process == FINISHED)
+                                        ? value.downLoadInfo.insertCount + value.downLoadInfo.updateCount +
+                                              value.downLoadInfo.deleteCount
+                                        : 0;
             }
         }
         if (async) {
             async(details);
         }
-        if (downloadFinished && callback) {
-            callback();
-        }
     };
 }
 
@@ -773,4 +775,19 @@ void KVDBGeneralStore::SetConfig(const GeneralStore::StoreConfig &storeConfig)
 {
     enableCloud_ = storeConfig.enableCloud_;
 }
+
+std::pair<int32_t, uint32_t> KVDBGeneralStore::LockCloudDB()
+{
+    return { GeneralError::E_NOT_SUPPORT, 0 };
+}
+
+int32_t KVDBGeneralStore::UnLockCloudDB()
+{
+    return GeneralError::E_NOT_SUPPORT;
+}
+
+void KVDBGeneralStore::SetExecutor(std::shared_ptr<Executor> executor)
+{
+    return;
+}
 } // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.h b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.h
index b9ad8360c353c01f35600759d553eac8f0276ec8..a21efc30b45c819dd77736605c39120880aaba7a 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.h
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_general_store.h
@@ -57,16 +57,17 @@ public:
         Values &&conditions) override;
     int32_t Replace(const std::string &table, VBucket &&value) override;
     int32_t Delete(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, const std::string &sql,
+        Values &&args) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, GenQuery &query) override;
     int32_t Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm) override;
-    std::shared_ptr<Cursor> PreSharing(GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> PreSharing(GenQuery &query) override;
     int32_t Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName) override;
     int32_t Watch(int32_t origin, Watcher &watcher) override;
     int32_t Unwatch(int32_t origin, Watcher &watcher) override;
     int32_t RegisterDetailProgressObserver(DetailAsync async) override;
     int32_t UnregisterDetailProgressObserver() override;
-    int32_t Close() override;
+    int32_t Close(bool isForce = false) override;
     int32_t AddRef() override;
     int32_t Release() override;
     int32_t BindSnapshots(std::shared_ptr<std::map<std::string, std::shared_ptr<Snapshot>>> bindAssets) override;
@@ -74,10 +75,12 @@ public:
     std::vector<std::string> GetWaterVersion(const std::string &deviceId) override;
     void SetEqualIdentifier(const std::string &appId, const std::string &storeId) override;
     void SetConfig(const StoreConfig &storeConfig) override;
-
+    void SetExecutor(std::shared_ptr<Executor> executor) override;
     static DBPassword GetDBPassword(const StoreMetaData &data);
     static DBOption GetDBOption(const StoreMetaData &data, const DBPassword &password);
     static DBSecurity GetDBSecurity(int32_t secLevel);
+    virtual std::pair<int32_t, uint32_t> LockCloudDB() override;
+    virtual int32_t UnLockCloudDB() override;
 
 private:
     using KvDelegate = DistributedDB::KvStoreNbDelegate;
@@ -91,8 +94,7 @@ private:
     std::vector<uint8_t> GetNewKey(std::vector<uint8_t> &key, const std::string &uuid);
     DBSyncCallback GetDBSyncCompleteCB(DetailAsync async);
     DBProcessCB GetDBProcessCB(DetailAsync async);
-    DBStatus CloudSync(const Devices &devices, int32_t mode, DetailAsync async, int64_t wait);
-    void InitWaterVersion(const StoreMetaData &meta);
+    DBStatus CloudSync(const Devices &devices, DistributedDB::SyncMode cloudSyncMode, DetailAsync async, int64_t wait);
     void GetIdentifierParams(std::vector<std::string> &devices,
         const std::vector<std::string> &uuids, int32_t authType);
     class ObserverProxy : public DistributedDB::KvStoreObserver {
@@ -125,14 +127,15 @@ private:
     std::atomic<bool> isBound_ = false;
     std::mutex mutex_;
     int32_t ref_ = 1;
-    mutable std::shared_mutex rwMutex_;
+    mutable std::shared_timed_mutex rwMutex_;
     StoreInfo storeInfo_;
-    std::function<void()> callback_;
 
     static constexpr int32_t NO_ACCOUNT = 0;
     static constexpr int32_t IDENTICAL_ACCOUNT = 1;
-    static constexpr const char *defaultAccountId = "default";
+    static constexpr const char *defaultAccountId = "ohosAnonymousUid";
     bool enableCloud_ = false;
+    bool isPublic_ = false;
+    static const std::map<DBStatus, GenErr> dbStatusMap_;
 };
 } // namespace OHOS::DistributedKv
 #endif // OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_KVDB_GENERAL_STORE_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
index ee0f35f0e61f7187138b1f681ec4c3c1e350f21d..b225490dc095a36c90e5dca4a0bfb8fc6839c90c 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
@@ -20,7 +20,6 @@
 
 #include "accesstoken_kit.h"
 #include "account/account_delegate.h"
-#include "auto_sync_matrix.h"
 #include "backup_manager.h"
 #include "bootstrap.h"
 #include "checker/checker_manager.h"
@@ -100,10 +99,7 @@ void KVDBServiceImpl::Init()
     auto process = [this](const Event &event) {
         const auto &evt = static_cast<const CloudEvent &>(event);
         const auto &storeInfo = evt.GetStoreInfo();
-        StoreMetaData meta;
-        meta.storeId = storeInfo.storeName;
-        meta.bundleName = storeInfo.bundleName;
-        meta.user = std::to_string(storeInfo.user);
+        StoreMetaData meta(storeInfo);
         meta.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
         if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
             if (meta.user == "0") {
@@ -133,6 +129,7 @@ void KVDBServiceImpl::Init()
         store->RegisterDetailProgressObserver(nullptr);
     };
     EventCenter::GetInstance().Subscribe(CloudEvent::CLOUD_SYNC, process);
+    EventCenter::GetInstance().Subscribe(CloudEvent::CLEAN_DATA, process);
 }
 
 void KVDBServiceImpl::RegisterKvServiceInfo()
@@ -258,42 +255,14 @@ Status KVDBServiceImpl::Sync(const AppId &appId, const StoreId &storeId, SyncInf
     syncInfo.syncId = ++syncId_;
     RADAR_REPORT(STANDARD_DEVICE_SYNC, ADD_SYNC_TASK, RADAR_SUCCESS, BIZ_STATE, START,
         SYNC_STORE_ID, Anonymous::Change(storeId.storeId), SYNC_APP_ID, appId.appId, CONCURRENT_ID,
-        std::to_string(syncInfo.syncId), DATA_TYPE, metaData.dataType, SYNC_TYPE, SYNC);
+        std::to_string(syncInfo.syncId), DATA_TYPE, metaData.dataType, SYNC_TYPE,
+        SYNC, OS_TYPE, IsOHOSType(syncInfo.devices));
     return KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), delay,
         std::bind(&KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_SYNC),
         std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
 }
 
-Status KVDBServiceImpl::SyncExt(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo)
-{
-    if (syncInfo.devices.empty()) {
-        return Status::INVALID_ARGUMENT;
-    }
-    StoreMetaData metaData = GetStoreMetaData(appId, storeId);
-    MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
-    auto device = DMAdapter::GetInstance().ToUUID(syncInfo.devices[0]);
-    if (device.empty()) {
-        ZLOGE("invalid deviceId, appId:%{public}s storeId:%{public}s deviceId:%{public}s",
-            metaData.bundleName.c_str(), Anonymous::Change(metaData.storeId).c_str(),
-            Anonymous::Change(syncInfo.devices[0]).c_str());
-        return Status::INVALID_ARGUMENT;
-    }
-    if (DeviceMatrix::GetInstance().IsSupportMatrix() &&
-        ((!DeviceMatrix::GetInstance().IsStatics(metaData) && !DeviceMatrix::GetInstance().IsDynamic(metaData)) ||
-        !IsRemoteChange(metaData, device))) {
-            ZLOGD("no change, do not need sync, appId:%{public}s storeId:%{public}s",
-                metaData.bundleName.c_str(), Anonymous::Change(metaData.storeId).c_str());
-            DBResult dbResult = { {syncInfo.devices[0], DBStatus::OK} };
-            DoComplete(metaData, syncInfo, RefCount(), std::move(dbResult));
-            return SUCCESS;
-    }
-    syncInfo.syncId = ++syncId_;
-    return KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), 0,
-        std::bind(&KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_SYNC),
-        std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
-}
-
-Status KVDBServiceImpl::NotifyDataChange(const AppId &appId, const StoreId &storeId)
+Status KVDBServiceImpl::NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay)
 {
     StoreMetaData meta = GetStoreMetaData(appId, storeId);
     if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta)) {
@@ -301,58 +270,20 @@ Status KVDBServiceImpl::NotifyDataChange(const AppId &appId, const StoreId &stor
             appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
         return Status::INVALID_ARGUMENT;
     }
-    if (!DeviceMatrix::GetInstance().IsSupportMatrix()) {
-        if (meta.cloudAutoSync) {
-            DoCloudSync(meta, {});
-        }
-        if (meta.isAutoSync) {
-            TryToSync(meta, true);
-        }
-        return SUCCESS;
-    }
-    if (DeviceMatrix::GetInstance().IsStatics(meta) || DeviceMatrix::GetInstance().IsDynamic(meta)) {
+    if (DeviceMatrix::GetInstance().IsSupportMatrix() &&
+        (DeviceMatrix::GetInstance().IsStatics(meta) || DeviceMatrix::GetInstance().IsDynamic(meta))) {
         WaterVersionManager::GetInstance().GenerateWaterVersion(meta.bundleName, meta.storeId);
         DeviceMatrix::GetInstance().OnChanged(meta);
-        if (meta.cloudAutoSync) {
-            DoCloudSync(meta, {});
-        }
-        return SUCCESS;
-    }
-    if (meta.cloudAutoSync) {
-        DoCloudSync(meta, {});
-    }
-    if (meta.isAutoSync) {
-        AutoSyncMatrix::GetInstance().OnChanged(meta);
-        TryToSync(meta);
     }
-    return SUCCESS;
-}
 
-void KVDBServiceImpl::TryToSync(const StoreMetaData &metaData, bool force)
-{
-    auto devices = DMAdapter::ToUUID(DMAdapter::GetInstance().GetRemoteDevices());
-    if (devices.empty()) {
-        return;
-    }
-    SyncInfo syncInfo;
-    syncInfo.mode = SyncMode::PUSH;
-    for (const auto &device : devices) {
-        if (!force && (!CommContext::GetInstance().IsSessionReady(device) ||
-            !DMAdapter::GetInstance().IsDeviceReady(device))) {
-            continue;
-        }
-        ZLOGI("[TryToSync] appId:%{public}s, storeId:%{public}s", metaData.bundleName.c_str(),
-            Anonymous::Change(metaData.storeId).c_str());
-        syncInfo.devices = { device };
-        syncInfo.syncId = ++syncId_;
-        RADAR_REPORT(STANDARD_DEVICE_SYNC, ADD_SYNC_TASK, RADAR_SUCCESS, BIZ_STATE, START,
-            SYNC_STORE_ID, Anonymous::Change(metaData.storeId), SYNC_APP_ID, metaData.bundleName,
-            CONCURRENT_ID, std::to_string(syncInfo.syncId), DATA_TYPE, metaData.dataType,
-            SYNC_TYPE, REUSE_SOCKET_AUTO_SYNC);
-        KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(metaData.tokenId), 0,
-            std::bind(&KVDBServiceImpl::DoSyncInOrder, this, metaData, syncInfo, std::placeholders::_1, ACTION_SYNC),
-            std::bind(&KVDBServiceImpl::DoComplete, this, metaData, syncInfo, RefCount(), std::placeholders::_1));
+    if (executors_ != nullptr && (meta.cloudAutoSync)) {
+        executors_->Schedule(std::chrono::milliseconds(delay), [this, meta]() {
+            if (meta.cloudAutoSync) {
+                DoCloudSync(meta, {});
+            }
+        });
     }
+    return SUCCESS;
 }
 
 Status KVDBServiceImpl::PutSwitch(const AppId &appId, const SwitchData &data)
@@ -416,76 +347,6 @@ Status KVDBServiceImpl::RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifie
     return Status::SUCCESS;
 }
 
-void KVDBServiceImpl::RegisterMatrixChange()
-{
-    if (!DeviceMatrix::GetInstance().IsSupportMatrix()) {
-        ZLOGD("not support matrix");
-        return;
-    }
-    DeviceMatrix::GetInstance().RegRemoteChange([this](const std::string &device, std::pair<uint16_t, uint16_t> mask) {
-        auto networkId = DMAdapter::GetInstance().ToNetworkID(device);
-        if (networkId.empty()) {
-            return;
-        }
-        OnDynamicChange(mask);
-        OnStaticsChange(mask);
-    });
-}
-
-void KVDBServiceImpl::OnStaticsChange(std::pair<uint16_t, uint16_t> mask)
-{
-    bool isChanged = false;
-    syncAgents_.ForEach([mask, &isChanged](const auto &key, auto &value) {
-        StoreMetaData meta;
-        meta.appId = value.appId_;
-        meta.tokenId = key;
-        meta.bundleName = value.appId_;
-        meta.dataType = DataType::TYPE_STATICS;
-        if (!DeviceMatrix::GetInstance().IsStatics(meta)) {
-            return false;
-        }
-        uint16_t code = DeviceMatrix::GetInstance().GetCode(meta);
-        std::map<std::string, bool> clientMask;
-        bool changed = ((mask.first & code) == code);
-        if ((value.staticsChanged_ && changed) || (!value.staticsChanged_ && !changed)) {
-            return false;
-        }
-        value.staticsChanged_ = changed;
-        isChanged = true;
-        return false;
-    });
-    if (isChanged) {
-        DoCloudSync(true);
-    }
-}
-
-void KVDBServiceImpl::OnDynamicChange(std::pair<uint16_t, uint16_t> mask)
-{
-    bool isChanged = false;
-    syncAgents_.ForEach([mask, &isChanged](const auto &key, auto &value) {
-        StoreMetaData meta;
-        meta.appId = value.appId_;
-        meta.tokenId = key;
-        meta.bundleName = value.appId_;
-        meta.dataType = DataType::TYPE_DYNAMICAL;
-        if (!DeviceMatrix::GetInstance().IsDynamic(meta)) {
-            return false;
-        }
-        uint16_t code = DeviceMatrix::GetInstance().GetCode(meta);
-        std::map<std::string, bool> clientMask;
-        bool changed = ((mask.second & code) == code);
-        if ((value.dynamicChanged_ && changed) || (!value.dynamicChanged_ && !changed)) {
-            return false;
-        }
-        value.dynamicChanged_ = changed;
-        isChanged = true;
-        return false;
-    });
-    if (isChanged) {
-        DoCloudSync(false);
-    }
-}
-
 Status KVDBServiceImpl::UnregServiceNotifier(const AppId &appId)
 {
     syncAgents_.ComputeIfPresent(IPCSkeleton::GetCallingTokenID(), [&appId](const auto &key, SyncAgent &value) {
@@ -780,20 +641,20 @@ Status KVDBServiceImpl::BeforeCreate(const AppId &appId, const StoreId &storeId,
     StoreMetaDataLocal oldLocal;
     MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), oldLocal, true);
     // when user is 0, old store no "isPublic" attr, as well as new store's "isPublic" is true, do not intercept.
-    if (old.storeType != meta.storeType || Constant::NotEqual(old.isEncrypt, meta.isEncrypt) ||
-        old.area != meta.area || !options.persistent ||
+    if (old.storeType != meta.storeType || Constant::NotEqual(old.isEncrypt, meta.isEncrypt) || old.area != meta.area ||
+        !options.persistent || (meta.securityLevel != NO_LABEL && (old.securityLevel > meta.securityLevel)) ||
         (Constant::NotEqual(oldLocal.isPublic, options.isPublic) &&
             (old.user != DEFAULT_USER_ID || !options.isPublic))) {
         ZLOGE("meta appId:%{public}s storeId:%{public}s user:%{public}s type:%{public}d->%{public}d "
-              "encrypt:%{public}d->%{public}d "
-              "area:%{public}d->%{public}d persistent:%{public}d isPublic:%{public}d->%{public}d",
-            appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), old.user.c_str(), old.storeType,
-            meta.storeType, old.isEncrypt, meta.isEncrypt, old.area, meta.area, options.persistent, oldLocal.isPublic,
-            options.isPublic);
+              "encrypt:%{public}d->%{public}d area:%{public}d->%{public}d persistent:%{public}d "
+              "securityLevel:%{public}d->%{public}d isPublic:%{public}d->%{public}d",
+              appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str(), old.user.c_str(), old.storeType,
+              meta.storeType, old.isEncrypt, meta.isEncrypt, old.area, meta.area, options.persistent,
+              old.securityLevel, meta.securityLevel, oldLocal.isPublic, options.isPublic);
         return Status::STORE_META_CHANGED;
     }
 
-    if (options.cloudConfig.enableCloud && (!isCreated || !meta.enableCloud) && executors_ != nullptr) {
+    if (options.cloudConfig.enableCloud && !meta.enableCloud && executors_ != nullptr) {
         DistributedData::StoreInfo storeInfo;
         storeInfo.bundleName = appId.appId;
         storeInfo.instanceId = GetInstIndex(storeInfo.tokenId, appId);
@@ -922,36 +783,6 @@ int32_t KVDBServiceImpl::OnUserChange(uint32_t code, const std::string &user, co
     return SUCCESS;
 }
 
-int32_t KVDBServiceImpl::OnReady(const std::string &device)
-{
-    return SUCCESS;
-}
-
-int32_t KVDBServiceImpl::OnSessionReady(const std::string &device)
-{
-    ZLOGI("session ready, device:%{public}s", Anonymous::Change(device).c_str());
-    if (!DMAdapter::GetInstance().IsDeviceReady(device)) {
-        return SUCCESS;
-    }
-
-    auto stores = AutoSyncMatrix::GetInstance().GetChangedStore(device);
-    for (const auto &store : stores) {
-        ZLOGI("[OnSessionReady] appId:%{public}s, storeId:%{public}s",
-            store.bundleName.c_str(), Anonymous::Change(store.storeId).c_str());
-        SyncInfo syncInfo;
-        syncInfo.mode = SyncMode::PUSH;
-        syncInfo.devices = { device };
-        syncInfo.syncId = ++syncId_;
-        RADAR_REPORT(STANDARD_DEVICE_SYNC, ADD_SYNC_TASK, RADAR_SUCCESS, BIZ_STATE, START,
-            SYNC_STORE_ID, Anonymous::Change(store.storeId), SYNC_APP_ID, store.bundleName,
-            CONCURRENT_ID, std::to_string(syncInfo.syncId), SYNC_TYPE, AUTOSYNC);
-        KvStoreSyncManager::GetInstance()->AddSyncOperation(uintptr_t(store.tokenId), 0,
-            std::bind(&KVDBServiceImpl::DoSyncInOrder, this, store, syncInfo, std::placeholders::_1, ACTION_SYNC),
-            std::bind(&KVDBServiceImpl::DoComplete, this, store, syncInfo, RefCount(), std::placeholders::_1));
-    }
-    return SUCCESS;
-}
-
 bool KVDBServiceImpl::IsRemoteChange(const StoreMetaData &metaData, const std::string &device)
 {
     auto code = DeviceMatrix::GetInstance().GetCode(metaData);
@@ -970,12 +801,6 @@ bool KVDBServiceImpl::IsRemoteChange(const StoreMetaData &metaData, const std::s
     return (mask & code) == code;
 }
 
-int32_t KVDBServiceImpl::Online(const std::string &device)
-{
-    AutoSyncMatrix::GetInstance().Online(device);
-    return SUCCESS;
-}
-
 void KVDBServiceImpl::AddOptions(const Options &options, StoreMetaData &metaData)
 {
     metaData.isAutoSync = options.autoSync;
@@ -994,6 +819,7 @@ void KVDBServiceImpl::AddOptions(const Options &options, StoreMetaData &metaData
     metaData.dataType = options.dataType;
     metaData.enableCloud = options.cloudConfig.enableCloud;
     metaData.cloudAutoSync = options.cloudConfig.autoSync;
+    metaData.authType = static_cast<int32_t>(options.authType);
 }
 
 void KVDBServiceImpl::SaveLocalMetaData(const Options &options, const StoreMetaData &metaData)
@@ -1067,33 +893,6 @@ KVDBServiceImpl::DBResult KVDBServiceImpl::HandleGenBriefDetails(const GenDetail
     return dbResults;
 }
 
-void KVDBServiceImpl::DoCloudSync(bool isStatic)
-{
-    if (isStatic) {
-        auto staticStores = CheckerManager::GetInstance().GetStaticStores();
-        for (auto &staticStore : staticStores) {
-            AppId appId = { staticStore.bundleName };
-            StoreId storeId = { staticStore.storeId };
-            auto status = CloudSync(appId, storeId, {});
-            if (status != SUCCESS) {
-                ZLOGW("cloud sync failed:%{public}d, appId:%{public}s storeId:%{public}s", status,
-                    staticStore.bundleName.c_str(), Anonymous::Change(staticStore.storeId).c_str());
-            }
-        }
-        return;
-    }
-    auto dynamicStores = CheckerManager::GetInstance().GetDynamicStores();
-    for (auto &dynamicStore : dynamicStores) {
-        AppId appId = { dynamicStore.bundleName };
-        StoreId storeId = { dynamicStore.storeId };
-        auto status = CloudSync(appId, storeId, {});
-        if (status != SUCCESS) {
-            ZLOGW("cloud sync failed:%{public}d, appId:%{public}s storeId:%{public}s", status,
-                dynamicStore.bundleName.c_str(), Anonymous::Change(dynamicStore.storeId).c_str());
-        }
-    }
-}
-
 Status KVDBServiceImpl::DoCloudSync(const StoreMetaData &meta, const SyncInfo &syncInfo)
 {
     if (!meta.enableCloud) {
@@ -1134,7 +933,7 @@ Status KVDBServiceImpl::DoCloudSync(const StoreMetaData &meta, const SyncInfo &s
     };
     auto mixMode = static_cast<int32_t>(GeneralStore::MixMode(GeneralStore::CLOUD_TIME_FIRST,
         meta.isAutoSync ? GeneralStore::AUTO_SYNC_MODE : GeneralStore::MANUAL_SYNC_MODE));
-    auto info = ChangeEvent::EventInfo(mixMode, 0, false, nullptr, syncCallback);
+    auto info = ChangeEvent::EventInfo({ mixMode, 0, false, syncInfo.triggerMode }, false, nullptr, syncCallback);
     auto evt = std::make_unique<ChangeEvent>(std::move(storeInfo), std::move(info));
     EventCenter::GetInstance().PostEvent(std::move(evt));
     return SUCCESS;
@@ -1203,7 +1002,10 @@ bool KVDBServiceImpl::IsNeedMetaSync(const StoreMetaData &meta, const std::vecto
         metaData.deviceId = uuid;
         CapMetaData capMeta;
         auto capKey = CapMetaRow::GetKeyFor(uuid);
-        if (!MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMeta) ||
+        auto devInfo = DMAdapter::GetInstance().GetDeviceInfo(uuid);
+        if ((!MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMeta) &&
+            !(devInfo.osType != OH_OS_TYPE &&
+            devInfo.deviceType == static_cast<uint32_t>(DistributedHardware::DmDeviceType::DEVICE_TYPE_CAR))) ||
             !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
             isAfterMeta = true;
             break;
@@ -1313,7 +1115,6 @@ Status KVDBServiceImpl::DoComplete(const StoreMetaData &meta, const SyncInfo &in
     for (const auto &device : info.devices) {
         auto it = result.find(device);
         if (it != result.end() && it->second == SUCCESS) {
-            AutoSyncMatrix::GetInstance().OnExchanged(device, meta);
             DeviceMatrix::GetInstance().OnExchanged(device, meta, ConvertType(static_cast<SyncMode>(info.mode)));
         }
     }
@@ -1392,6 +1193,43 @@ Status KVDBServiceImpl::ConvertDbStatus(DBStatus status) const
     return Status::ERROR;
 }
 
+Status KVDBServiceImpl::ConvertGeneralErr(GeneralError error) const
+{
+    switch (error) {
+        case GeneralError::E_DB_ERROR:
+            return Status::DB_ERROR;
+        case GeneralError::E_OK:
+            return Status::SUCCESS;
+        case GeneralError::E_INVALID_ARGS:
+            return Status::INVALID_ARGUMENT;
+        case GeneralError::E_RECORD_NOT_FOUND:
+            return Status::KEY_NOT_FOUND;
+        case GeneralError::E_INVALID_VALUE_FIELDS:
+            return Status::INVALID_VALUE_FIELDS;
+        case GeneralError::E_INVALID_FIELD_TYPE:
+            return Status::INVALID_FIELD_TYPE;
+        case GeneralError::E_CONSTRAIN_VIOLATION:
+            return Status::CONSTRAIN_VIOLATION;
+        case GeneralError::E_INVALID_FORMAT:
+            return Status::INVALID_FORMAT;
+        case GeneralError::E_INVALID_QUERY_FORMAT:
+            return Status::INVALID_QUERY_FORMAT;
+        case GeneralError::E_INVALID_QUERY_FIELD:
+            return Status::INVALID_QUERY_FIELD;
+        case GeneralError::E_NOT_SUPPORT:
+            return Status::NOT_SUPPORT;
+        case GeneralError::E_TIME_OUT:
+            return Status::TIME_OUT;
+        case GeneralError::E_OVER_MAX_LIMITS:
+            return Status::OVER_MAX_LIMITS;
+        case GeneralError::E_SECURITY_LEVEL_ERROR:
+            return Status::SECURITY_LEVEL_ERROR;
+        default:
+            break;
+    }
+    return Status::ERROR;
+}
+
 KVDBServiceImpl::DBMode KVDBServiceImpl::ConvertDBMode(SyncMode syncMode) const
 {
     DBMode dbMode;
@@ -1513,7 +1351,43 @@ int32_t KVDBServiceImpl::OnInitialize()
     RegisterKvServiceInfo();
     RegisterHandler();
     Init();
-    RegisterMatrixChange();
     return SUCCESS;
 }
+
+bool KVDBServiceImpl::IsOHOSType(const std::vector<std::string> &ids)
+{
+    if (ids.empty()) {
+        ZLOGI("ids is empty");
+        return true;
+    }
+    bool isOHOSType = true;
+    for (auto &id : ids) {
+        if (!DMAdapter::GetInstance().IsOHOSType(id)) {
+            isOHOSType = false;
+            break;
+        }
+    }
+    return isOHOSType;
+}
+
+Status KVDBServiceImpl::RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device)
+{
+    StoreMetaData metaData = GetStoreMetaData(appId, storeId);
+    MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
+    auto watcher = GetWatchers(metaData.tokenId, metaData.storeId);
+    auto store = AutoCache::GetInstance().GetStore(metaData, watcher);
+    if (store == nullptr) {
+        ZLOGE("GetStore failed! appId:%{public}s storeId:%{public}s dir:%{public}s", metaData.bundleName.c_str(),
+            Anonymous::Change(metaData.storeId).c_str(), metaData.dataDir.c_str());
+        return Status::ERROR;
+    }
+
+    int32_t ret;
+    if (device.empty()) {
+        ret = store->Clean({}, KVDBGeneralStore::NEARBY_DATA, "");
+    } else {
+        ret = store->Clean({ DMAdapter::GetInstance().ToUUID(device) }, KVDBGeneralStore::NEARBY_DATA, "");
+    }
+    return ConvertGeneralErr(GeneralError(ret));
+}
 } // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h
index a43b204507884af3d6e9bce7f04d31acf2516664..38038ba2813c1851dc7cd87d3c1cc837bbe9cfe9 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_impl.h
@@ -49,7 +49,6 @@ public:
     Status Close(const AppId &appId, const StoreId &storeId) override;
     Status CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo) override;
     Status Sync(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) override;
-    Status SyncExt(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) override;
     Status RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier) override;
     Status UnregServiceNotifier(const AppId &appId) override;
     Status SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam) override;
@@ -63,7 +62,7 @@ public:
     Status Subscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer) override;
     Status Unsubscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer) override;
     Status GetBackupPassword(const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password) override;
-    Status NotifyDataChange(const AppId &appId, const StoreId &storeId) override;
+    Status NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay) override;
     Status PutSwitch(const AppId &appId, const SwitchData &data) override;
     Status GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data) override;
     Status SubscribeSwitchData(const AppId &appId) override;
@@ -74,9 +73,7 @@ public:
     int32_t OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &appId) override;
     int32_t ResolveAutoLaunch(const std::string &identifier, DBLaunchParam &param) override;
     int32_t OnUserChange(uint32_t code, const std::string &user, const std::string &account) override;
-    int32_t Online(const std::string &device) override;
-    int32_t OnReady(const std::string &device) override;
-    int32_t OnSessionReady(const std::string &device) override;
+    Status RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device) override;
 
 private:
     using StoreMetaData = OHOS::DistributedData::StoreMetaData;
@@ -90,6 +87,7 @@ private:
     using DBStatus = DistributedDB::DBStatus;
     using DBMode = DistributedDB::SyncMode;
     using Action = OHOS::DistributedData::MetaDataManager::Action;
+    using GeneralError = DistributedData::GeneralError;
     enum SyncAction {
         ACTION_SYNC,
         ACTION_SUBSCRIBE,
@@ -122,7 +120,7 @@ private:
     int32_t GetInstIndex(uint32_t tokenId, const AppId &appId);
     bool IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids);
     Status DoCloudSync(const StoreMetaData &meta, const SyncInfo &syncInfo);
-    void DoCloudSync(bool isStatic);
+    void DoCloudSync(bool statics, bool dynamic);
     Status DoSync(const StoreMetaData &meta, const SyncInfo &info, const SyncEnd &complete, int32_t type);
     Status DoSyncInOrder(const StoreMetaData &meta, const SyncInfo &info, const SyncEnd &complete, int32_t type);
     Status DoSyncBegin(const std::vector<std::string> &devices, const StoreMetaData &meta,
@@ -130,6 +128,7 @@ private:
     Status DoComplete(const StoreMetaData &meta, const SyncInfo &info, RefCount refCount, const DBResult &dbResult);
     uint32_t GetSyncDelayTime(uint32_t delay, const StoreId &storeId);
     Status ConvertDbStatus(DBStatus status) const;
+    Status ConvertGeneralErr(GeneralError error) const;
     DBMode ConvertDBMode(SyncMode syncMode) const;
     ChangeType ConvertType(SyncMode syncMode) const;
     SwitchState ConvertAction(Action action) const;
@@ -145,16 +144,15 @@ private:
     void SaveLocalMetaData(const Options &options, const StoreMetaData &metaData);
     void RegisterKvServiceInfo();
     void RegisterHandler();
-    void RegisterMatrixChange();
     void DumpKvServiceInfo(int fd, std::map<std::string, std::vector<std::string>> &params);
     void TryToSync(const StoreMetaData &metaData, bool force = false);
-    void OnStaticsChange(std::pair<uint16_t, uint16_t> mask);
-    void OnDynamicChange(std::pair<uint16_t, uint16_t> mask);
     bool IsRemoteChange(const StoreMetaData &metaData, const std::string &device);
+    bool IsOHOSType(const std::vector<std::string> &ids);
     static Factory factory_;
     ConcurrentMap<uint32_t, SyncAgent> syncAgents_;
     std::shared_ptr<ExecutorPool> executors_;
     std::atomic_uint64_t syncId_ = 0;
+    static constexpr int32_t OH_OS_TYPE = 10;
 };
 } // namespace OHOS::DistributedKv
 #endif // OHOS_DISTRIBUTED_DATA_SERVICE_KVDB_SERVICE_IMPL_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.cpp b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.cpp
index c224ccaa595dd53f2d75905770676453c028c6ae..cf7761ae8ed4f6928f343032f4937e3249e2b091 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.cpp
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.cpp
@@ -41,7 +41,6 @@ const KVDBServiceStub::Handler
     &KVDBServiceStub::OnSubscribe,
     &KVDBServiceStub::OnUnsubscribe,
     &KVDBServiceStub::OnGetBackupPassword,
-    &KVDBServiceStub::OnSyncExt,
     &KVDBServiceStub::OnCloudSync,
     &KVDBServiceStub::OnNotifyDataChange,
     &KVDBServiceStub::OnSetConfig,
@@ -50,6 +49,7 @@ const KVDBServiceStub::Handler
     &KVDBServiceStub::OnSubscribeSwitchData,
     &KVDBServiceStub::OnUnsubscribeSwitchData,
     &KVDBServiceStub::OnClose,
+    &KVDBServiceStub::OnRemoveDeviceData,
 };
 
 int KVDBServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply)
@@ -108,7 +108,7 @@ std::pair<int32_t, KVDBServiceStub::StoreInfo> KVDBServiceStub::GetStoreInfo(uin
 bool KVDBServiceStub::CheckPermission(uint32_t code, const StoreInfo &storeInfo)
 {
     if (code >= static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_PUT_SWITCH) &&
-        code < static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BUTT)) {
+        code <= static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA)) {
         return CheckerManager::GetInstance().IsSwitches(storeInfo);
     }
     return CheckerManager::GetInstance().IsValid(storeInfo);
@@ -221,29 +221,16 @@ int32_t KVDBServiceStub::OnCloudSync(
     return ERR_NONE;
 }
 
-int32_t KVDBServiceStub::OnSyncExt(
+int32_t KVDBServiceStub::OnNotifyDataChange(
     const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply)
 {
-    SyncInfo syncInfo;
-    if (!ITypesUtil::Unmarshal(
-        data, syncInfo.seqId, syncInfo.mode, syncInfo.devices, syncInfo.delay, syncInfo.query)) {
-        ZLOGE("Unmarshal appId:%{public}s storeId:%{public}s",
-            appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
+    uint64_t delay = 0;
+    if (!ITypesUtil::Unmarshal(data, delay)) {
+        ZLOGE("Unmarshal appId:%{public}s storeId:%{public}s", appId.appId.c_str(),
+            Anonymous::Change(storeId.storeId).c_str());
         return IPC_STUB_INVALID_DATA_ERR;
     }
-    int32_t status = SyncExt(appId, storeId, syncInfo);
-    if (!ITypesUtil::Marshal(reply, status)) {
-        ZLOGE("Marshal status:0x%{public}x appId:%{public}s storeId:%{public}s", status,
-            appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
-        return IPC_STUB_WRITE_PARCEL_ERR;
-    }
-    return ERR_NONE;
-}
-
-int32_t KVDBServiceStub::OnNotifyDataChange(
-    const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply)
-{
-    int32_t status = NotifyDataChange(appId, storeId);
+    int32_t status = NotifyDataChange(appId, storeId, delay);
     if (!ITypesUtil::Marshal(reply, status)) {
         ZLOGE("Marshal status:0x%{public}x appId:%{public}s storeId:%{public}s",
             status, appId.appId.c_str(), Anonymous::Change(storeId.storeId).c_str());
@@ -519,4 +506,21 @@ int32_t KVDBServiceStub::OnSetConfig(const AppId &appId, const StoreId &storeId,
     }
     return ERR_NONE;
 }
+
+int32_t KVDBServiceStub::OnRemoveDeviceData(const AppId &appId, const StoreId &storeId, MessageParcel &data,
+    MessageParcel &reply)
+{
+    std::string device;
+    if (!ITypesUtil::Unmarshal(data, device)) {
+        ZLOGE("Unmarshal appId:%{public}s storeId:%{public}s", appId.appId.c_str(),
+            Anonymous::Change(storeId.storeId).c_str());
+        return IPC_STUB_INVALID_DATA_ERR;
+    }
+    int32_t status = RemoveDeviceData(appId, storeId, device);
+    if (!ITypesUtil::Marshal(reply, status)) {
+        ZLOGE("Marshal status:0x%{public}x appId:%{public}s", status, appId.appId.c_str());
+        return IPC_STUB_WRITE_PARCEL_ERR;
+    }
+    return ERR_NONE;
+}
 } // namespace OHOS::DistributedKv
diff --git a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.h b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.h
index 71abe63480c24cc018b44169edaf9e7ab3af03d5..a5deeaf1b28c7fe0cc648f0d9def3bfae2a5356b 100644
--- a/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.h
+++ b/datamgr_service/services/distributeddataservice/service/kvdb/kvdb_service_stub.h
@@ -50,7 +50,6 @@ private:
     int32_t OnSubscribe(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     int32_t OnUnsubscribe(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     int32_t OnGetBackupPassword(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
-    int32_t OnSyncExt(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     int32_t OnNotifyDataChange(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     int32_t OnPutSwitch(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     int32_t OnGetSwitch(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
@@ -59,6 +58,7 @@ private:
     int32_t OnUnsubscribeSwitchData(const AppId &appId, const StoreId &storeId, MessageParcel &data,
         MessageParcel &reply);
     int32_t OnSetConfig(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
+    int32_t OnRemoveDeviceData(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
     static const Handler HANDLERS[static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BUTT)];
 
     bool CheckPermission(uint32_t code, const StoreInfo &storeInfo);
diff --git a/datamgr_service/services/distributeddataservice/service/matrix/include/auto_sync_matrix.h b/datamgr_service/services/distributeddataservice/service/matrix/include/auto_sync_matrix.h
index 75445a8db74498d1e933a2c77f0c468175c808ab..d875a2358e68bf7a77ac97e065d23af54cccce71 100644
--- a/datamgr_service/services/distributeddataservice/service/matrix/include/auto_sync_matrix.h
+++ b/datamgr_service/services/distributeddataservice/service/matrix/include/auto_sync_matrix.h
@@ -19,6 +19,7 @@
 #include <bitset>
 #include <map>
 #include <mutex>
+
 #include "metadata/store_meta_data.h"
 
 namespace OHOS::DistributedData {
diff --git a/datamgr_service/services/distributeddataservice/service/matrix/include/device_matrix.h b/datamgr_service/services/distributeddataservice/service/matrix/include/device_matrix.h
index 4fd6bc5c3e9162c00ebf0853a4e08cb1eec25e3d..6fb6068597c4a169c5c9d19783510dd2ffe8c4d9 100644
--- a/datamgr_service/services/distributeddataservice/service/matrix/include/device_matrix.h
+++ b/datamgr_service/services/distributeddataservice/service/matrix/include/device_matrix.h
@@ -16,6 +16,7 @@
 #define OHOS_DISTRIBUTED_DATA_SERVICE_MATRIX_DEVICE_MATRIX_H
 #include <map>
 #include <mutex>
+
 #include "eventcenter/event.h"
 #include "executor_pool.h"
 #include "lru_bucket.h"
@@ -24,6 +25,7 @@
 #include "metadata/store_meta_data.h"
 #include "utils/ref_count.h"
 #include "visibility.h"
+
 namespace OHOS::DistributedData {
 class API_EXPORT DeviceMatrix {
 public:
@@ -74,7 +76,6 @@ public:
         const StoreMetaData &metaData, ChangeType type = ChangeType::CHANGE_ALL);
     void UpdateLevel(const std::string &device, uint16_t level, LevelType type, bool isConsistent = false);
     void Clear();
-    void RegRemoteChange(std::function<void(const std::string &, std::pair<uint16_t, uint16_t>)> observer);
     void SetExecutor(std::shared_ptr<ExecutorPool> executors);
     uint16_t GetCode(const StoreMetaData &metaData);
     std::pair<bool, uint16_t> GetMask(const std::string &device, LevelType type = LevelType::DYNAMIC);
@@ -87,6 +88,7 @@ public:
     bool IsDynamic(const StoreMetaData &metaData);
     bool IsStatics(const StoreMetaData &metaData);
     bool IsSupportMatrix();
+    bool IsConsistent();
 
 private:
     static constexpr uint32_t RESET_MASK_DELAY = 10; // min
@@ -133,12 +135,13 @@ private:
     void UpdateMask(Mask &mask);
     void UpdateConsistentMeta(const std::string &device, const Mask &remote);
     void SaveSwitches(const std::string &device, const DataLevel &dataLevel);
-    void UpdateRemoteMeta(const std::string &device, Mask &mask);
+    void UpdateRemoteMeta(const std::string &device, Mask &mask, MatrixMetaData &newMeta);
     Task GenResetTask();
     std::pair<uint16_t, uint16_t> ConvertMask(const std::string &device, const DataLevel &dataLevel);
     uint16_t ConvertDynamic(const MatrixMetaData &meta, uint16_t mask);
     uint16_t ConvertStatics(const MatrixMetaData &meta, uint16_t mask);
     MatrixMetaData GetMatrixInfo(const std::string &device);
+    MatrixMetaData GetMatrixMetaData(const std::string &device, const Mask &mask);
     static inline uint16_t ConvertIndex(uint16_t code);
 
     MatrixEvent::MatrixData lasts_;
@@ -155,9 +158,9 @@ private:
     std::map<std::string, Mask> remotes_;
     std::vector<std::string> dynamicApps_;
     std::vector<std::string> staticsApps_;
-    std::function<void(const std::string &, std::pair<uint16_t, uint16_t>)> observer_;
+    std::function<void(bool, bool)> observer_;
     LRUBucket<std::string, MatrixMetaData> matrices_{ MAX_DEVICES };
     LRUBucket<std::string, MatrixMetaData> versions_{ MAX_DEVICES };
 };
 } // namespace OHOS::DistributedData
-#endif // OHOS_DISTRIBUTED_DATA_SERVICE_MATRIX_DEVICE_MATRIX_H
+#endif // OHOS_DISTRIBUTED_DATA_SERVICE_MATRIX_DEVICE_MATRIX_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/matrix/src/auto_sync_matrix.cpp b/datamgr_service/services/distributeddataservice/service/matrix/src/auto_sync_matrix.cpp
index c9986722a6b7693cc408494942ab965b2d4fcf26..4b6b38b5403c5dc4202b05731e4bd5de8cc9ca7a 100644
--- a/datamgr_service/services/distributeddataservice/service/matrix/src/auto_sync_matrix.cpp
+++ b/datamgr_service/services/distributeddataservice/service/matrix/src/auto_sync_matrix.cpp
@@ -16,10 +16,11 @@
 #define LOG_TAG "AutoSyncMatrix"
 
 #include "auto_sync_matrix.h"
+
 #include "bootstrap.h"
 #include "checker/checker_manager.h"
-#include "device_matrix.h"
 #include "device_manager_adapter.h"
+#include "device_matrix.h"
 #include "log_print.h"
 #include "metadata/meta_data_manager.h"
 #include "utils/anonymous.h"
@@ -64,7 +65,7 @@ AutoSyncMatrix::AutoSyncMatrix()
                     break;
             }
             return true;
-    });
+        });
 }
 
 AutoSyncMatrix::~AutoSyncMatrix()
diff --git a/datamgr_service/services/distributeddataservice/service/matrix/src/device_matrix.cpp b/datamgr_service/services/distributeddataservice/service/matrix/src/device_matrix.cpp
index da5c1ba546f08ab1af368f455e6c2137cae61966..337ae78613bf6c00286eeb44d462eaef2e53da4e 100644
--- a/datamgr_service/services/distributeddataservice/service/matrix/src/device_matrix.cpp
+++ b/datamgr_service/services/distributeddataservice/service/matrix/src/device_matrix.cpp
@@ -48,7 +48,7 @@ DeviceMatrix::DeviceMatrix()
                 return true;
             }
             auto deviceId = std::move(metaData.deviceId);
-            ZLOGI("Matrix ver:%{public}u origin:%{public}d device:%{public}s",
+            ZLOGI("matrix version:%{public}u origin:%{public}d device:%{public}s",
                 metaData.version, metaData.origin, Anonymous::Change(deviceId).c_str());
             if (metaData.origin == MatrixMetaData::Origin::REMOTE_CONSISTENT) {
                 return true;
@@ -69,7 +69,7 @@ DeviceMatrix::DeviceMatrix()
             }
             auto deviceId = std::move(metaData.deviceId);
             versions_.Set(deviceId, metaData);
-            ZLOGI("Matrix ver:%{public}u device:%{public}s",
+            ZLOGI("matrix version:%{public}u device:%{public}s",
                 metaData.version, Anonymous::Change(deviceId).c_str());
             return true;
         });
@@ -118,7 +118,7 @@ bool DeviceMatrix::Initialize(uint32_t token, std::string storeId)
         newMeta.dynamic = Merge(oldMeta.dynamic, newMeta.dynamic);
         newMeta.statics = Merge(oldMeta.statics, newMeta.statics);
     }
-    ZLOGI("Save Matrix ver:%{public}u -> %{public}u ", oldMeta.version, newMeta.version);
+    ZLOGI("Save Matrix, oldMeta.version:%{public}u , newMeta.version:%{public}u ", oldMeta.version, newMeta.version);
     MetaDataManager::GetInstance().SaveMeta(newMeta.GetKey(), newMeta, true);
     return MetaDataManager::GetInstance().SaveMeta(newMeta.GetKey(), newMeta);
 }
@@ -205,7 +205,8 @@ std::pair<uint16_t, uint16_t> DeviceMatrix::OnBroadcast(const std::string &devic
     } else {
         mask.statics &= ~dataLevel.statics;
     }
-    UpdateRemoteMeta(device, mask);
+    auto meta = GetMatrixMetaData(device, mask);
+    UpdateRemoteMeta(device, mask, meta);
     {
         std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
         auto it = remotes_.find(device);
@@ -215,9 +216,6 @@ std::pair<uint16_t, uint16_t> DeviceMatrix::OnBroadcast(const std::string &devic
         }
         remotes_.insert_or_assign(device, mask);
     }
-    if (observer_) {
-        observer_(device, { mask.statics, mask.dynamic });
-    }
     return { mask.dynamic, mask.statics };
 }
 
@@ -288,15 +286,20 @@ uint16_t DeviceMatrix::ConvertIndex(uint16_t code)
     return index;
 }
 
-void DeviceMatrix::UpdateRemoteMeta(const std::string &device, Mask &mask)
+MatrixMetaData DeviceMatrix::GetMatrixMetaData(const std::string &device, const Mask &mask)
+{
+    MatrixMetaData meta;
+    meta.dynamic = mask.dynamic;
+    meta.statics = mask.statics;
+    meta.deviceId = device;
+    meta.origin = Origin::REMOTE_RECEIVED;
+    meta.dynamicInfo = dynamicApps_;
+    meta.staticsInfo = staticsApps_;
+    return meta;
+}
+
+void DeviceMatrix::UpdateRemoteMeta(const std::string &device, Mask &mask, MatrixMetaData &newMeta)
 {
-    MatrixMetaData newMeta;
-    newMeta.dynamic = mask.dynamic;
-    newMeta.statics = mask.statics;
-    newMeta.deviceId = device;
-    newMeta.origin = Origin::REMOTE_RECEIVED;
-    newMeta.dynamicInfo = dynamicApps_;
-    newMeta.staticsInfo = staticsApps_;
     auto [exist, oldMeta] = GetMatrixMeta(device);
     if (exist && oldMeta == newMeta) {
         return;
@@ -364,15 +367,15 @@ void DeviceMatrix::Broadcast(const DataLevel &dataLevel)
     }
     matrix.dynamic |= Low(lasts_.dynamic);
     matrix.statics |= Low(lasts_.statics);
-    if (High(matrix.dynamic) != INVALID_HIGH &&  High(lasts_.dynamic)!= INVALID_HIGH &&
+    if (High(matrix.dynamic) != INVALID_HIGH && High(lasts_.dynamic) != INVALID_HIGH &&
         High(matrix.dynamic) < High(lasts_.dynamic)) {
-            matrix.dynamic &= 0x000F;
-            matrix.dynamic |= High(matrix.dynamic);
+        matrix.dynamic &= 0x000F;
+        matrix.dynamic |= High(matrix.dynamic);
     }
-    if (High(matrix.statics) != INVALID_HIGH &&  High(lasts_.statics)!= INVALID_HIGH &&
+    if (High(matrix.statics) != INVALID_HIGH && High(lasts_.statics) != INVALID_HIGH &&
         High(matrix.statics) < High(lasts_.statics)) {
-            matrix.statics &= 0x000F;
-            matrix.statics |= High(matrix.statics);
+        matrix.statics &= 0x000F;
+        matrix.statics |= High(matrix.statics);
     }
     EventCenter::GetInstance().PostEvent(std::make_unique<MatrixEvent>(MATRIX_BROADCAST, "", matrix));
     lasts_ = matrix;
@@ -458,7 +461,7 @@ void DeviceMatrix::OnChanged(const StoreMetaData &metaData)
 void DeviceMatrix::OnExchanged(const std::string &device, uint16_t code, LevelType type, ChangeType changeType)
 {
     if (device.empty() || type < LevelType::STATICS || type > LevelType::DYNAMIC) {
-        ZLOGE("Invalid args.device:%{public}s, code:%{public}d, type:%{public}d", Anonymous::Change(device).c_str(),
+        ZLOGE("invalid args, device:%{public}s, code:%{public}d, type:%{public}d", Anonymous::Change(device).c_str(),
             code, type);
         return;
     }
@@ -486,9 +489,6 @@ void DeviceMatrix::OnExchanged(const std::string &device, uint16_t code, LevelTy
         it->second.statics &= ~codes[LevelType::STATICS];
         it->second.dynamic &= ~codes[LevelType::DYNAMIC];
         UpdateConsistentMeta(device, it->second);
-        if (observer_) {
-            observer_(device, { it->second.statics, it->second.dynamic });
-        }
     }
 }
 
@@ -675,7 +675,7 @@ void DeviceMatrix::UpdateLevel(const std::string &device, uint16_t level, Device
     bool isConsistent)
 {
     if (device.empty() || type < 0 || type >= LevelType::BUTT) {
-        ZLOGE("Invalid args.device:%{public}s, level:%{public}d, type:%{public}d", Anonymous::Change(device).c_str(),
+        ZLOGE("invalid args, device:%{public}s, level:%{public}d, type:%{public}d", Anonymous::Change(device).c_str(),
             level, type);
         return;
     }
@@ -713,15 +713,6 @@ MatrixMetaData DeviceMatrix::GetMatrixInfo(const std::string &device)
     return meta;
 }
 
-void DeviceMatrix::RegRemoteChange(std::function<void(const std::string &, std::pair<uint16_t, uint16_t>)> observer)
-{
-    if (observer_) {
-        ZLOGD("duplicate register");
-        return;
-    }
-    observer_ = std::move(observer);
-}
-
 bool DeviceMatrix::IsDynamic(const StoreMetaData &metaData)
 {
     if (metaData.dataType != LevelType::DYNAMIC) {
@@ -771,4 +762,26 @@ bool DeviceMatrix::IsSupportMatrix()
 {
     return isSupportBroadcast_;
 }
+
+bool DeviceMatrix::IsConsistent()
+{
+    std::vector<MatrixMetaData> metas;
+    if (!MetaDataManager::GetInstance().LoadMeta(MatrixMetaData::GetPrefix({}), metas, true)) {
+        return true;
+    }
+    for (const auto &meta : metas) {
+        if (meta.origin == MatrixMetaData::Origin::REMOTE_RECEIVED) {
+            MatrixMetaData consistentMeta;
+            consistentMeta.deviceId = meta.deviceId;
+            if (!MetaDataManager::GetInstance().LoadMeta(consistentMeta.GetConsistentKey(), consistentMeta, true)) {
+                return false;
+            }
+            if ((High(meta.statics) > High(consistentMeta.statics)) ||
+                (High(meta.dynamic) > High(consistentMeta.dynamic))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
 } // namespace OHOS::DistributedData
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_asset_loader.cpp b/datamgr_service/services/distributeddataservice/service/object/object_asset_loader.cpp
index acafa07b7bd5fa856035b9742d23ca8016284226..c3d582e6aef6ae46beef39d1bc06ae2c34d3794c 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_asset_loader.cpp
+++ b/datamgr_service/services/distributeddataservice/service/object/object_asset_loader.cpp
@@ -67,7 +67,6 @@ bool ObjectAssetLoader::Transfer(const int32_t userId, const std::string& bundle
 void ObjectAssetLoader::TransferAssetsAsync(const int32_t userId, const std::string& bundleName,
     const std::string& deviceId, const std::vector<DistributedData::Asset>& assets, const TransferFunc& callback)
 {
-    RADAR_REPORT(ObjectStore::CREATE, ObjectStore::TRANSFER, ObjectStore::IDLE);
     if (executors_ == nullptr) {
         ZLOGE("executors is null, bundleName: %{public}s, deviceId: %{public}s, userId: %{public}d",
             bundleName.c_str(), DistributedData::Anonymous::Change(deviceId).c_str(), userId);
@@ -124,9 +123,6 @@ void ObjectAssetLoader::FinishTask(const std::string& uri, bool result)
         if (task.downloadAssets.size() == 0 && task.callback != nullptr) {
             task.callback(result);
             finishedTasks.emplace_back(seq);
-            if (result) {
-                RADAR_REPORT(ObjectStore::CREATE, ObjectStore::TRANSFER, ObjectStore::RADAR_SUCCESS);
-            }
         }
         return false;
     });
@@ -171,7 +167,8 @@ bool ObjectAssetLoader::IsDownloaded(const DistributedData::Asset& asset)
 int32_t ObjectAssetLoader::PushAsset(int32_t userId, const sptr<AssetObj> &assetObj,
     const sptr<ObjectAssetsSendListener> &sendCallback)
 {
-    RADAR_REPORT(ObjectStore::SAVE, ObjectStore::PUSH_ASSETS, ObjectStore::IDLE);
+    ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::SAVE,
+        ObjectStore::PUSH_ASSETS, ObjectStore::IDLE);
     ZLOGI("PushAsset start, asset size:%{public}zu, bundleName:%{public}s, sessionId:%{public}s",
         assetObj->uris_.size(), assetObj->dstBundleName_.c_str(), assetObj->sessionId_.c_str());
     auto status = Storage::DistributedFile::DistributedFileDaemonManager::GetInstance().PushAsset(userId, assetObj,
@@ -179,20 +176,27 @@ int32_t ObjectAssetLoader::PushAsset(int32_t userId, const sptr<AssetObj> &asset
     if (status != OBJECT_SUCCESS) {
         ZLOGE("PushAsset err status: %{public}d, asset size:%{public}zu, bundleName:%{public}s, sessionId:%{public}s",
             status, assetObj->uris_.size(), assetObj->dstBundleName_.c_str(), assetObj->sessionId_.c_str());
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, status);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_FAILED, status, ObjectStore::FINISHED);
     }
     return status;
 }
 
 int32_t ObjectAssetsSendListener::OnSendResult(const sptr<AssetObj> &assetObj, int32_t result)
 {
+    if (assetObj == nullptr) {
+        ZLOGE("OnSendResult error! status:%{public}d", result);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
+        return result;
+    }
     ZLOGI("OnSendResult, status:%{public}d, asset size:%{public}zu", result, assetObj->uris_.size());
     if (result == OBJECT_SUCCESS) {
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_SUCCESS);
+        ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_SUCCESS);
     } else {
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, result);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::PUSH_ASSETS, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
     }
     return result;
 }
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_asset_machine.cpp b/datamgr_service/services/distributeddataservice/service/object/object_asset_machine.cpp
index ce67d4df90da1df64b81162aea7d850ca32f6707..b15277a6cedaa221bbd1157cedf0cb36b1d27a79 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_asset_machine.cpp
+++ b/datamgr_service/services/distributeddataservice/service/object/object_asset_machine.cpp
@@ -125,7 +125,7 @@ static const DFAAction AssetDFA[STATUS_BUTT][EVENT_BUTT] = {
         { STATUS_STABLE, nullptr, (Action)CompensateSync },              // transfer_finished
         { STATUS_WAIT_UPLOAD, nullptr, (Action)ChangeAssetToNormal },    // upload
         { STATUS_NO_CHANGE, nullptr, (Action)Recover },                  // upload_finished
-        { STATUS_WAIT_DOWNLOAD, nullptr, (Action)STATUS_WAIT_DOWNLOAD }, // download
+        { STATUS_WAIT_DOWNLOAD, nullptr, (Action)ChangeAssetToNormal }, // download
         { STATUS_NO_CHANGE, nullptr, (Action)Recover },                  // download_finished
     }
 };
@@ -201,8 +201,8 @@ static VBuckets GetMigratedData(AutoCache::Store& store, AssetBindInfo& assetBin
     Values args;
     VBuckets vBuckets;
     auto sql = BuildSql(assetBindInfo, args);
-    auto cursor = store->Query(assetBindInfo.tableName, sql, std::move(args));
-    if (cursor == nullptr) {
+    auto [errCode, cursor] = store->Query(assetBindInfo.tableName, sql, std::move(args));
+    if (errCode != E_OK || cursor == nullptr) {
         return vBuckets;
     }
     int32_t count = cursor->GetCount();
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_data_listener.cpp b/datamgr_service/services/distributeddataservice/service/object/object_data_listener.cpp
index 4bd3c3d5d7977f4eabcfd9382cd21330b10cafb8..1c58fb4934c315ffb37f25faddceaf7815418497 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_data_listener.cpp
+++ b/datamgr_service/services/distributeddataservice/service/object/object_data_listener.cpp
@@ -18,6 +18,8 @@
 #include "object_data_listener.h"
 #include "log_print.h"
 #include "object_manager.h"
+#include "object_radar_reporter.h"
+#include "utils/anonymous.h"
 namespace OHOS {
 namespace DistributedObject {
 ObjectDataListener::ObjectDataListener()
@@ -56,10 +58,17 @@ int32_t ObjectAssetsRecvListener::OnStart(const std::string &srcNetworkId, const
 int32_t ObjectAssetsRecvListener::OnFinished(const std::string &srcNetworkId, const sptr<AssetObj> &assetObj,
     int32_t result)
 {
+    if (assetObj == nullptr) {
+        ZLOGE("OnFinished error! status:%{public}d, srcNetworkId:%{public}s", result,
+            DistributedData::Anonymous::Change(srcNetworkId).c_str());
+        ObjectStore::RadarReporter::ReportStageError(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+            ObjectStore::ASSETS_RECV, ObjectStore::RADAR_FAILED, result);
+        return result;
+    }
     auto objectKey = assetObj->dstBundleName_+assetObj->sessionId_;
     ZLOGI("OnFinished, status:%{public}d objectKey:%{public}s, asset size:%{public}zu", result, objectKey.c_str(),
         assetObj->uris_.size());
-    ObjectStoreManager::GetInstance()->NotifyAssetsReady(objectKey, srcNetworkId);
+    ObjectStoreManager::GetInstance()->NotifyAssetsReady(objectKey, assetObj->dstBundleName_, srcNetworkId);
     return OBJECT_SUCCESS;
 }
 }  // namespace DistributedObject
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp b/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp
index c4c231e28692b41f87c4919fe6d0965558afc166..2089491ab32e79efc5afb4e1a8730958782819e2 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/object/object_manager.cpp
@@ -47,6 +47,7 @@ using Account = OHOS::DistributedKv::AccountDelegate;
 using AccessTokenKit = Security::AccessToken::AccessTokenKit;
 using ValueProxy = OHOS::DistributedData::ValueProxy;
 using DistributedFileDaemonManager = Storage::DistributedFile::DistributedFileDaemonManager;
+constexpr const char *SAVE_INFO = "p_###SAVEINFO###";
 ObjectStoreManager::ObjectStoreManager()
 {
     ZLOGI("ObjectStoreManager construct");
@@ -150,8 +151,8 @@ int32_t ObjectStoreManager::Save(const std::string &appId, const std::string &se
     if (result != OBJECT_SUCCESS) {
         ZLOGE("Open failed, errCode = %{public}d", result);
         proxy->Completed(std::map<std::string, int32_t>());
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, ObjectStore::GETKV_FAILED, ObjectStore::BIZ_STATE, ObjectStore::FINISHED);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_FAILED, ObjectStore::GETKV_FAILED, ObjectStore::FINISHED);
         return STORE_NOT_OPEN;
     }
 
@@ -160,6 +161,8 @@ int32_t ObjectStoreManager::Save(const std::string &appId, const std::string &se
     result = SaveToStore(appId, sessionId, deviceId, data);
     if (result != OBJECT_SUCCESS) {
         ZLOGE("Save failed, errCode = %{public}d", result);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
         Close();
         proxy->Completed(std::map<std::string, int32_t>());
         return result;
@@ -168,14 +171,15 @@ int32_t ObjectStoreManager::Save(const std::string &appId, const std::string &se
         proxy->Completed(results);
         ProcessSyncCallback(results, appId, sessionId, deviceId);
     };
-    ZLOGD("start SyncOnStore");
+    ZLOGI("Sync data, bundleName: %{public}s, sessionId: %{public}s, deviceId: %{public}s", appId.c_str(),
+        sessionId.c_str(), Anonymous::Change(deviceId).c_str());
     std::vector<std::string> deviceList = {deviceId};
     result = SyncOnStore(GetPropertyPrefix(appId, sessionId, deviceId), deviceList, tmp);
     if (result != OBJECT_SUCCESS) {
         ZLOGE("sync failed, errCode = %{public}d", result);
         proxy->Completed(std::map<std::string, int32_t>());
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, result, ObjectStore::BIZ_STATE, ObjectStore::FINISHED);
+        ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+            ObjectStore::SYNC_DATA, ObjectStore::RADAR_FAILED, result, ObjectStore::FINISHED);
     }
     result = PushAssets(std::stoi(GetCurrentUser()), appId, sessionId, data, deviceId);
     Close();
@@ -268,13 +272,16 @@ int32_t ObjectStoreManager::Retrieve(
         allReady = true;
     } else {
         auto objectKey = bundleName + sessionId;
-        restoreStatus_.ComputeIfAbsent(
-            objectKey, [](const std::string& key) -> auto {
-            return RestoreStatus::NONE;
+        restoreStatus_.ComputeIfPresent(objectKey, [&allReady](const auto &key, auto &value) {
+            if (value == RestoreStatus::ALL_READY) {
+                allReady = true;
+                return false;
+            }
+            if (value == RestoreStatus::DATA_READY) {
+                value = RestoreStatus::DATA_NOTIFIED;
+            }
+            return true;
         });
-        if (restoreStatus_[objectKey] == RestoreStatus::ALL_READY) {
-            allReady = true;
-        }
     }
     // delete local data
     status = RevokeSaveToStore(GetPrefixWithoutDeviceId(bundleName, sessionId));
@@ -286,8 +293,10 @@ int32_t ObjectStoreManager::Retrieve(
     }
     Close();
     proxy->Completed(results, allReady);
-    RADAR_REPORT(ObjectStore::CREATE, ObjectStore::RESTORE, ObjectStore::RADAR_SUCCESS, ObjectStore::BIZ_STATE,
-        ObjectStore::FINISHED);
+    if (allReady) {
+        ObjectStore::RadarReporter::ReportStateFinished(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+            ObjectStore::NOTIFY, ObjectStore::RADAR_SUCCESS, ObjectStore::FINISHED);
+    }
     return status;
 }
 
@@ -399,61 +408,113 @@ void ObjectStoreManager::UnregisterRemoteCallback(const std::string &bundleName,
 void ObjectStoreManager::NotifyChange(std::map<std::string, std::vector<uint8_t>> &changedData)
 {
     ZLOGI("OnChange start, size:%{public}zu", changedData.size());
-    std::map<std::string, std::map<std::string, Assets>> changedAssets = GetAssetsFromStore(changedData);
-    std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data;
     bool hasAsset = false;
-    for (const auto &item : changedData) {
-        std::vector<std::string> splitKeys = SplitEntryKey(item.first);
-        if (splitKeys.empty()) {
-            continue;
-        }
-        std::string prefix = splitKeys[BUNDLE_NAME_INDEX] + splitKeys[SESSION_ID_INDEX];
-        std::string propertyName = splitKeys[PROPERTY_NAME_INDEX];
-        data[prefix].insert_or_assign(propertyName, item.second);
-        if (IsAssetKey(propertyName)) {
-            hasAsset = true;
+    SaveInfo saveInfo;
+    for (const auto &[key, value] : changedData) {
+        if (key.find(SAVE_INFO) != std::string::npos) {
+            DistributedData::Serializable::Unmarshall(std::string(value.begin(), value.end()), saveInfo);
+            break;
         }
     }
+    auto data = GetObjectData(changedData, saveInfo, hasAsset);
     if (!hasAsset) {
+        ObjectStore::RadarReporter::ReportStateStart(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+            ObjectStore::DATA_RECV, ObjectStore::RADAR_SUCCESS, ObjectStore::START, saveInfo.bundleName);
         callbacks_.ForEach([this, &data](uint32_t tokenId, const CallbackInfo& value) {
             DoNotify(tokenId, value, data, true); // no asset, data ready means all ready
             return false;
         });
         return;
     }
-    NotifyDataChanged(data);
+    NotifyDataChanged(data, saveInfo);
     SaveUserToMeta();
 }
 
-void ObjectStoreManager::NotifyDataChanged(std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data)
+std::map<std::string, std::map<std::string, std::vector<uint8_t>>> ObjectStoreManager::GetObjectData(
+    const std::map<std::string, std::vector<uint8_t>>& changedData, SaveInfo& saveInfo, bool& hasAsset)
 {
-    for (auto const& [objectKey, results] : data) {
-        restoreStatus_.ComputeIfAbsent(
-            objectKey, [](const std::string& key) -> auto {
-            return RestoreStatus::NONE;
-        });
-        if (restoreStatus_[objectKey] == RestoreStatus::ASSETS_READY) {
-            restoreStatus_[objectKey] = RestoreStatus::ALL_READY;
+    std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data;
+    std::string keyPrefix = saveInfo.ToPropertyPrefix();
+    if (!keyPrefix.empty()) {
+        std::string observerKey = saveInfo.bundleName + saveInfo.sessionId;
+        for (const auto &[key, value] : changedData) {
+            if (key.size() < keyPrefix.size() || key.find(SAVE_INFO) != std::string::npos) {
+                continue;
+            }
+            std::string propertyName = key.substr(keyPrefix.size());
+            data[observerKey].insert_or_assign(propertyName, value);
+            if (!hasAsset && IsAssetKey(propertyName)) {
+                hasAsset = true;
+            }
+        }
+    } else {
+        for (const auto &item : changedData) {
+            std::vector<std::string> splitKeys = SplitEntryKey(item.first);
+            if (splitKeys.size() <= PROPERTY_NAME_INDEX) {
+                continue;
+            }
+            if (saveInfo.sourceDeviceId.empty() || saveInfo.bundleName.empty()) {
+                saveInfo.sourceDeviceId = splitKeys[SOURCE_DEVICE_UDID_INDEX];
+                saveInfo.bundleName = splitKeys[BUNDLE_NAME_INDEX];
+                saveInfo.sessionId = splitKeys[SESSION_ID_INDEX];
+                saveInfo.timestamp = splitKeys[TIME_INDEX];
+            }
+            std::string prefix = splitKeys[BUNDLE_NAME_INDEX] + splitKeys[SESSION_ID_INDEX];
+            std::string propertyName = splitKeys[PROPERTY_NAME_INDEX];
+            data[prefix].insert_or_assign(propertyName, item.second);
+            if (IsAssetKey(propertyName)) {
+                hasAsset = true;
+            }
+        }
+    }
+    return data;
+}
+
+void ObjectStoreManager::ComputeStatus(const std::string& objectKey, const SaveInfo& saveInfo,
+    const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data)
+{
+    restoreStatus_.Compute(objectKey, [this, &data, saveInfo] (const auto &key, auto &value) {
+        if (value == RestoreStatus::ASSETS_READY) {
+            value = RestoreStatus::ALL_READY;
+            ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::DATA_RECV, ObjectStore::RADAR_SUCCESS);
             callbacks_.ForEach([this, &data](uint32_t tokenId, const CallbackInfo& value) {
                 DoNotify(tokenId, value, data, true);
                 return false;
             });
         } else {
-            restoreStatus_[objectKey] = RestoreStatus::DATA_READY;
+            value = RestoreStatus::DATA_READY;
+            ObjectStore::RadarReporter::ReportStateStart(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::DATA_RECV, ObjectStore::RADAR_SUCCESS, ObjectStore::START, saveInfo.bundleName);
             callbacks_.ForEach([this, &data](uint32_t tokenId, const CallbackInfo& value) {
                 DoNotify(tokenId, value, data, false);
                 return false;
             });
-            WaitAssets(objectKey);
+            WaitAssets(key, saveInfo, data);
         }
+        return true;
+    });
+}
+
+void ObjectStoreManager::NotifyDataChanged(
+    const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data, const SaveInfo& saveInfo)
+{
+    for (auto const& [objectKey, results] : data) {
+        restoreStatus_.ComputeIfAbsent(
+            objectKey, [](const std::string& key) -> auto {
+            return RestoreStatus::NONE;
+        });
+        ComputeStatus(objectKey, saveInfo, data);
     }
 }
 
-int32_t ObjectStoreManager::WaitAssets(const std::string& objectKey)
+int32_t ObjectStoreManager::WaitAssets(const std::string& objectKey, const SaveInfo& saveInfo,
+    const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data)
 {
-    auto taskId = executors_->Schedule(std::chrono::seconds(WAIT_TIME), [this, objectKey]() {
-        ZLOGE("wait assets finisehd timeout, objectKey:%{public}s", objectKey.c_str());
-        NotifyAssetsReady(objectKey);
+    auto taskId = executors_->Schedule(std::chrono::seconds(WAIT_TIME), [this, objectKey, data, saveInfo]() {
+        ZLOGE("wait assets finisehd timeout, try pull assets, objectKey:%{public}s", objectKey.c_str());
+        PullAssets(data, saveInfo);
+        DoNotifyWaitAssetTimeout(objectKey);
     });
 
     objectTimer_.ComputeIfAbsent(
@@ -463,73 +524,66 @@ int32_t ObjectStoreManager::WaitAssets(const std::string& objectKey)
     return  OBJECT_SUCCESS;
 }
 
-void ObjectStoreManager::NotifyAssetsReady(const std::string& objectKey, const std::string& srcNetworkId)
+void ObjectStoreManager::PullAssets(const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data,
+    const SaveInfo& saveInfo)
 {
-    restoreStatus_.ComputeIfAbsent(
-        objectKey, [](const std::string& key) -> auto {
-        return RestoreStatus::NONE;
-    });
-    if (restoreStatus_[objectKey] == RestoreStatus::DATA_READY) {
-        restoreStatus_[objectKey] = RestoreStatus::ALL_READY;
-        callbacks_.ForEach([this, objectKey](uint32_t tokenId, const CallbackInfo& value) {
-            DoNotifyAssetsReady(tokenId, value,  objectKey, true);
-            return false;
+    std::map<std::string, Assets> changedAssets;
+    for (auto const& [objectId, result] : data) {
+        changedAssets[objectId] = GetAssetsFromDBRecords(result);
+    }
+    for (const auto& [objectId, assets] : changedAssets) {
+        std::string networkId = DmAdaper::GetInstance().ToNetworkID(saveInfo.sourceDeviceId);
+        auto block = std::make_shared<BlockData<std::tuple<bool, bool>>>(WAIT_TIME, std::tuple{ true, true });
+        ObjectAssetLoader::GetInstance()->TransferAssetsAsync(std::stoi(GetCurrentUser()),
+            saveInfo.bundleName, networkId, assets, [this, block](bool success) {
+                block->SetValue({ false, success });
         });
-    } else {
-        restoreStatus_[objectKey] = RestoreStatus::ASSETS_READY;
+        auto [timeout, success] = block->GetValue();
+        ZLOGI("Pull assets end, timeout: %{public}d, success: %{public}d, size:%{public}zu, deviceId: %{public}s",
+            timeout, success, assets.size(), DistributedData::Anonymous::Change(networkId).c_str());
     }
 }
 
-void ObjectStoreManager::NotifyAssetsStart(const std::string& objectKey, const std::string& srcNetworkId)
+void ObjectStoreManager::NotifyAssetsReady(const std::string& objectKey, const std::string& bundleName,
+    const std::string& srcNetworkId)
 {
     restoreStatus_.ComputeIfAbsent(
         objectKey, [](const std::string& key) -> auto {
         return RestoreStatus::NONE;
     });
+    restoreStatus_.Compute(objectKey, [this, &bundleName] (const auto &key, auto &value) {
+        if (value == RestoreStatus::DATA_NOTIFIED) {
+            value = RestoreStatus::ALL_READY;
+            ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::ASSETS_RECV, ObjectStore::RADAR_SUCCESS);
+            callbacks_.ForEach([this, key](uint32_t tokenId, const CallbackInfo& value) {
+                DoNotifyAssetsReady(tokenId, value,  key, true);
+                return false;
+            });
+        } else if (value == RestoreStatus::DATA_READY) {
+            value = RestoreStatus::ALL_READY;
+            ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::ASSETS_RECV, ObjectStore::RADAR_SUCCESS);
+            auto [has, taskId] = objectTimer_.Find(key);
+            if (has) {
+                executors_->Remove(taskId);
+                objectTimer_.Erase(key);
+            }
+        } else {
+            value = RestoreStatus::ASSETS_READY;
+            ObjectStore::RadarReporter::ReportStateStart(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::ASSETS_RECV, ObjectStore::RADAR_SUCCESS, ObjectStore::START, bundleName);
+        }
+        return true;
+    });
 }
 
-std::map<std::string, std::map<std::string, Assets>> ObjectStoreManager::GetAssetsFromStore(
-    const std::map<std::string, std::vector<uint8_t>>& changedData)
+void ObjectStoreManager::NotifyAssetsStart(const std::string& objectKey, const std::string& srcNetworkId)
 {
-    std::set<std::string> assetKeyPrefix;
-    for (const auto& item : changedData) {
-        if (IsAssetKey(GetPropertyName(item.first))) {
-            assetKeyPrefix.insert(item.first.substr(0, item.first.find_last_of(ObjectStore::ASSET_DOT)));
-        }
-    }
-    std::map<std::string, std::map<std::string, std::map<std::string, std::vector<uint8_t>>>> results;
-    for (const auto& keyPrefix : assetKeyPrefix) {
-        std::vector<DistributedDB::Entry> entries;
-        auto status = delegate_->GetEntries(std::vector<uint8_t>(keyPrefix.begin(), keyPrefix.end()), entries);
-        if (status != DistributedDB::DBStatus::OK) {
-            ZLOGE("GetEntries fail. keyPrefix = %{public}s", keyPrefix.c_str());
-            continue;
-        }
-        std::map<std::string, std::vector<uint8_t>> result{};
-        std::for_each(entries.begin(), entries.end(), [&result, this](const DistributedDB::Entry entry) {
-            std::string key(entry.key.begin(), entry.key.end());
-            result[GetPropertyName(key)] = entry.value;
-        });
-        std::vector<std::string> splitKeys = SplitEntryKey(keyPrefix);
-        if (splitKeys.empty() || !IsAssetComplete(result, splitKeys[PROPERTY_NAME_INDEX])) {
-            continue;
-        }
-        std::string bundleName = splitKeys[BUNDLE_NAME_INDEX];
-        std::string networkId = DmAdaper::GetInstance().ToNetworkID(splitKeys[SOURCE_DEVICE_UDID_INDEX]);
-        for (const auto &[key, value] : result) {
-            results[bundleName][networkId][key] = value;
-        }
-    }
-    std::map<std::string, std::map<std::string, Assets>> changedAssets{};
-    for (const auto& resultOfBundle : results) {
-        std::string bundleName = resultOfBundle.first;
-        for (const auto& resultOfDevice : resultOfBundle.second) {
-            std::string deviceId = resultOfDevice.first;
-            Assets assets = GetAssetsFromDBRecords(resultOfDevice.second);
-            changedAssets[bundleName][deviceId] = assets;
-        }
-    }
-    return changedAssets;
+    restoreStatus_.ComputeIfAbsent(
+        objectKey, [](const std::string& key) -> auto {
+        return RestoreStatus::NONE;
+    });
 }
 
 bool ObjectStoreManager::IsAssetKey(const std::string& key)
@@ -601,6 +655,13 @@ void ObjectStoreManager::DoNotify(uint32_t tokenId, const CallbackInfo& value,
         observer.second->Completed((*it).second, allReady);
         if (allReady) {
             restoreStatus_.Erase(observer.first);
+            ObjectStore::RadarReporter::ReportStateFinished(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::NOTIFY, ObjectStore::RADAR_SUCCESS, ObjectStore::FINISHED);
+        } else {
+            restoreStatus_.ComputeIfPresent(observer.first, [](const auto &key, auto &value) {
+                value = RestoreStatus::DATA_NOTIFIED;
+                return true;
+            });
         }
     }
 }
@@ -615,6 +676,8 @@ void ObjectStoreManager::DoNotifyAssetsReady(uint32_t tokenId, const CallbackInf
         observer.second->Completed(std::map<std::string, std::vector<uint8_t>>(), allReady);
         if (allReady) {
             restoreStatus_.Erase(objectKey);
+            ObjectStore::RadarReporter::ReportStateFinished(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::NOTIFY, ObjectStore::RADAR_SUCCESS, ObjectStore::FINISHED);
         }
         auto [has, taskId] = objectTimer_.Find(objectKey);
         if (has) {
@@ -624,6 +687,29 @@ void ObjectStoreManager::DoNotifyAssetsReady(uint32_t tokenId, const CallbackInf
     }
 }
 
+void ObjectStoreManager::DoNotifyWaitAssetTimeout(const std::string &objectKey)
+{
+    ObjectStore::RadarReporter::ReportStageError(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+        ObjectStore::ASSETS_RECV, ObjectStore::RADAR_FAILED, ObjectStore::TIMEOUT);
+    callbacks_.ForEach([this, &objectKey](uint32_t tokenId, const CallbackInfo &value) {
+        for (const auto& observer : value.observers_) {
+            if (objectKey != observer.first) {
+                continue;
+            }
+            observer.second->Completed(std::map<std::string, std::vector<uint8_t>>(), true);
+            restoreStatus_.Erase(objectKey);
+            auto [has, taskId] = objectTimer_.Find(objectKey);
+            if (has) {
+                executors_->Remove(taskId);
+                objectTimer_.Erase(objectKey);
+            }
+            ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::DATA_RESTORE,
+                ObjectStore::NOTIFY, ObjectStore::RADAR_FAILED, ObjectStore::TIMEOUT, ObjectStore::FINISHED);
+        }
+        return false;
+    });
+}
+
 void ObjectStoreManager::SetData(const std::string &dataDir, const std::string &userId)
 {
     ZLOGI("enter %{public}s", dataDir.c_str());
@@ -662,6 +748,12 @@ void ObjectStoreManager::Close()
     if (delegate_ == nullptr) {
         return;
     }
+    int32_t taskCount = delegate_->GetTaskCount();
+    if (taskCount > 0 && syncCount_ == 1) {
+        CloseAfterMinute();
+        ZLOGW("Store is busy, close after a minute, task count: %{public}d", taskCount);
+        return;
+    }
     syncCount_--;
     ZLOGI("closed a store, syncCount = %{public}d", syncCount_);
     FlushClosedStore();
@@ -677,8 +769,19 @@ void ObjectStoreManager::SyncCompleted(
         SetSyncStatus(false);
         FlushClosedStore();
     }
+    for (const auto &item : results) {
+        if (item.second == DistributedDB::DBStatus::OK) {
+            ZLOGI("Sync success, sequenceId: 0x%{public}" PRIx64 "", sequenceId);
+            ObjectStore::RadarReporter::ReportStateFinished(std::string(__FUNCTION__), ObjectStore::SAVE,
+                ObjectStore::SYNC_DATA, ObjectStore::RADAR_SUCCESS, ObjectStore::FINISHED);
+        } else {
+            ZLOGE("Sync failed, sequenceId: 0x%{public}" PRIx64 ", status: %{public}d", sequenceId, item.second);
+            ObjectStore::RadarReporter::ReportStateError(std::string(__FUNCTION__), ObjectStore::SAVE,
+                ObjectStore::SYNC_DATA, ObjectStore::RADAR_FAILED, item.second, ObjectStore::FINISHED);
+        }
+    }
 }
-
+        
 void ObjectStoreManager::FlushClosedStore()
 {
     std::lock_guard<std::recursive_mutex> lock(kvStoreMutex_);
@@ -719,14 +822,15 @@ void ObjectStoreManager::ProcessOldEntry(const std::string &appId)
         if (splitKeys.empty()) {
             continue;
         }
-        std::string id = splitKeys[SESSION_ID_INDEX];
-        if (sessionIds.count(id) == 0) {
+        std::string bundleName = splitKeys[BUNDLE_NAME_INDEX];
+        std::string sessionId = splitKeys[SESSION_ID_INDEX];
+        if (sessionIds.count(sessionId) == 0) {
             char *end = nullptr;
-            sessionIds[id] = strtol(splitKeys[TIME_INDEX].c_str(), &end, DECIMAL_BASE);
+            sessionIds[sessionId] = strtol(splitKeys[TIME_INDEX].c_str(), &end, DECIMAL_BASE);
         }
-        if (oldestTime == 0 || oldestTime > sessionIds[id]) {
-            oldestTime = sessionIds[id];
-            deleteKey = GetPrefixWithoutDeviceId(appId, id);
+        if (oldestTime == 0 || oldestTime > sessionIds[sessionId]) {
+            oldestTime = sessionIds[sessionId];
+            deleteKey = GetPrefixWithoutDeviceId(bundleName, sessionId);
         }
     }
     if (sessionIds.size() < MAX_OBJECT_SIZE_PER_APP) {
@@ -747,6 +851,13 @@ int32_t ObjectStoreManager::SaveToStore(const std::string &appId, const std::str
     RevokeSaveToStore(GetPropertyPrefix(appId, sessionId, toDeviceId));
     std::string timestamp = std::to_string(GetSecondsSince1970ToNow());
     std::vector<DistributedDB::Entry> entries;
+    DistributedDB::Entry saveInfoEntry;
+    std::string saveInfoKey = GetPropertyPrefix(appId, sessionId, toDeviceId) + timestamp + SEPERATOR + SAVE_INFO;
+    saveInfoEntry.key = std::vector<uint8_t>(saveInfoKey.begin(), saveInfoKey.end());
+    SaveInfo saveInfo(appId, sessionId, DmAdaper::GetInstance().GetLocalDevice().udid, toDeviceId, timestamp);
+    std::string saveInfoValue = DistributedData::Serializable::Marshall(saveInfo);
+    saveInfoEntry.value = std::vector<uint8_t>(saveInfoValue.begin(), saveInfoValue.end());
+    entries.emplace_back(saveInfoEntry);
     for (auto &item : data) {
         DistributedDB::Entry entry;
         std::string tmp = GetPropertyPrefix(appId, sessionId, toDeviceId) + timestamp + SEPERATOR + item.first;
@@ -757,8 +868,6 @@ int32_t ObjectStoreManager::SaveToStore(const std::string &appId, const std::str
     auto status = delegate_->PutBatch(entries);
     if (status != DistributedDB::DBStatus::OK) {
         ZLOGE("putBatch fail %{public}d", status);
-        RADAR_REPORT(ObjectStore::SAVE, ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, status, ObjectStore::BIZ_STATE, ObjectStore::FINISHED);
     }
     return status;
 }
@@ -782,7 +891,7 @@ int32_t ObjectStoreManager::SyncOnStore(
         uint64_t sequenceId = SequenceSyncManager::GetInstance()->AddNotifier(userId_, callback);
         DistributedDB::Query dbQuery = DistributedDB::Query::Select();
         dbQuery.PrefixKey(std::vector<uint8_t>(prefix.begin(), prefix.end()));
-        ZLOGD("start sync");
+        ZLOGI("Start sync, sequenceId: 0x%{public}" PRIx64 "", sequenceId);
         auto status = delegate_->Sync(
             syncDevices, DistributedDB::SyncMode::SYNC_MODE_PUSH_ONLY,
             [this, sequenceId](const std::map<std::string, DistributedDB::DBStatus> &devicesMap) {
@@ -855,28 +964,69 @@ int32_t ObjectStoreManager::RetrieveFromStore(
         return DB_ERROR;
     }
     ZLOGI("GetEntries successfully");
-    std::for_each(entries.begin(), entries.end(), [&results, this](const DistributedDB::Entry &entry) {
+    for (const auto &entry : entries) {
         std::string key(entry.key.begin(), entry.key.end());
-        results[GetPropertyName(key)] = entry.value;
-    });
+        if (key.find(SAVE_INFO) != std::string::npos) {
+            continue;
+        }
+        auto splitKeys = SplitEntryKey(key);
+        if (!splitKeys.empty()) {
+            results[splitKeys[PROPERTY_NAME_INDEX]] = entry.value;
+        }
+    }
     return OBJECT_SUCCESS;
 }
 
+ObjectStoreManager::SaveInfo::SaveInfo(const std::string &bundleName, const std::string &sessionId,
+    const std::string &sourceDeviceId, const std::string &targetDeviceId, const std::string &timestamp)
+    : bundleName(bundleName), sessionId(sessionId), sourceDeviceId(sourceDeviceId), targetDeviceId(targetDeviceId),
+    timestamp(timestamp) {}
+
+bool ObjectStoreManager::SaveInfo::Marshal(json &node) const
+{
+    SetValue(node[GET_NAME(bundleName)], bundleName);
+    SetValue(node[GET_NAME(sessionId)], sessionId);
+    SetValue(node[GET_NAME(sourceDeviceId)], sourceDeviceId);
+    SetValue(node[GET_NAME(targetDeviceId)], targetDeviceId);
+    SetValue(node[GET_NAME(timestamp)], timestamp);
+    return true;
+}
+
+bool ObjectStoreManager::SaveInfo::Unmarshal(const json &node)
+{
+    GetValue(node, GET_NAME(bundleName), bundleName);
+    GetValue(node, GET_NAME(sessionId), sessionId);
+    GetValue(node, GET_NAME(sourceDeviceId), sourceDeviceId);
+    GetValue(node, GET_NAME(targetDeviceId), targetDeviceId);
+    GetValue(node, GET_NAME(timestamp), timestamp);
+    return true;
+}
+
+std::string ObjectStoreManager::SaveInfo::ToPropertyPrefix()
+{
+    if (bundleName.empty() || sessionId.empty() || sourceDeviceId.empty() || targetDeviceId.empty() ||
+        timestamp.empty()) {
+        return "";
+    }
+    return bundleName + SEPERATOR + sessionId + SEPERATOR + sourceDeviceId + SEPERATOR + targetDeviceId + SEPERATOR +
+        timestamp + SEPERATOR;
+}
+
 std::vector<std::string> ObjectStoreManager::SplitEntryKey(const std::string &key)
 {
     std::smatch match;
     std::regex timeRegex(TIME_REGEX);
     if (!std::regex_search(key, match, timeRegex)) {
-        ZLOGE("Format error, key.size = %{public}zu", key.size());
+        ZLOGW("Format error, key.size = %{public}zu", key.size());
         return {};
     }
-    size_t timePos = match.position();
+    auto timePos = match.position();
     std::string fromTime = key.substr(timePos + 1);
     std::string beforeTime = key.substr(0, timePos);
 
     size_t targetDevicePos = beforeTime.find_last_of(SEPERATOR);
     if (targetDevicePos == std::string::npos) {
-        ZLOGE("Format error, key.size = %{public}zu", key.size());
+        ZLOGW("Format error, key.size = %{public}zu", key.size());
         return {};
     }
     std::string targetDevice = beforeTime.substr(targetDevicePos + 1);
@@ -884,7 +1034,7 @@ std::vector<std::string> ObjectStoreManager::SplitEntryKey(const std::string &ke
 
     size_t sourceDeviceUdidPos = beforeTargetDevice.find_last_of(SEPERATOR);
     if (sourceDeviceUdidPos == std::string::npos) {
-        ZLOGE("Format error, key.size = %{public}zu", key.size());
+        ZLOGW("Format error, key.size = %{public}zu", key.size());
         return {};
     }
     std::string sourceDeviceUdid = beforeTargetDevice.substr(sourceDeviceUdidPos + 1);
@@ -892,7 +1042,7 @@ std::vector<std::string> ObjectStoreManager::SplitEntryKey(const std::string &ke
 
     size_t sessionIdPos = beforeSourceDeviceUdid.find_last_of(SEPERATOR);
     if (sessionIdPos == std::string::npos) {
-        ZLOGE("Format error, key.size = %{public}zu", key.size());
+        ZLOGW("Format error, key.size = %{public}zu", key.size());
         return {};
     }
     std::string sessionId = beforeSourceDeviceUdid.substr(sessionIdPos + 1);
@@ -900,7 +1050,7 @@ std::vector<std::string> ObjectStoreManager::SplitEntryKey(const std::string &ke
 
     size_t propertyNamePos = fromTime.find_first_of(SEPERATOR);
     if (propertyNamePos == std::string::npos) {
-        ZLOGE("Format error, key.size = %{public}zu", key.size());
+        ZLOGW("Format error, key.size = %{public}zu", key.size());
         return {};
     }
     std::string propertyName = fromTime.substr(propertyNamePos + 1);
@@ -909,12 +1059,6 @@ std::vector<std::string> ObjectStoreManager::SplitEntryKey(const std::string &ke
     return { bundleName, sessionId, sourceDeviceUdid, targetDevice, time, propertyName };
 }
 
-std::string ObjectStoreManager::GetPropertyName(const std::string &key)
-{
-    std::vector<std::string> splitKeys = SplitEntryKey(key);
-    return splitKeys.empty() ? "" : splitKeys[PROPERTY_NAME_INDEX];
-}
-
 std::string ObjectStoreManager::GetCurrentUser()
 {
     std::vector<int> users;
@@ -1026,7 +1170,11 @@ int32_t ObjectStoreManager::BindAsset(const uint32_t tokenId, const std::string&
         storeKey, [](const std::string& key) -> auto {
             return std::make_shared<std::map<std::string, std::shared_ptr<Snapshot>>>();
         });
-    bindSnapshots_[storeKey]->emplace(std::pair{asset.uri, snapshots_[snapshotKey]});
+    auto snapshots = snapshots_.Find(snapshotKey).second;
+    bindSnapshots_.Compute(storeKey, [this, &asset, snapshots] (const auto &key, auto &value) {
+        value->emplace(std::pair{asset.uri, snapshots});
+        return true;
+    });
 
     HapTokenInfo tokenInfo;
     auto status = AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo);
@@ -1041,7 +1189,10 @@ int32_t ObjectStoreManager::BindAsset(const uint32_t tokenId, const std::string&
     storeInfo.user = tokenInfo.userID;
     storeInfo.storeName = bindInfo.storeName;
 
-    snapshots_[snapshotKey]->BindAsset(ValueProxy::Convert(std::move(asset)), ConvertBindInfo(bindInfo), storeInfo);
+    snapshots_.Compute(snapshotKey, [this, &asset, &bindInfo, &storeInfo] (const auto &key, auto &value) {
+        value->BindAsset(ValueProxy::Convert(std::move(asset)), ConvertBindInfo(bindInfo), storeInfo);
+        return true;
+    });
     return OBJECT_SUCCESS;
 }
 
@@ -1063,8 +1214,16 @@ int32_t ObjectStoreManager::OnAssetChanged(const uint32_t tokenId, const std::st
     auto objectAsset = asset;
     Asset dataAsset =  ValueProxy::Convert(std::move(objectAsset));
     auto snapshotKey = appId + SEPERATOR + sessionId;
-    if (snapshots_.Contains(snapshotKey) && snapshots_[snapshotKey]->IsBoundAsset(dataAsset)) {
-        return snapshots_[snapshotKey]->OnDataChanged(dataAsset, deviceId); // needChange
+    int32_t res = OBJECT_SUCCESS;
+    bool exist = snapshots_.ComputeIfPresent(snapshotKey,
+        [&res, &dataAsset, &deviceId](const std::string &key, std::shared_ptr<Snapshot> snapshot) {
+            if (snapshot != nullptr) {
+                res = snapshot->OnDataChanged(dataAsset, deviceId); // needChange
+            }
+            return snapshot != nullptr;
+        });
+    if (exist) {
+        return res;
     }
 
     auto block = std::make_shared<BlockData<std::tuple<bool, bool>>>(WAIT_TIME, std::tuple{ true, true });
@@ -1088,17 +1247,17 @@ ObjectStoreManager::UriToSnapshot ObjectStoreManager::GetSnapShots(const std::st
         storeKey, [](const std::string& key) -> auto {
             return std::make_shared<std::map<std::string, std::shared_ptr<Snapshot>>>();
         });
-    return bindSnapshots_[storeKey];
+    return bindSnapshots_.Find(storeKey).second;
 }
 
 void ObjectStoreManager::DeleteSnapshot(const std::string& bundleName, const std::string& sessionId)
 {
     auto snapshotKey = bundleName + SEPERATOR + sessionId;
-    if (!snapshots_.Contains(snapshotKey)) {
+    auto snapshot = snapshots_.Find(snapshotKey).second;
+    if (snapshot == nullptr) {
         ZLOGD("Not find snapshot, don't need delete");
         return;
     }
-    auto snapshot = snapshots_[snapshotKey];
     bindSnapshots_.ForEach([snapshot](auto& key, auto& value) {
         for (auto pos = value->begin(); pos != value->end();) {
             if (pos->second == snapshot) {
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_manager.h b/datamgr_service/services/distributeddataservice/service/object/object_manager.h
index 8ff416a5761ab90a4c8ed53a70b26fe944ac2d2a..e927912387a4edeba01b472d4841207b5eae8455 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_manager.h
+++ b/datamgr_service/services/distributeddataservice/service/object/object_manager.h
@@ -28,6 +28,7 @@
 #include "object_data_listener.h"
 #include "object_snapshot.h"
 #include "object_types.h"
+#include "serializable/serializable.h"
 #include "types.h"
 #include "value_proxy.h"
 namespace OHOS {
@@ -67,6 +68,7 @@ public:
     enum RestoreStatus : int32_t {
         NONE = 0,
         DATA_READY,
+        DATA_NOTIFIED,
         ASSETS_READY,
         ALL_READY,
         STATUS_BUTT
@@ -95,7 +97,8 @@ public:
     void UnregisterRemoteCallback(const std::string &bundleName, pid_t pid, uint32_t tokenId,
                                   const std::string &sessionId = "");
     void NotifyChange(std::map<std::string, std::vector<uint8_t>> &changedData);
-    void NotifyAssetsReady(const std::string& objectKey, const std::string& srcNetworkId = "");
+    void NotifyAssetsReady(const std::string& objectKey, const std::string& bundleName,
+        const std::string& srcNetworkId = "");
     void NotifyAssetsStart(const std::string& objectKey, const std::string& srcNetworkId = "");
     void CloseAfterMinute();
     int32_t Open();
@@ -132,6 +135,19 @@ private:
             return false;
         }
     };
+    struct SaveInfo : DistributedData::Serializable {
+        std::string bundleName;
+        std::string sessionId;
+        std::string sourceDeviceId;
+        std::string targetDeviceId;
+        std::string timestamp;
+        SaveInfo() = default;
+        SaveInfo(const std::string &bundleName, const std::string &sessionId, const std::string &sourceDeviceId,
+            const std::string &targetDeviceId, const std::string &timestamp);
+        bool Marshal(json &node) const override;
+        bool Unmarshal(const json &node) override;
+        std::string ToPropertyPrefix();
+    };
     DistributedDB::KvStoreNbDelegate *OpenObjectKvStore();
     void FlushClosedStore();
     void Close();
@@ -144,7 +160,6 @@ private:
         const std::string &appId, const std::string &sessionId, std::map<std::string, std::vector<uint8_t>> &results);
     void SyncCompleted(const std::map<std::string, DistributedDB::DBStatus> &results, uint64_t sequenceId);
     std::vector<std::string> SplitEntryKey(const std::string &key);
-    std::string GetPropertyName(const std::string &key);
     void ProcessOldEntry(const std::string &appId);
     void ProcessSyncCallback(const std::map<std::string, int32_t> &results, const std::string &appId,
         const std::string &sessionId, const std::string &deviceId);
@@ -153,6 +168,7 @@ private:
     void DoNotify(uint32_t tokenId, const CallbackInfo& value,
         const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data, bool allReady);
     void DoNotifyAssetsReady(uint32_t tokenId, const CallbackInfo& value, const std::string& objectKey, bool allReady);
+    void DoNotifyWaitAssetTimeout(const std::string &objectKey);
     std::map<std::string, std::map<std::string, Assets>> GetAssetsFromStore(
         const std::map<std::string, std::vector<uint8_t>>& changedData);
     static bool IsAssetKey(const std::string& key);
@@ -160,10 +176,19 @@ private:
         const std::string& assetPrefix);
     Assets GetAssetsFromDBRecords(const std::map<std::string, std::vector<uint8_t>>& result);
     bool RegisterAssetsLister();
-    void NotifyDataChanged(std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data);
+    void ComputeStatus(const std::string& objectKey, const SaveInfo& saveInfo,
+        const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data);
+    void NotifyDataChanged(const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data,
+        const SaveInfo& saveInfo);
     int32_t PushAssets(int32_t userId, const std::string &appId, const std::string &sessionId,
         const std::map<std::string, std::vector<uint8_t>> &data, const std::string &deviceId);
-    int32_t WaitAssets(const std::string& objectKey);
+    int32_t WaitAssets(const std::string& objectKey, const SaveInfo& saveInfo,
+        const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data);
+    void PullAssets(const std::map<std::string, std::map<std::string, std::vector<uint8_t>>>& data,
+        const SaveInfo& saveInfo);
+    std::map<std::string, std::map<std::string, std::vector<uint8_t>>> GetObjectData(
+        const std::map<std::string, std::vector<uint8_t>>& changedData, SaveInfo& saveInfo, bool& hasAsset);
+
     inline std::string GetPropertyPrefix(const std::string &appId, const std::string &sessionId)
     {
         return appId + SEPERATOR + sessionId + SEPERATOR + DmAdaper::GetInstance().GetLocalDevice().udid + SEPERATOR;
diff --git a/datamgr_service/services/distributeddataservice/service/object/object_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/object/object_service_impl.cpp
index 4b225813216623c323c90a45f34493f878dc21fe..206dd1065d533e4a6f0dc5bc0373cc58b4fc34f6 100644
--- a/datamgr_service/services/distributeddataservice/service/object/object_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/object/object_service_impl.cpp
@@ -63,7 +63,8 @@ int32_t ObjectServiceImpl::ObjectStoreSave(const std::string &bundleName, const
     sptr<IRemoteObject> callback)
 {
     ZLOGI("begin.");
-    RADAR_REPORT(ObjectStore::SAVE, ObjectStore::SAVE_TO_STORE, ObjectStore::IDLE);
+    ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::SAVE,
+        ObjectStore::SAVE_TO_STORE, ObjectStore::IDLE);
     uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
     int32_t status = IsBundleNameEqualTokenId(bundleName, sessionId, tokenId);
     if (status != OBJECT_SUCCESS) {
@@ -73,8 +74,8 @@ int32_t ObjectServiceImpl::ObjectStoreSave(const std::string &bundleName, const
     if (status != OBJECT_SUCCESS) {
         ZLOGE("save fail %{public}d", status);
     }
-    RADAR_REPORT(ObjectStore::SAVE, ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_SUCCESS, ObjectStore::BIZ_STATE,
-        ObjectStore::FINISHED);
+    ObjectStore::RadarReporter::ReportStage(std::string(__FUNCTION__), ObjectStore::SAVE,
+        ObjectStore::SAVE_TO_STORE, ObjectStore::RADAR_SUCCESS);
     return status;
 }
 
@@ -196,8 +197,6 @@ int32_t ObjectServiceImpl::ObjectStoreRetrieve(
     status = ObjectStoreManager::GetInstance()->Retrieve(bundleName, sessionId, callback, tokenId);
     if (status != OBJECT_SUCCESS) {
         ZLOGE("retrieve fail %{public}d", status);
-        RADAR_REPORT(ObjectStore::CREATE, ObjectStore::RESTORE, ObjectStore::RADAR_FAILED,
-            ObjectStore::ERROR_CODE, status, ObjectStore::BIZ_STATE, ObjectStore::FINISHED);
         return status;
     }
     return OBJECT_SUCCESS;
@@ -251,8 +250,8 @@ int32_t ObjectServiceImpl::IsBundleNameEqualTokenId(
     storeInfo.storeId = sessionId;
     std::string appId = DistributedData::CheckerManager::GetInstance().GetAppId(storeInfo);
     if (appId.empty()) {
-        ZLOGE("object bundleName wrong, bundleName = %{public}s, uid = %{public}d, tokenId = 0x%{public}x",
-              bundleName.c_str(), storeInfo.uid, storeInfo.tokenId);
+        ZLOGE("object bundleName wrong, bundleName = %{public}s, uid = %{public}d, tokenId = %{public}s",
+              bundleName.c_str(), storeInfo.uid, Anonymous::Change(std::to_string(storeInfo.tokenId)).c_str());
         return OBJECT_PERMISSION_DENIED;
     }
     return OBJECT_SUCCESS;
@@ -308,6 +307,7 @@ int32_t ObjectServiceImpl::ResolveAutoLaunch(const std::string &identifier, Dist
                 continue;
             }
             DistributedObject::ObjectStoreManager::GetInstance()->CloseAfterMinute();
+            ZLOGI("Auto launch, close after a minute");
             return OBJECT_SUCCESS;
         }
     }
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.cpp
index 0dd0afdab46a921f1cd49e3894bce7e019b19a6e..096d3fc638ac2b81f9eadbdde288b26e16e9e1c0 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.cpp
@@ -42,6 +42,7 @@ DBStatus RdbCloud::BatchInsert(
     VBuckets temp = records;
     auto error = cloudDB_->BatchInsert(tableName, std::move(records), extends);
     PostEvent(temp, skipAssets, extends, DistributedData::AssetEvent::UPLOAD_FINISHED);
+    ConvertErrorField(extends);
     extend = ValueProxy::Convert(std::move(extends));
     return ConvertStatus(static_cast<GeneralError>(error));
 }
@@ -57,6 +58,7 @@ DBStatus RdbCloud::BatchUpdate(
     VBuckets temp = records;
     auto error = cloudDB_->BatchUpdate(tableName, std::move(records), extends);
     PostEvent(temp, skipAssets, extends, DistributedData::AssetEvent::UPLOAD_FINISHED);
+    ConvertErrorField(extends);
     extend = ValueProxy::Convert(std::move(extends));
     return ConvertStatus(static_cast<GeneralError>(error));
 }
@@ -65,6 +67,7 @@ DBStatus RdbCloud::BatchDelete(const std::string &tableName, std::vector<DBVBuck
 {
     VBuckets extends = ValueProxy::Convert(std::move(extend));
     auto error = cloudDB_->BatchDelete(tableName, extends);
+    ConvertErrorField(extends);
     extend = ValueProxy::Convert(std::move(extends));
     return ConvertStatus(static_cast<GeneralError>(error));
 }
@@ -115,15 +118,13 @@ DistributedData::GeneralError RdbCloud::PreSharing(const std::string& tableName,
 
 std::pair<DBStatus, uint32_t> RdbCloud::Lock()
 {
-    auto error = cloudDB_->Lock();
-    return std::make_pair(  // int64_t <-> uint32_t, s <-> ms
-        ConvertStatus(static_cast<GeneralError>(error)), cloudDB_->AliveTime() * TO_MS);
+    auto result = InnerLock(FLAG::SYSTEM_ABILITY);
+    return { ConvertStatus(result.first), result.second };
 }
 
 DBStatus RdbCloud::UnLock()
 {
-    auto error = cloudDB_->Unlock();
-    return ConvertStatus(static_cast<GeneralError>(error));
+    return ConvertStatus(InnerUnLock(FLAG::SYSTEM_ABILITY));
 }
 
 DBStatus RdbCloud::HeartBeat()
@@ -138,6 +139,34 @@ DBStatus RdbCloud::Close()
     return ConvertStatus(static_cast<GeneralError>(error));
 }
 
+std::pair<GeneralError, uint32_t> RdbCloud::InnerLock(FLAG flag)
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    flag_ |= flag;
+    // int64_t <-> uint32_t, s <-> ms
+    return std::make_pair(static_cast<GeneralError>(cloudDB_->Lock()), cloudDB_->AliveTime() * TO_MS);
+}
+
+GeneralError RdbCloud::InnerUnLock(FLAG flag)
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    flag_ &= ~flag;
+    if (flag_ == 0) {
+        return static_cast<GeneralError>(cloudDB_->Unlock());
+    }
+    return GeneralError::E_OK;
+}
+
+std::pair<GeneralError, uint32_t> RdbCloud::LockCloudDB(FLAG flag)
+{
+    return InnerLock(flag);
+}
+
+GeneralError RdbCloud::UnLockCloudDB(FLAG flag)
+{
+    return InnerUnLock(flag);
+}
+
 std::pair<DBStatus, std::string> RdbCloud::GetEmptyCursor(const std::string &tableName)
 {
     auto [error, cursor] = cloudDB_->GetEmptyCursor(tableName);
@@ -157,8 +186,18 @@ DBStatus RdbCloud::ConvertStatus(DistributedData::GeneralError error)
             return DBStatus::CLOUD_FULL_RECORDS;
         case GeneralError::E_NO_SPACE_FOR_ASSET:
             return DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT;
+        case GeneralError::E_VERSION_CONFLICT:
+            return DBStatus::CLOUD_VERSION_CONFLICT;
         case GeneralError::E_RECORD_EXIST_CONFLICT:
             return DBStatus::CLOUD_RECORD_EXIST_CONFLICT;
+        case GeneralError::E_RECORD_NOT_FOUND:
+            return DBStatus::CLOUD_RECORD_NOT_FOUND;
+        case GeneralError::E_RECORD_ALREADY_EXISTED:
+            return DBStatus::CLOUD_RECORD_ALREADY_EXISTED;
+        case GeneralError::E_FILE_NOT_EXIST:
+            return DBStatus::LOCAL_ASSET_NOT_FOUND;
+        case GeneralError::E_TIME_OUT:
+            return DBStatus::TIME_OUT;
         default:
             ZLOGI("error:0x%{public}x", error);
             break;
@@ -286,4 +325,24 @@ void RdbCloud::PostEventAsset(DistributedData::Asset& asset, DataBucket& extend,
         it->second->Uploaded(asset);
     }
 }
-} // namespace OHOS::DistributedRdb
+
+uint8_t RdbCloud::GetLockFlag() const
+{
+    return flag_;
+}
+
+void RdbCloud::ConvertErrorField(DistributedData::VBuckets& extends)
+{
+    for (auto& extend : extends) {
+        auto errorField = extend.find(SchemaMeta::ERROR_FIELD);
+        if (errorField == extend.end()) {
+            continue;
+        }
+        auto errCode = Traits::get_if<int64_t>(&(errorField->second));
+        if (errCode == nullptr) {
+            continue;
+        }
+        errorField->second = ConvertStatus(static_cast<GeneralError>(*errCode));
+    }
+}
+} // namespace OHOS::DistributedRdb
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.h b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.h
index be8b11793242e1aed296fb1ed4f900e2a1dbf008..0478110cb0a2cfacfe8d3cbf0b6c4bd291c45735 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.h
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud.h
@@ -15,6 +15,9 @@
 
 #ifndef OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_RDB_CLOUD_H
 #define OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_RDB_CLOUD_H
+
+#include <mutex>
+
 #include "cloud/cloud_db.h"
 #include "cloud/cloud_store_types.h"
 #include "cloud/icloud_db.h"
@@ -24,11 +27,16 @@
 namespace OHOS::DistributedRdb {
 class RdbCloud : public DistributedDB::ICloudDb {
 public:
+    enum FLAG : uint8_t {
+        SYSTEM_ABILITY = 1,
+        APPLICATION
+    };
     using DBStatus = DistributedDB::DBStatus;
     using DBVBucket = DistributedDB::VBucket;
     using DBQueryNodes = std::vector<DistributedDB::QueryNode>;
     using DataBucket = DistributedData::VBucket;
     using BindAssets = DistributedData::BindAssets;
+    using GeneralError = DistributedData::GeneralError;
 
     explicit RdbCloud(std::shared_ptr<DistributedData::CloudDB> cloudDB, BindAssets* bindAssets);
     virtual ~RdbCloud() = default;
@@ -45,6 +53,9 @@ public:
     DBStatus Close() override;
     std::pair<DBStatus, std::string> GetEmptyCursor(const std::string &tableName) override;
     static DBStatus ConvertStatus(DistributedData::GeneralError error);
+    uint8_t GetLockFlag() const;
+    std::pair<GeneralError, uint32_t> LockCloudDB(FLAG flag);
+    GeneralError UnLockCloudDB(FLAG flag);
 
 private:
     static constexpr const char *TYPE_FIELD = "#_type";
@@ -52,9 +63,12 @@ private:
     using QueryNodes = std::vector<DistributedData::QueryNode>;
     static std::pair<QueryNodes, DistributedData::GeneralError> ConvertQuery(DBVBucket& extend);
     static QueryNodes ConvertQuery(DBQueryNodes&& nodes);
+    static void ConvertErrorField(DistributedData::VBuckets& extends);
     static constexpr int32_t TO_MS = 1000; // s > ms
     std::shared_ptr<DistributedData::CloudDB> cloudDB_;
     BindAssets* snapshots_;
+    uint8_t flag_ = 0;
+    std::mutex mutex_;
 
     void PostEvent(DistributedData::VBuckets& records, std::set<std::string>& skipAssets,
         DistributedData::VBuckets& extend, DistributedData::AssetEvent eventId);
@@ -62,6 +76,8 @@ private:
         DistributedData::AssetEvent eventId);
     void PostEventAsset(DistributedData::Asset& asset, DataBucket& extend, std::set<std::string>& skipAssets,
         DistributedData::AssetEvent eventId);
+    std::pair<GeneralError, uint32_t> InnerLock(FLAG flag);
+    GeneralError InnerUnLock(FLAG flag);
 };
 } // namespace OHOS::DistributedRdb
 #endif // OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_RDB_CLOUD_H
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud_data_translate.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud_data_translate.cpp
index 05d7d580f12c5d4e2e6c4c581a3d3670746b110c..833474bd410f5f8f0d8cb55bf1e5b33447f22b8e 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud_data_translate.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_cloud_data_translate.cpp
@@ -138,7 +138,7 @@ size_t RdbCloudDataTranslate::ParserRawData(const uint8_t *data, size_t length,
             break;
         }
         used += dataLen;
-        assets.push_back(ValueProxy::Convert(asset));
+        assets.push_back(std::move(asset));
         count++;
     }
     return used;
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.cpp
index cc1bfb6ea814a88c70e65be14ea078a6c8fa8be5..b5be9c581efb4be38ac9c5ef0a9ef9c6081f7ed2 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.cpp
@@ -20,6 +20,7 @@
 #include <cinttypes>
 
 #include "cache_cursor.h"
+#include "changeevent/remote_change_event.h"
 #include "cloud/asset_loader.h"
 #include "cloud/cloud_db.h"
 #include "cloud/cloud_store_types.h"
@@ -57,11 +58,13 @@ using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 constexpr const char *INSERT = "INSERT INTO ";
 constexpr const char *REPLACE = "REPLACE INTO ";
 constexpr const char *VALUES = " VALUES ";
+constexpr const char *LOGOUT_DELETE_FLAG = "DELETE#ALL_CLOUDDATA";
 constexpr const LockAction LOCK_ACTION = static_cast<LockAction>(static_cast<uint32_t>(LockAction::INSERT) |
     static_cast<uint32_t>(LockAction::UPDATE) | static_cast<uint32_t>(LockAction::DELETE) |
     static_cast<uint32_t>(LockAction::DOWNLOAD));
 constexpr uint32_t CLOUD_SYNC_FLAG = 1;
 constexpr uint32_t SEARCHABLE_FLAG = 2;
+constexpr uint32_t LOCK_TIMEOUT = 3600; // second
 
 static DBSchema GetDBSchema(const Database &database)
 {
@@ -84,9 +87,11 @@ static DBSchema GetDBSchema(const Database &database)
     return schema;
 }
 
-RdbGeneralStore::RdbGeneralStore(const StoreMetaData &meta) : manager_(meta.appId, meta.user, meta.instanceId)
+RdbGeneralStore::RdbGeneralStore(const StoreMetaData &meta)
+    : manager_(meta.appId, meta.user, meta.instanceId), tasks_(std::make_shared<ConcurrentMap<SyncId, FinishTask>>())
 {
     observer_.storeId_ = meta.storeId;
+    observer_.meta_ = meta;
     RelationalStoreDelegate::Option option;
     option.observer = &observer_;
     if (meta.isEncrypt) {
@@ -106,11 +111,13 @@ RdbGeneralStore::RdbGeneralStore(const StoreMetaData &meta) : manager_(meta.appI
                 break;
             }
             manager_.CloseStore(delegate_);
+            delegate_ = nullptr;
         }
     } else {
         auto ret = manager_.OpenStore(meta.dataDir, meta.storeId, option, delegate_);
         if (ret != DBStatus::OK || delegate_ == nullptr) {
             manager_.CloseStore(delegate_);
+            delegate_ = nullptr;
         }
     }
 
@@ -142,6 +149,9 @@ RdbGeneralStore::~RdbGeneralStore()
     bindInfo_.db_ = nullptr;
     rdbCloud_ = nullptr;
     rdbLoader_ = nullptr;
+    RemoveTasks();
+    tasks_ = nullptr;
+    executor_ = nullptr;
 }
 
 int32_t RdbGeneralStore::BindSnapshots(std::shared_ptr<std::map<std::string, std::shared_ptr<Snapshot>>> bindAssets)
@@ -177,8 +187,11 @@ int32_t RdbGeneralStore::Bind(Database &database, const std::map<uint32_t, BindI
     auto evt = std::make_unique<BindEvent>(BindEvent::BIND_SNAPSHOT, std::move(eventInfo));
     EventCenter::GetInstance().PostEvent(std::move(evt));
     bindInfo_ = std::move(bindInfo);
-    rdbCloud_ = std::make_shared<RdbCloud>(bindInfo_.db_, &snapshots_);
-    rdbLoader_ = std::make_shared<RdbAssetLoader>(bindInfo_.loader_, &snapshots_);
+    {
+        std::unique_lock<decltype(rdbCloudMutex_)> lock(rdbCloudMutex_);
+        rdbCloud_ = std::make_shared<RdbCloud>(bindInfo_.db_, &snapshots_);
+        rdbLoader_ = std::make_shared<RdbAssetLoader>(bindInfo_.loader_, &snapshots_);
+    }
 
     DistributedDB::CloudSyncConfig dbConfig;
     dbConfig.maxUploadCount = config.maxNumber;
@@ -204,28 +217,37 @@ bool RdbGeneralStore::IsBound()
     return isBound_;
 }
 
-int32_t RdbGeneralStore::Close()
+int32_t RdbGeneralStore::Close(bool isForce)
 {
-    std::unique_lock<decltype(rwMutex_)> lock(rwMutex_);
-    if (delegate_ == nullptr) {
-        return 0;
-    }
-    int32_t count = delegate_->GetCloudSyncTaskCount();
-    if (count > 0) {
-        return GeneralError::E_BUSY;
-    }
-    auto status = manager_.CloseStore(delegate_);
-    if (status != DBStatus::OK) {
-        return status;
+    {
+        std::unique_lock<decltype(rwMutex_)> lock(rwMutex_, std::chrono::seconds(isForce ? LOCK_TIMEOUT : 0));
+        if (!lock) {
+            return GeneralError::E_BUSY;
+        }
+
+        if (delegate_ == nullptr) {
+            return GeneralError::E_OK;
+        }
+        if (!isForce && delegate_->GetCloudSyncTaskCount() > 0) {
+            return GeneralError::E_BUSY;
+        }
+        auto status = manager_.CloseStore(delegate_);
+        if (status != DBStatus::OK) {
+            return status;
+        }
+        delegate_ = nullptr;
     }
-    delegate_ = nullptr;
+    RemoveTasks();
     bindInfo_.loader_ = nullptr;
     if (bindInfo_.db_ != nullptr) {
         bindInfo_.db_->Close();
     }
     bindInfo_.db_ = nullptr;
-    rdbCloud_ = nullptr;
-    rdbLoader_ = nullptr;
+    {
+        std::unique_lock<decltype(rdbCloudMutex_)> lock(rdbCloudMutex_);
+        rdbCloud_ = nullptr;
+        rdbLoader_ = nullptr;
+    }
     return GeneralError::E_OK;
 }
 
@@ -414,40 +436,40 @@ int32_t RdbGeneralStore::Delete(const std::string &table, const std::string &sql
     return 0;
 }
 
-std::shared_ptr<Cursor> RdbGeneralStore::Query(__attribute__((unused))const std::string &table,
+std::pair<int32_t, std::shared_ptr<Cursor>> RdbGeneralStore::Query(__attribute__((unused))const std::string &table,
     const std::string &sql, Values &&args)
 {
     std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
     if (delegate_ == nullptr) {
         ZLOGE("Database already closed! database:%{public}s", Anonymous::Change(storeInfo_.storeName).c_str());
-        return nullptr;
+        return { GeneralError::E_ALREADY_CLOSED, nullptr };
     }
-    std::vector<VBucket> records = QuerySql(sql, std::move(args));
-    return std::make_shared<CacheCursor>(std::move(records));
+    auto [errCode, records] = QuerySql(sql, std::move(args));
+    return { errCode, std::make_shared<CacheCursor>(std::move(records)) };
 }
 
-std::shared_ptr<Cursor> RdbGeneralStore::Query(const std::string &table, GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> RdbGeneralStore::Query(const std::string &table, GenQuery &query)
 {
     RdbQuery *rdbQuery = nullptr;
     auto ret = query.QueryInterface(rdbQuery);
     if (ret != GeneralError::E_OK || rdbQuery == nullptr) {
         ZLOGE("not RdbQuery!");
-        return nullptr;
+        return { GeneralError::E_INVALID_ARGS, nullptr };
     }
     std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
     if (delegate_ == nullptr) {
         ZLOGE("Database already closed! database:%{public}s, table:%{public}s",
             Anonymous::Change(storeInfo_.storeName).c_str(), Anonymous::Change(table).c_str());
-        return nullptr;
+        return { GeneralError::E_ALREADY_CLOSED, nullptr };
     }
     if (rdbQuery->IsRemoteQuery()) {
         if (rdbQuery->GetDevices().size() != 1) {
             ZLOGE("RemoteQuery: devices size error! size:%{public}zu", rdbQuery->GetDevices().size());
-            return nullptr;
+            return { GeneralError::E_ERROR, nullptr };
         }
-        return RemoteQuery(*rdbQuery->GetDevices().begin(), rdbQuery->GetRemoteCondition());
+        return { GeneralError::E_OK, RemoteQuery(*rdbQuery->GetDevices().begin(), rdbQuery->GetRemoteCondition()) };
     }
-    return nullptr;
+    return { GeneralError::E_ERROR, nullptr };
 }
 
 int32_t RdbGeneralStore::MergeMigratedData(const std::string &tableName, VBuckets &&values)
@@ -470,7 +492,7 @@ int32_t RdbGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAsy
     bool isPriority = false;
     auto ret = query.QueryInterface(rdbQuery);
     if (ret != GeneralError::E_OK || rdbQuery == nullptr) {
-        dbQuery.FromTable(query.GetTables());
+        dbQuery.FromTable(GetIntersection(query.GetTables(), GetTables()));
     } else {
         dbQuery = rdbQuery->GetQuery();
         isPriority = rdbQuery->IsPriority();
@@ -485,30 +507,47 @@ int32_t RdbGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAsy
         return GeneralError::E_ALREADY_CLOSED;
     }
     auto highMode = GetHighMode(static_cast<uint32_t>(syncParam.mode));
-    auto status = (syncMode < NEARBY_END)
-        ? delegate_->Sync(devices, dbMode, dbQuery, GetDBBriefCB(std::move(async), syncMode), syncParam.wait != 0)
-        : (syncMode > NEARBY_END && syncMode < CLOUD_END)
-        ? delegate_->Sync({ devices, dbMode, dbQuery, syncParam.wait, (isPriority || highMode == MANUAL_SYNC_MODE),
-            syncParam.isCompensation, {}, highMode == AUTO_SYNC_MODE, LOCK_ACTION },
-            GetDBProcessCB(std::move(async), syncMode, highMode))
-        : DistributedDB::INVALID_ARGS;
-    OnSyncStart(storeInfo_, syncNotifyFlag_, syncMode, status);
-    return status;
+    SyncId syncId = ++syncTaskId_;
+    auto dbStatus = DistributedDB::INVALID_ARGS;
+    if (syncMode < NEARBY_END) {
+        dbStatus = delegate_->Sync(devices, dbMode, dbQuery, GetDBBriefCB(std::move(async)), syncParam.wait != 0);
+    } else if (syncMode > NEARBY_END && syncMode < CLOUD_END) {
+        auto callback = GetDBProcessCB(std::move(async), syncMode, syncId, highMode);
+        if (executor_ != nullptr && tasks_ != nullptr) {
+            auto id = executor_->Schedule(GetFinishTask(syncId), std::chrono::minutes(INTERVAL),
+                std::chrono::minutes(INTERVAL));
+            tasks_->Insert(syncId, { id, callback });
+        }
+        dbStatus =
+            delegate_->Sync({ devices, dbMode, dbQuery, syncParam.wait, (isPriority || highMode == MANUAL_SYNC_MODE),
+                                syncParam.isCompensation, {}, highMode == AUTO_SYNC_MODE, LOCK_ACTION },
+                tasks_ != nullptr ? GetCB(syncId) : callback, syncId);
+        if (dbStatus == DBStatus::OK || tasks_ == nullptr) {
+            return ConvertStatus(dbStatus);
+        }
+        tasks_->ComputeIfPresent(syncId, [executor = executor_](SyncId syncId, const FinishTask &task) {
+            if (executor != nullptr) {
+                executor->Remove(task.taskId);
+            }
+            return false;
+        });
+    }
+    return ConvertStatus(dbStatus);
 }
 
-std::shared_ptr<Cursor> RdbGeneralStore::PreSharing(GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> RdbGeneralStore::PreSharing(GenQuery &query)
 {
     RdbQuery *rdbQuery = nullptr;
     auto ret = query.QueryInterface(rdbQuery);
     if (ret != GeneralError::E_OK || rdbQuery == nullptr) {
         ZLOGE("not RdbQuery!");
-        return nullptr;
+        return { GeneralError::E_INVALID_ARGS, nullptr };
     }
     auto tables = rdbQuery->GetTables();
     auto statement = rdbQuery->GetStatement();
     if (statement.empty() || tables.empty()) {
         ZLOGE("statement size:%{public}zu, tables size:%{public}zu", statement.size(), tables.size());
-        return nullptr;
+        return { GeneralError::E_INVALID_ARGS, nullptr };
     }
     std::string sql = BuildSql(*tables.begin(), statement, rdbQuery->GetColumns());
     VBuckets values;
@@ -516,23 +555,25 @@ std::shared_ptr<Cursor> RdbGeneralStore::PreSharing(GenQuery &query)
         std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
         if (delegate_ == nullptr) {
             ZLOGE("Database already closed! database:%{public}s", Anonymous::Change(storeInfo_.storeName).c_str());
-            return nullptr;
+            return { GeneralError::E_ALREADY_CLOSED, nullptr };
         }
-        values = QuerySql(sql, rdbQuery->GetBindArgs());
+        auto [errCode, ret] = QuerySql(sql, rdbQuery->GetBindArgs());
+        values = std::move(ret);
     }
-    if (rdbCloud_ == nullptr || values.empty()) {
-        ZLOGW("rdbCloud is %{public}s, values size:%{public}zu", rdbCloud_ == nullptr ? "nullptr" : "not nullptr",
+    auto rdbCloud = GetRdbCloud();
+    if (rdbCloud == nullptr || values.empty()) {
+        ZLOGW("rdbCloud is %{public}s, values size:%{public}zu", rdbCloud == nullptr ? "nullptr" : "not nullptr",
             values.size());
-        return nullptr;
+        return { GeneralError::E_CLOUD_DISABLED, nullptr };
     }
     VBuckets extends = ExtractExtend(values);
-    rdbCloud_->PreSharing(*tables.begin(), extends);
+    rdbCloud->PreSharing(*tables.begin(), extends);
     for (auto value = values.begin(), extend = extends.begin(); value != values.end() && extend != extends.end();
          ++value, ++extend) {
         value->insert_or_assign(DistributedRdb::Field::SHARING_RESOURCE_FIELD, (*extend)[SchemaMeta::SHARING_RESOURCE]);
         value->erase(CLOUD_GID);
     }
-    return std::make_shared<CacheCursor>(std::move(values));
+    return { GeneralError::E_OK, std::make_shared<CacheCursor>(std::move(values)) };
 }
 
 VBuckets RdbGeneralStore::ExtractExtend(VBuckets &values) const
@@ -636,21 +677,18 @@ int32_t RdbGeneralStore::Unwatch(int32_t origin, Watcher &watcher)
     return GeneralError::E_OK;
 }
 
-RdbGeneralStore::DBBriefCB RdbGeneralStore::GetDBBriefCB(DetailAsync async, uint32_t syncMode)
+RdbGeneralStore::DBBriefCB RdbGeneralStore::GetDBBriefCB(DetailAsync async)
 {
     if (!async) {
-        return [storeInfo = storeInfo_, flag = syncNotifyFlag_, syncMode](auto &) {
-            RdbGeneralStore::OnSyncFinish(storeInfo, flag, syncMode);
-        };
+        return [](auto &) {};
     }
-    return [async = std::move(async), storeInfo = storeInfo_, flag = syncNotifyFlag_, syncMode](
+    return [async = std::move(async)](
         const std::map<std::string, std::vector<TableStatus>> &result) {
         DistributedData::GenDetails details;
         for (auto &[key, tables] : result) {
             auto &value = details[key];
             value.progress = FINISHED;
             value.code = GeneralError::E_OK;
-            RdbGeneralStore::OnSyncFinish(storeInfo, flag, syncMode);
             for (auto &table : tables) {
                 if (table.status != DBStatus::OK) {
                     value.code = GeneralError::E_ERROR;
@@ -661,35 +699,47 @@ RdbGeneralStore::DBBriefCB RdbGeneralStore::GetDBBriefCB(DetailAsync async, uint
     };
 }
 
-RdbGeneralStore::DBProcessCB RdbGeneralStore::GetDBProcessCB(DetailAsync async, uint32_t syncMode, uint32_t highMode)
+RdbGeneralStore::DBProcessCB RdbGeneralStore::GetDBProcessCB(DetailAsync async, uint32_t syncMode, SyncId syncId,
+    uint32_t highMode)
 {
-    if (!async && (highMode == MANUAL_SYNC_MODE || !async_)) {
-        return [storeInfo = storeInfo_, flag = syncNotifyFlag_, syncMode](auto &) {
-            RdbGeneralStore::OnSyncFinish(storeInfo, flag, syncMode);
-        };
-    }
-
-    return [async, autoAsync = async_, highMode, storeInfo = storeInfo_, flag = syncNotifyFlag_, syncMode](
-        const std::map<std::string, SyncProcess> &processes) {
+    std::shared_lock<std::shared_mutex> lock(asyncMutex_);
+    return [async, autoAsync = async_, highMode, storeInfo = storeInfo_, flag = syncNotifyFlag_, syncMode, syncId,
+        rdbCloud = GetRdbCloud()](const std::map<std::string, SyncProcess> &processes) {
         DistributedData::GenDetails details;
         for (auto &[id, process] : processes) {
+            bool isDownload = false;
             auto &detail = details[id];
             detail.progress = process.process;
             detail.code = ConvertStatus(process.errCode);
             detail.dbCode = DB_ERR_OFFSET + process.errCode;
-            if (process.process == FINISHED) {
-                RdbGeneralStore::OnSyncFinish(storeInfo, flag, syncMode);
-            }
+            uint32_t totalCount = 0;
             for (auto [key, value] : process.tableProcess) {
                 auto &table = detail.details[key];
                 table.upload.total = value.upLoadInfo.total;
                 table.upload.success = value.upLoadInfo.successCount;
                 table.upload.failed = value.upLoadInfo.failCount;
                 table.upload.untreated = table.upload.total - table.upload.success - table.upload.failed;
+                totalCount += table.upload.total;
+                isDownload = table.download.total > 0;
                 table.download.total = value.downLoadInfo.total;
                 table.download.success = value.downLoadInfo.successCount;
                 table.download.failed = value.downLoadInfo.failCount;
                 table.download.untreated = table.download.total - table.download.success - table.download.failed;
+                detail.changeCount = (process.process == FINISHED)
+                                        ? value.downLoadInfo.insertCount + value.downLoadInfo.updateCount +
+                                              value.downLoadInfo.deleteCount
+                                        : 0;
+                totalCount += table.download.total;
+            }
+            if (process.process == FINISHED) {
+                RdbGeneralStore::OnSyncFinish(storeInfo, flag, syncMode, syncId);
+            } else {
+                RdbGeneralStore::OnSyncStart(storeInfo, flag, syncMode, syncId, totalCount);
+            }
+
+            if (isDownload && (process.process == FINISHED || process.process == PROCESSING) && rdbCloud != nullptr &&
+                (rdbCloud->GetLockFlag() & RdbCloud::FLAG::APPLICATION)) {
+                rdbCloud->LockCloudDB(RdbCloud::FLAG::APPLICATION);
             }
         }
         if (async) {
@@ -827,17 +877,19 @@ bool RdbGeneralStore::IsValid()
 
 int32_t RdbGeneralStore::RegisterDetailProgressObserver(GeneralStore::DetailAsync async)
 {
+    std::unique_lock<std::shared_mutex> lock(asyncMutex_);
     async_ = std::move(async);
     return GenErr::E_OK;
 }
 
 int32_t RdbGeneralStore::UnregisterDetailProgressObserver()
 {
+    std::unique_lock<std::shared_mutex> lock(asyncMutex_);
     async_ = nullptr;
     return GenErr::E_OK;
 }
 
-VBuckets RdbGeneralStore::QuerySql(const std::string &sql, Values &&args)
+std::pair<int32_t, VBuckets> RdbGeneralStore::QuerySql(const std::string &sql, Values &&args)
 {
     std::vector<DistributedDB::VBucket> changedData;
     std::vector<DistributedDB::Type> bindArgs = ValueProxy::Convert(std::move(args));
@@ -845,9 +897,9 @@ VBuckets RdbGeneralStore::QuerySql(const std::string &sql, Values &&args)
     if (status != DBStatus::OK) {
         ZLOGE("Failed! ret:%{public}d, sql:%{public}s, data size:%{public}zu", status, Anonymous::Change(sql).c_str(),
             changedData.size());
-        return {};
+        return { GenErr::E_ERROR, {} };
     }
-    return ValueProxy::Convert(std::move(changedData));
+    return { GenErr::E_OK, ValueProxy::Convert(std::move(changedData)) };
 }
 
 std::vector<std::string> RdbGeneralStore::GetWaterVersion(const std::string &deviceId)
@@ -855,28 +907,77 @@ std::vector<std::string> RdbGeneralStore::GetWaterVersion(const std::string &dev
     return {};
 }
 
-void RdbGeneralStore::OnSyncStart(const StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode, int status)
+void RdbGeneralStore::OnSyncStart(const StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode, uint32_t traceId,
+    uint32_t syncCount)
 {
     uint32_t requiredFlag = (CLOUD_SYNC_FLAG | SEARCHABLE_FLAG);
     if (requiredFlag != (requiredFlag & flag)) {
         return;
     }
-    if (status != GeneralError::E_OK) {
-        return;
-    }
     StoreInfo info = storeInfo;
-    auto evt = std::make_unique<DataSyncEvent>(std::move(info), syncMode, DataSyncEvent::DataSyncStatus::START);
+    auto evt = std::make_unique<DataSyncEvent>(std::move(info), syncMode, DataSyncEvent::DataSyncStatus::START,
+        traceId, syncCount);
     EventCenter::GetInstance().PostEvent(std::move(evt));
 }
 
-void RdbGeneralStore::OnSyncFinish(const StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode)
+void RdbGeneralStore::OnSyncFinish(const StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode, uint32_t traceId)
 {
     uint32_t requiredFlag = (CLOUD_SYNC_FLAG | SEARCHABLE_FLAG);
     if (requiredFlag != (requiredFlag & flag)) {
         return;
     }
     StoreInfo info = storeInfo;
-    auto evt = std::make_unique<DataSyncEvent>(std::move(info), syncMode, DataSyncEvent::DataSyncStatus::FINISH);
+    auto evt = std::make_unique<DataSyncEvent>(std::move(info), syncMode, DataSyncEvent::DataSyncStatus::FINISH,
+        traceId);
+    EventCenter::GetInstance().PostEvent(std::move(evt));
+}
+
+std::set<std::string> RdbGeneralStore::GetTables()
+{
+    std::set<std::string> tables;
+    std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
+    if (delegate_ == nullptr) {
+        ZLOGE("Database already closed! database:%{public}s", Anonymous::Change(storeInfo_.storeName).c_str());
+        return tables;
+    }
+    auto [errCode, res] = QuerySql(QUERY_TABLES_SQL, {});
+    if (errCode != GenErr::E_OK) {
+        return tables;
+    }
+    for (auto &table : res) {
+        auto it = table.find("name");
+        if (it == table.end() || TYPE_INDEX<std::string> != it->second.index()) {
+            ZLOGW("error res! database:%{public}s", Anonymous::Change(storeInfo_.storeName).c_str());
+            continue;
+        }
+        tables.emplace(std::move(*std::get_if<std::string>(&(it->second))));
+    }
+    return tables;
+}
+
+std::vector<std::string> RdbGeneralStore::GetIntersection(std::vector<std::string> &&syncTables,
+    const std::set<std::string> &localTables)
+{
+    std::vector<std::string> res;
+    for (auto &it : syncTables) {
+        if (localTables.count(it)) {
+            res.push_back(std::move(it));
+        }
+    }
+    return res;
+}
+
+void RdbGeneralStore::ObserverProxy::PostDataChange(const StoreMetaData &meta,
+    const std::vector<std::string> &tables, ChangeType type)
+{
+    RemoteChangeEvent::DataInfo info;
+    info.userId = meta.user;
+    info.storeId = meta.storeId;
+    info.deviceId = meta.deviceId;
+    info.bundleName = meta.bundleName;
+    info.tables = tables;
+    info.changeType = type;
+    auto evt = std::make_unique<RemoteChangeEvent>(RemoteChangeEvent::DATA_CHANGE, std::move(info));
     EventCenter::GetInstance().PostEvent(std::move(evt));
 }
 
@@ -917,17 +1018,143 @@ void RdbGeneralStore::ObserverProxy::OnChange(DBOrigin origin, const std::string
     genOrigin.store = storeId_;
     Watcher::PRIFields fields;
     Watcher::ChangeInfo changeInfo;
+    bool notifyFlag = false;
     for (uint32_t i = 0; i < DistributedDB::OP_BUTT; ++i) {
         auto &info = changeInfo[data.tableName][i];
         for (auto &priData : data.primaryData[i]) {
             Watcher::PRIValue value;
             Convert(std::move(*(priData.begin())), value);
+            if (notifyFlag || origin != DBOrigin::ORIGIN_CLOUD || i != DistributedDB::OP_DELETE) {
+                info.push_back(std::move(value));
+                continue;
+            }
+            auto deleteKey = std::get_if<std::string>(&value);
+            if (deleteKey != nullptr && (*deleteKey == LOGOUT_DELETE_FLAG)) {
+                // notify to start app
+                notifyFlag = true;
+            }
             info.push_back(std::move(value));
         }
     }
+    if (notifyFlag) {
+        ZLOGI("post data change for cleaning cloud data");
+        PostDataChange(meta_, {}, CLOUD_DATA_CLEAN);
+    }
     if (!data.field.empty()) {
         fields[std::move(data.tableName)] = std::move(*(data.field.begin()));
     }
     watcher_->OnChange(genOrigin, fields, std::move(changeInfo));
 }
+
+std::pair<int32_t, uint32_t> RdbGeneralStore::LockCloudDB()
+{
+    auto rdbCloud = GetRdbCloud();
+    if (rdbCloud == nullptr) {
+        return { GeneralError::E_ERROR, 0 };
+    }
+    return rdbCloud->LockCloudDB(RdbCloud::FLAG::APPLICATION);
+}
+
+int32_t RdbGeneralStore::UnLockCloudDB()
+{
+    auto rdbCloud = GetRdbCloud();
+    if (rdbCloud == nullptr) {
+        return GeneralError::E_ERROR;
+    }
+    return rdbCloud->UnLockCloudDB(RdbCloud::FLAG::APPLICATION);
+}
+
+std::shared_ptr<RdbCloud> RdbGeneralStore::GetRdbCloud() const
+{
+    std::shared_lock<decltype(rdbCloudMutex_)> lock(rdbCloudMutex_);
+    return rdbCloud_;
+}
+
+bool RdbGeneralStore::IsFinished(SyncId syncId) const
+{
+    std::shared_lock<decltype(rwMutex_)> lock(rwMutex_);
+    if (delegate_ == nullptr) {
+        ZLOGE("database already closed! database:%{public}s", Anonymous::Change(storeInfo_.storeName).c_str());
+        return true;
+    }
+    return delegate_->GetCloudTaskStatus(syncId).process == DistributedDB::FINISHED;
+}
+
+Executor::Task RdbGeneralStore::GetFinishTask(SyncId syncId)
+{
+    return [this, syncId]() {
+        if (!IsFinished(syncId)) {
+            return;
+        }
+        DBProcessCB cb;
+        ZLOGW("database:%{public}s syncId:%{public}" PRIu64 " miss finished. ",
+            Anonymous::Change(storeInfo_.storeName).c_str(), syncId);
+        tasks_->ComputeIfPresent(syncId, [&cb, executor = executor_](SyncId syncId, const FinishTask &task) {
+            cb = task.cb;
+            if (executor != nullptr) {
+                executor->Remove(task.taskId);
+            }
+            return false;
+        });
+        if (cb != nullptr) {
+            std::map<std::string, SyncProcess> result;
+            result.insert({ "", { DistributedDB::FINISHED, DBStatus::DB_ERROR } });
+            cb(result);
+        }
+    };
+}
+
+void RdbGeneralStore::SetExecutor(std::shared_ptr<Executor> executor)
+{
+    if (executor_ == nullptr) {
+        executor_ = executor;
+    }
+}
+
+void RdbGeneralStore::RemoveTasks()
+{
+    if (tasks_ == nullptr) {
+        return;
+    }
+    std::list<DBProcessCB> cbs;
+    tasks_->ForEach([&cbs, executor = executor_, store = storeInfo_.storeName](SyncId syncId, const FinishTask &task) {
+        cbs.push_back(std::move(task.cb));
+        ZLOGW("database:%{public}s syncId:%{public}" PRIu64 " miss finished. ",
+            Anonymous::Change(store).c_str(), syncId);
+        if (executor != nullptr) {
+            executor->Remove(task.taskId);
+        }
+        return false;
+    });
+    tasks_->Clear();
+    std::map<std::string, SyncProcess> result;
+    result.insert({ "", { DistributedDB::FINISHED, DBStatus::DB_ERROR } });
+    for (auto &cb : cbs) {
+        if (cb != nullptr) {
+            cb(result);
+        }
+    }
+}
+
+RdbGeneralStore::DBProcessCB RdbGeneralStore::GetCB(SyncId syncId)
+{
+    return [task = tasks_, executor = executor_, syncId](const std::map<std::string, SyncProcess> &progress) {
+        if (task == nullptr) {
+            return;
+        }
+        DBProcessCB cb;
+        task->ComputeIfPresent(syncId, [&cb, &progress, executor](SyncId syncId, const FinishTask &finishTask) {
+            cb = finishTask.cb;
+            bool isFinished = !progress.empty() && progress.begin()->second.process == DistributedDB::FINISHED;
+            if (isFinished && executor != nullptr) {
+                executor->Remove(finishTask.taskId);
+            }
+            return !isFinished;
+        });
+        if (cb != nullptr) {
+            cb(progress);
+        }
+        return;
+    };
+}
 } // namespace OHOS::DistributedRdb
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.h b/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.h
index 567177c0c78f5776e9b56f61b7eaf2ecb5fee1f5..f096b6c31f111f87865242a6aef944a101c3d102 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.h
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_general_store.h
@@ -19,6 +19,7 @@
 #include <functional>
 #include <shared_mutex>
 
+#include "concurrent_map.h"
 #include "metadata/store_meta_data.h"
 #include "rdb_asset_loader.h"
 #include "rdb_cloud.h"
@@ -48,8 +49,11 @@ public:
     explicit RdbGeneralStore(const StoreMetaData &meta);
     ~RdbGeneralStore();
 
-    static void OnSyncStart(const DistributedData::StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode, int status);
-    static void OnSyncFinish(const DistributedData::StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode);
+    static void OnSyncStart(const DistributedData::StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode,
+        uint32_t traceId, uint32_t syncCount);
+    static void OnSyncFinish(const DistributedData::StoreInfo &storeInfo, uint32_t flag, uint32_t syncMode,
+        uint32_t traceId);
+    void SetExecutor(std::shared_ptr<Executor> executor) override;
     int32_t Bind(Database &database, const std::map<uint32_t, BindInfo> &bindInfos,
         const CloudConfig &config) override;
     bool IsBound() override;
@@ -64,22 +68,25 @@ public:
         Values &&conditions) override;
     int32_t Replace(const std::string &table, VBucket &&value) override;
     int32_t Delete(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, const std::string &sql,
+        Values &&args) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, GenQuery &query) override;
     int32_t Sync(
         const Devices &devices, GenQuery &query, DetailAsync async, DistributedData::SyncParam &syncParam) override;
-    std::shared_ptr<Cursor> PreSharing(GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> PreSharing(GenQuery &query) override;
     int32_t Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName) override;
     int32_t Watch(int32_t origin, Watcher &watcher) override;
     int32_t Unwatch(int32_t origin, Watcher &watcher) override;
     int32_t RegisterDetailProgressObserver(DetailAsync async) override;
     int32_t UnregisterDetailProgressObserver() override;
-    int32_t Close() override;
+    int32_t Close(bool isForce = false) override;
     int32_t AddRef() override;
     int32_t Release() override;
     int32_t BindSnapshots(std::shared_ptr<std::map<std::string, std::shared_ptr<Snapshot>>> bindAssets) override;
     int32_t MergeMigratedData(const std::string &tableName, VBuckets&& values) override;
     std::vector<std::string> GetWaterVersion(const std::string &deviceId) override;
+    std::pair<int32_t, uint32_t> LockCloudDB() override;
+    int32_t UnLockCloudDB() override;
 
 private:
     RdbGeneralStore(const RdbGeneralStore& rdbGeneralStore);
@@ -89,10 +96,18 @@ private:
     using SyncProcess = DistributedDB::SyncProcess;
     using DBBriefCB = DistributedDB::SyncStatusCallback;
     using DBProcessCB = std::function<void(const std::map<std::string, SyncProcess> &processes)>;
+    using TaskId = ExecutorPool::TaskId;
+    using Time = std::chrono::steady_clock::time_point;
+    using SyncId = uint64_t;
     static GenErr ConvertStatus(DistributedDB::DBStatus status);
+    // GetIntersection and return results in the order of collecter1
+    static std::vector<std::string> GetIntersection(std::vector<std::string> &&syncTables,
+        const std::set<std::string> &localTables);
     static constexpr inline uint64_t REMOTE_QUERY_TIME_OUT = 30 * 1000;
+    static constexpr int64_t INTERVAL = 1;
     static constexpr const char* CLOUD_GID = "cloud_gid";
     static constexpr const char* DATE_KEY = "data_key";
+    static constexpr const char* QUERY_TABLES_SQL = "select name from sqlite_master where type = 'table';";
     static constexpr uint32_t ITER_V0 = 10000;
     static constexpr uint32_t ITER_V1 = 5000;
     static constexpr uint32_t ITERS[] = {ITER_V0, ITER_V1};
@@ -110,20 +125,33 @@ private:
             return watcher_ != nullptr;
         }
     private:
+        enum ChangeType {
+            CLOUD_DATA_CHANGE = 0,
+            CLOUD_DATA_CLEAN
+        };
+        void PostDataChange(const StoreMetaData &meta, const std::vector<std::string> &tables, ChangeType type);
         friend RdbGeneralStore;
         Watcher *watcher_ = nullptr;
         std::string storeId_;
+        StoreMetaData meta_;
     };
-    DBBriefCB GetDBBriefCB(DetailAsync async, uint32_t syncMode);
-    DBProcessCB GetDBProcessCB(DetailAsync async, uint32_t syncMode, uint32_t highMode = AUTO_SYNC_MODE);
+    DBBriefCB GetDBBriefCB(DetailAsync async);
+    DBProcessCB GetCB(SyncId syncId);
+    DBProcessCB GetDBProcessCB(DetailAsync async, uint32_t syncMode, SyncId syncId,
+        uint32_t highMode = AUTO_SYNC_MODE);
+    Executor::Task GetFinishTask(SyncId syncId);
     std::shared_ptr<Cursor> RemoteQuery(const std::string &device,
         const DistributedDB::RemoteCondition &remoteCondition);
     std::string BuildSql(const std::string& table, const std::string& statement,
         const std::vector<std::string>& columns) const;
-    VBuckets QuerySql(const std::string& sql, Values &&args);
+    std::pair<int32_t, VBuckets> QuerySql(const std::string& sql, Values &&args);
+    std::set<std::string> GetTables();
     VBuckets ExtractExtend(VBuckets& values) const;
     size_t SqlConcatenate(VBucket &value, std::string &strColumnSql, std::string &strRowValueSql);
     bool IsPrintLog(DistributedDB::DBStatus status);
+    std::shared_ptr<RdbCloud> GetRdbCloud() const;
+    bool IsFinished(uint64_t syncId) const;
+    void RemoveTasks();
     
     ObserverProxy observer_;
     RdbManager manager_;
@@ -135,7 +163,7 @@ private:
     std::atomic<bool> isBound_ = false;
     std::mutex mutex_;
     int32_t ref_ = 1;
-    mutable std::shared_mutex rwMutex_;
+    mutable std::shared_timed_mutex rwMutex_;
 
     BindAssets snapshots_;
     DistributedData::StoreInfo storeInfo_;
@@ -144,6 +172,15 @@ private:
     static constexpr uint32_t PRINT_ERROR_CNT = 150;
     uint32_t lastErrCnt_ = 0;
     uint32_t syncNotifyFlag_ = 0;
+    std::atomic<SyncId> syncTaskId_ = 0;
+    std::shared_mutex asyncMutex_ {};
+    mutable std::shared_mutex rdbCloudMutex_;
+    struct FinishTask {
+        TaskId taskId = Executor::INVALID_TASK_ID;
+        DBProcessCB cb = nullptr;
+    };
+    std::shared_ptr<Executor> executor_ = nullptr;
+    std::shared_ptr<ConcurrentMap<SyncId, FinishTask>> tasks_;
 };
 } // namespace OHOS::DistributedRdb
 #endif // OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_RDB_GENERAL_STORE_H
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_notifier_proxy.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_notifier_proxy.cpp
index eba9b47b84d8d8836bb16aa067564b7b8a4d046a..ceb200a3777656b880950fe6c4925d6974b44caa 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_notifier_proxy.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_notifier_proxy.cpp
@@ -62,7 +62,7 @@ int32_t RdbNotifierProxy::OnChange(const Origin &origin, const PrimaryFields &pr
     }
 
     MessageParcel reply;
-    MessageOption option;
+    MessageOption option(MessageOption::TF_ASYNC);
     if (Remote()->SendRequest(
         static_cast<uint32_t>(NotifierIFCode::RDB_NOTIFIER_CMD_DATA_CHANGE), data, reply, option) != 0) {
         ZLOGE("storeName:%{public}s, send request failed", DistributedData::Anonymous::Change(origin.store).c_str());
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
index 4b3a16c70a430ba4c938b149561820e968f6904e..e8730147ea1214b4311e540e26223afe30bfd779 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
@@ -21,8 +21,10 @@
 #include "changeevent/remote_change_event.h"
 #include "cloud/change_event.h"
 #include "cloud/cloud_share_event.h"
+#include "cloud/cloud_lock_event.h"
 #include "cloud/make_query_event.h"
 #include "commonevent/data_change_event.h"
+#include "commonevent/set_searchable_event.h"
 #include "communicator/device_manager_adapter.h"
 #include "crypto_manager.h"
 #include "directory/directory_manager.h"
@@ -47,6 +49,8 @@
 #include "rdb_general_store.h"
 #include "rdb_result_set_impl.h"
 #include "xcollie.h"
+#include "device_matrix.h"
+#include "metadata/capability_meta_data.h"
 using OHOS::DistributedKv::AccountDelegate;
 using OHOS::DistributedData::CheckerManager;
 using OHOS::DistributedData::MetaDataManager;
@@ -116,6 +120,7 @@ RdbServiceImpl::RdbServiceImpl()
         store->RegisterDetailProgressObserver(GetCallbacks(meta.tokenId, storeInfo.storeName));
     };
     EventCenter::GetInstance().Subscribe(CloudEvent::CLOUD_SYNC, process);
+    EventCenter::GetInstance().Subscribe(CloudEvent::CLEAN_DATA, process);
 
     EventCenter::GetInstance().Subscribe(CloudEvent::MAKE_QUERY, [](const Event& event) {
         auto& evt = static_cast<const MakeQueryEvent&>(event);
@@ -170,7 +175,7 @@ int32_t RdbServiceImpl::ResolveAutoLaunch(const std::string &identifier, Distrib
         if (entry.isEncrypt) {
             param.option.iterateTimes = ITERATE_TIMES;
             param.option.cipher = DistributedDB::CipherType::AES_256_GCM;
-            GetPassword(entry, param.option.passwd);
+            GetDBPassword(entry, param.option.passwd);
         }
         AutoCache::GetInstance().GetStore(entry, GetWatchers(entry.tokenId, entry.storeId));
         return true;
@@ -182,22 +187,28 @@ int32_t RdbServiceImpl::ResolveAutoLaunch(const std::string &identifier, Distrib
 int32_t RdbServiceImpl::OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &bundleName)
 {
     ZLOGI("client dead, tokenId:%{public}d, pid:%{public}d ", tokenId, pid);
-    syncAgents_.EraseIf([pid](auto& key, SyncAgent& agent) {
-        if (agent.pid_ != pid) {
-            return false;
+    bool destroyed = false;
+    syncAgents_.ComputeIfPresent(tokenId, [pid, &destroyed](auto &key, SyncAgents &agents) {
+        auto it = agents.find(pid);
+        if (it != agents.end()) {
+            it->second.SetNotifier(nullptr);
+            agents.erase(it);
         }
-        if (agent.watcher_ != nullptr) {
-            agent.watcher_->SetNotifier(nullptr);
+        if (!agents.empty()) {
+            return true;
         }
-        auto stores = AutoCache::GetInstance().GetStoresIfPresent(key);
+        destroyed = true;
+        return false;
+    });
+    if (destroyed) {
+        auto stores = AutoCache::GetInstance().GetStoresIfPresent(tokenId);
         for (auto store : stores) {
             if (store != nullptr) {
                 store->UnregisterDetailProgressObserver();
             }
         }
-        return true;
-    });
-    AutoCache::GetInstance().Enable(tokenId);
+        AutoCache::GetInstance().Enable(tokenId);
+    }
     return E_OK;
 }
 
@@ -241,15 +252,15 @@ int32_t RdbServiceImpl::InitNotifier(const RdbSyncerParam &param, const sptr<IRe
     auto notifierProxy = iface_cast<RdbNotifierProxy>(notifier);
     pid_t pid = IPCSkeleton::GetCallingPid();
     uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
-    syncAgents_.Compute(tokenId, [&param, notifierProxy, pid](auto, SyncAgent &agent) {
-        if (pid != agent.pid_) {
-            agent.ReInit(pid, param.bundleName_);
+    syncAgents_.Compute(tokenId, [bundleName = param.bundleName_, notifierProxy, pid](auto, SyncAgents &agents) {
+        auto [it, success] = agents.try_emplace(pid, SyncAgent(bundleName));
+        if (it == agents.end()) {
+            return true;
         }
-        agent.SetNotifier(notifierProxy);
+        it->second.SetNotifier(notifierProxy);
         return true;
     });
     ZLOGI("success tokenId:%{public}x, pid=%{public}d", tokenId, pid);
-
     return RDB_OK;
 }
 
@@ -307,12 +318,19 @@ int32_t RdbServiceImpl::SetDistributedTables(const RdbSyncerParam &param, const
     return store->SetDistributedTables(tables, type, relationships);
 }
 
-void RdbServiceImpl::OnAsyncComplete(uint32_t tokenId, uint32_t seqNum, Details &&result)
+void RdbServiceImpl::OnAsyncComplete(uint32_t tokenId, pid_t pid, uint32_t seqNum, Details &&result)
 {
-    ZLOGI("tokenId=%{public}x seqnum=%{public}u", tokenId, seqNum);
-    auto [success, agent] = syncAgents_.Find(tokenId);
-    if (success && agent.notifier_ != nullptr) {
-        agent.notifier_->OnComplete(seqNum, std::move(result));
+    ZLOGI("tokenId=%{public}x, pid=%{public}d, seqnum=%{public}u", tokenId, pid, seqNum);
+    sptr<RdbNotifierProxy> notifier = nullptr;
+    syncAgents_.ComputeIfPresent(tokenId, [&notifier, pid](auto, SyncAgents &syncAgents) {
+        auto it = syncAgents.find(pid);
+        if (it != syncAgents.end()) {
+            notifier = it->second.notifier_;
+        }
+        return true;
+    });
+    if (notifier != nullptr) {
+        notifier->OnComplete(seqNum, std::move(result));
     }
 }
 
@@ -333,28 +351,37 @@ std::string RdbServiceImpl::TransferStringToHex(const std::string &origStr)
 
 AutoCache::Watchers RdbServiceImpl::GetWatchers(uint32_t tokenId, const std::string &storeName)
 {
-    auto [success, agent] = syncAgents_.Find(tokenId);
-    if (agent.watcher_ == nullptr) {
-        return {};
-    }
-    return { agent.watcher_ };
+    AutoCache::Watchers watchers;
+    syncAgents_.ComputeIfPresent(tokenId, [&watchers](auto, SyncAgents &syncAgents) {
+        std::for_each(syncAgents.begin(), syncAgents.end(), [&watchers](const auto &item) {
+            if (item.second.watcher_ != nullptr) {
+                watchers.insert(item.second.watcher_);
+            }
+        });
+        return true;
+    });
+    return watchers;
 }
 
-RdbServiceImpl::DetailAsync RdbServiceImpl::GetCallbacks(uint32_t tokenId, const std::string& storeName)
+RdbServiceImpl::DetailAsync RdbServiceImpl::GetCallbacks(uint32_t tokenId, const std::string &storeName)
 {
-    sptr<RdbNotifierProxy> notifier = nullptr;
-    syncAgents_.ComputeIfPresent(tokenId, [&storeName, &notifier](auto, SyncAgent& syncAgent) {
-        if (syncAgent.callBackStores_.count(storeName) != 0) {
-            notifier = syncAgent.notifier_;
-        }
+    std::list<sptr<RdbNotifierProxy>> notifiers;
+    syncAgents_.ComputeIfPresent(tokenId, [&storeName, &notifiers](auto, SyncAgents &syncAgents) {
+        std::for_each(syncAgents.begin(), syncAgents.end(), [&storeName, &notifiers](const auto &item) {
+            if (item.second.callBackStores_.count(storeName) != 0) {
+                notifiers.push_back(item.second.notifier_);
+            }
+        });
         return true;
     });
-    if (notifier == nullptr) {
+    if (notifiers.empty()) {
         return nullptr;
     }
-    return [notifier, storeName](const GenDetails& details) {
-        if (notifier != nullptr) {
-            notifier->OnComplete(storeName, HandleGenDetails(details));
+    return [notifiers, storeName](const GenDetails &details) {
+        for (const auto &notifier : notifiers) {
+            if (notifier != nullptr) {
+                notifier->OnComplete(storeName, HandleGenDetails(details));
+            }
         }
     };
 }
@@ -374,7 +401,10 @@ std::pair<int32_t, std::shared_ptr<RdbServiceImpl::ResultSet>> RdbServiceImpl::R
     }
     RdbQuery rdbQuery;
     rdbQuery.MakeRemoteQuery(DmAdapter::GetInstance().ToUUID(device), sql, ValueProxy::Convert(selectionArgs));
-    auto cursor = store->Query("", rdbQuery);
+    auto [errCode, cursor] = store->Query("", rdbQuery);
+    if (errCode != GeneralError::E_OK) {
+        return { RDB_ERROR, nullptr };
+    }
     return { RDB_OK, std::make_shared<RdbResultSetImpl>(cursor) };
 }
 
@@ -405,33 +435,71 @@ int RdbServiceImpl::DoSync(const RdbSyncerParam &param, const RdbService::Option
     rdbQuery.MakeQuery(predicates);
     auto devices = rdbQuery.GetDevices().empty() ? DmAdapter::ToUUID(DmAdapter::GetInstance().GetRemoteDevices())
                                                  : DmAdapter::ToUUID(rdbQuery.GetDevices());
-    if (!option.isAsync) {
-        SyncParam syncParam = { option.mode, 1, option.isCompensation };
-        Details details = {};
-        auto status = store->Sync(
-            devices, rdbQuery,
-            [&details, &param](const GenDetails &result) mutable {
-                ZLOGD("Sync complete, bundleName:%{public}s, storeName:%{public}s", param.bundleName_.c_str(),
-                    Anonymous::Change(param.storeName_).c_str());
-                details = HandleGenDetails(result);
+    auto pid = IPCSkeleton::GetCallingPid();
+    SyncParam syncParam = { option.mode, 0, option.isCompensation };
+    StoreMetaData meta = GetStoreMetaData(param);
+    auto tokenId = IPCSkeleton::GetCallingTokenID();
+    ZLOGD("seqNum=%{public}u", option.seqNum);
+    auto complete = [this, rdbQuery, store, pid, syncParam, tokenId, async, seq = option.seqNum](
+                        const auto &results) mutable {
+        auto ret = ProcessResult(results);
+        store->Sync(
+            ret.first, rdbQuery,
+            [this, tokenId, seq, pid](const GenDetails &result) mutable {
+                OnAsyncComplete(tokenId, pid, seq, HandleGenDetails(result));
             },
             syncParam);
-        if (async != nullptr) {
-            async(std::move(details));
-        }
-        return status;
+    };
+    if (IsNeedMetaSync(meta, devices)) {
+        auto result = MetaDataManager::GetInstance().Sync(devices, complete);
+        return result ? GeneralError::E_OK : GeneralError::E_ERROR;
     }
-    ZLOGD("seqNum=%{public}u", option.seqNum);
-    auto tokenId = IPCSkeleton::GetCallingTokenID();
-    SyncParam syncParam = { option.mode, 0, option.isCompensation };
     return store->Sync(
         devices, rdbQuery,
-        [this, tokenId, seqNum = option.seqNum](const GenDetails &result) mutable {
-            OnAsyncComplete(tokenId, seqNum, HandleGenDetails(result));
+        [this, tokenId, pid, seqNum = option.seqNum](const GenDetails &result) mutable {
+            OnAsyncComplete(tokenId, pid, seqNum, HandleGenDetails(result));
         },
         syncParam);
 }
 
+bool RdbServiceImpl::IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids)
+{
+    bool isAfterMeta = false;
+    for (const auto &uuid : uuids) {
+        auto metaData = meta;
+        metaData.deviceId = uuid;
+        CapMetaData capMeta;
+        auto capKey = CapMetaRow::GetKeyFor(uuid);
+        if (!MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMeta) ||
+            !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
+            isAfterMeta = true;
+            break;
+        }
+        auto [exist, mask] = DeviceMatrix::GetInstance().GetRemoteMask(uuid);
+        if ((mask & DeviceMatrix::META_STORE_MASK) == DeviceMatrix::META_STORE_MASK) {
+            isAfterMeta = true;
+            break;
+        }
+    }
+    return isAfterMeta;
+}
+
+RdbServiceImpl::SyncResult RdbServiceImpl::ProcessResult(const std::map<std::string, int32_t> &results)
+{
+    std::map<std::string, DBStatus> dbResults;
+    std::vector<std::string> devices;
+    for (const auto &[uuid, status] : results) {
+        dbResults.insert_or_assign(uuid, static_cast<DBStatus>(status));
+        if (static_cast<DBStatus>(status) != DBStatus::OK) {
+            continue;
+        }
+        DeviceMatrix::GetInstance().OnExchanged(uuid, DeviceMatrix::META_STORE_MASK);
+        devices.emplace_back(uuid);
+    }
+    ZLOGD("meta sync finish, total size:%{public}zu, success size:%{public}zu", dbResults.size(), devices.size());
+    return { devices, dbResults };
+}
+
 void RdbServiceImpl::DoCompensateSync(const BindEvent& event)
 {
     auto bindInfo = event.GetBindInfo();
@@ -471,9 +539,10 @@ void RdbServiceImpl::DoCloudSync(const RdbSyncerParam &param, const RdbService::
         query = std::make_shared<RdbQuery>();
         query->MakeCloudQuery(predicates);
     }
-    GenAsync asyncCallback = [this, tokenId = storeInfo.tokenId, seqNum = option.seqNum](
+    auto pid = IPCSkeleton::GetCallingPid();
+    GenAsync asyncCallback = [this, tokenId = storeInfo.tokenId, seqNum = option.seqNum, pid](
                                  const GenDetails &result) mutable {
-        OnAsyncComplete(tokenId, seqNum, HandleGenDetails(result));
+        OnAsyncComplete(tokenId, pid, seqNum, HandleGenDetails(result));
     };
     GenAsync syncCallback = [async, &param](const GenDetails &details) {
         ZLOGD("Cloud Sync complete, bundleName:%{public}s, storeName:%{public}s", param.bundleName_.c_str(),
@@ -484,7 +553,7 @@ void RdbServiceImpl::DoCloudSync(const RdbSyncerParam &param, const RdbService::
     };
     auto mixMode = static_cast<int32_t>(GeneralStore::MixMode(option.mode,
         option.isAutoSync ? GeneralStore::AUTO_SYNC_MODE : GeneralStore::MANUAL_SYNC_MODE));
-    SyncParam syncParam = { mixMode, (option.isAsync ? 0 : static_cast<int32_t>(WAIT_TIME)), option.isCompensation };
+    SyncParam syncParam = { mixMode, (option.isAsync ? 0 : WAIT_TIME), option.isCompensation };
     auto info = ChangeEvent::EventInfo(syncParam, option.isAutoSync, query,
         option.isAutoSync ? nullptr
         : option.isAsync  ? asyncCallback
@@ -503,15 +572,16 @@ int32_t RdbServiceImpl::Subscribe(const RdbSyncerParam &param, const SubscribeOp
     pid_t pid = IPCSkeleton::GetCallingPid();
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     bool isCreate = false;
-    syncAgents_.Compute(tokenId, [pid, &param, &isCreate](auto &key, SyncAgent &agent) {
-        if (pid != agent.pid_) {
-            agent.ReInit(pid, param.bundleName_);
+    syncAgents_.Compute(tokenId, [pid, &param, &isCreate](auto &key, SyncAgents &agents) {
+        auto [it, _] = agents.try_emplace(pid, param.bundleName_);
+        if (it == agents.end()) {
+            return !agents.empty();
         }
-        if (agent.watcher_ == nullptr) {
+        if (it->second.watcher_ == nullptr) {
             isCreate = true;
-            agent.SetWatcher(std::make_shared<RdbWatcher>());
+            it->second.SetWatcher(std::make_shared<RdbWatcher>());
         }
-        agent.count_++;
+        it->second.count_++;
         return true;
     });
     if (isCreate) {
@@ -530,13 +600,16 @@ int32_t RdbServiceImpl::UnSubscribe(const RdbSyncerParam &param, const Subscribe
     }
     bool destroyed = false;
     auto tokenId = IPCSkeleton::GetCallingTokenID();
-    syncAgents_.ComputeIfPresent(tokenId, [&destroyed](auto &key, SyncAgent &agent) {
-        if (agent.count_ > 0) {
-            agent.count_--;
+    auto pid = IPCSkeleton::GetCallingPid();
+    syncAgents_.ComputeIfPresent(tokenId, [pid, &destroyed](auto, SyncAgents &agents) {
+        auto it = agents.find(pid);
+        if (it == agents.end()) {
+            return !agents.empty();
         }
-        if (agent.count_ == 0) {
+        it->second.count_--;
+        if (it->second.count_ <= 0) {
             destroyed = true;
-            agent.SetWatcher(nullptr);
+            it->second.SetWatcher(nullptr);
         }
         return true;
     });
@@ -553,25 +626,17 @@ int32_t RdbServiceImpl::RegisterAutoSyncCallback(const RdbSyncerParam& param,
     pid_t pid = IPCSkeleton::GetCallingPid();
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto storeName = RemoveSuffix(param.storeName_);
-    bool isCreate = false;
-    syncAgents_.Compute(tokenId, [pid, &param, &storeName, &isCreate](auto, SyncAgent& agent) {
-        if (pid != agent.pid_) {
-            agent.ReInit(pid, param.bundleName_);
+    syncAgents_.Compute(tokenId, [pid, &param, &storeName](auto, SyncAgents &agents) {
+        auto [it, success] = agents.try_emplace(pid, param.bundleName_);
+        if (it == agents.end()) {
+            return !agents.empty();
         }
-        auto it = agent.callBackStores_.find(storeName);
-        if (it == agent.callBackStores_.end()) {
-            agent.callBackStores_.insert(std::make_pair(storeName, 0));
-            isCreate = true;
+        if (success) {
+            it->second.callBackStores_.insert(std::make_pair(storeName, 0));
         }
-        agent.callBackStores_[storeName]++;
+        it->second.callBackStores_[storeName]++;
         return true;
     });
-    if (isCreate) {
-        auto stores = AutoCache::GetInstance().GetStoresIfPresent(tokenId, storeName);
-        if (!stores.empty() && *stores.begin() != nullptr) {
-            (*stores.begin())->RegisterDetailProgressObserver(GetCallbacks(tokenId, storeName));
-        }
-    }
     return RDB_OK;
 }
 
@@ -579,26 +644,23 @@ int32_t RdbServiceImpl::UnregisterAutoSyncCallback(const RdbSyncerParam& param,
     std::shared_ptr<DetailProgressObserver> observer)
 {
     auto tokenId = IPCSkeleton::GetCallingTokenID();
+    auto pid = IPCSkeleton::GetCallingPid();
     auto storeName = RemoveSuffix(param.storeName_);
-    bool destroyed = false;
-    syncAgents_.ComputeIfPresent(tokenId, [&storeName, &destroyed](auto, SyncAgent& agent) {
-        auto it = agent.callBackStores_.find(storeName);
-        if (it == agent.callBackStores_.end()) {
-            return true;
+    syncAgents_.ComputeIfPresent(tokenId, [pid, &storeName](auto, SyncAgents &agents) {
+        auto agent = agents.find(pid);
+        if (agent == agents.end()) {
+            return !agents.empty();
+        }
+        auto it = agent->second.callBackStores_.find(storeName);
+        if (it == agent->second.callBackStores_.end()) {
+            return !agents.empty();
         }
         it->second--;
         if (it->second <= 0) {
-            agent.callBackStores_.erase(it);
-            destroyed = true;
+            agent->second.callBackStores_.erase(it);
         }
-        return true;
+        return !agents.empty();
     });
-    if (destroyed) {
-        auto stores = AutoCache::GetInstance().GetStoresIfPresent(tokenId, storeName);
-        if (!stores.empty() && *stores.begin() != nullptr) {
-            (*stores.begin())->UnregisterDetailProgressObserver();
-        }
-    }
     return RDB_OK;
 }
 
@@ -688,6 +750,7 @@ void RdbServiceImpl::SetReturnParam(StoreMetaData &metadata, RdbSyncerParam &par
     param.isEncrypt_ = metadata.isEncrypt;
     param.isAutoClean_ = !metadata.isManualClean;
     param.isSearchable_ = metadata.isSearchable;
+    param.haMode_ = metadata.haMode;
 }
 
 int32_t RdbServiceImpl::AfterOpen(const RdbSyncerParam &param)
@@ -782,6 +845,7 @@ StoreMetaData RdbServiceImpl::GetStoreMetaData(const RdbSyncerParam &param)
     metaData.isEncrypt = param.isEncrypt_;
     metaData.isManualClean = !param.isAutoClean_;
     metaData.isSearchable = param.isSearchable_;
+    metaData.haMode = param.haMode_;
     return metaData;
 }
 
@@ -828,7 +892,7 @@ Details RdbServiceImpl::HandleGenDetails(const GenDetails &details)
     return dbDetails;
 }
 
-bool RdbServiceImpl::GetPassword(const StoreMetaData &metaData, DistributedDB::CipherPassword &password)
+bool RdbServiceImpl::GetDBPassword(const StoreMetaData &metaData, DistributedDB::CipherPassword &password)
 {
     if (!metaData.isEncrypt) {
         return true;
@@ -881,18 +945,6 @@ int32_t RdbServiceImpl::OnBind(const BindInfo &bindInfo)
     return 0;
 }
 
-void RdbServiceImpl::SyncAgent::ReInit(pid_t pid, const std::string &bundleName)
-{
-    pid_ = pid;
-    count_ = 0;
-    callBackStores_.clear();
-    bundleName_ = bundleName;
-    notifier_ = nullptr;
-    if (watcher_ != nullptr) {
-        watcher_->SetNotifier(nullptr);
-    }
-}
-
 void RdbServiceImpl::SyncAgent::SetNotifier(sptr<RdbNotifierProxy> notifier)
 {
     notifier_ = notifier;
@@ -911,6 +963,14 @@ void RdbServiceImpl::SyncAgent::SetWatcher(std::shared_ptr<RdbWatcher> watcher)
     }
 }
 
+RdbServiceImpl::SyncAgent::SyncAgent(const std::string &bundleName) : bundleName_(bundleName)
+{
+    notifier_ = nullptr;
+    watcher_ = nullptr;
+    count_ = 0;
+    callBackStores_.clear();
+}
+
 int32_t RdbServiceImpl::RdbStatic::CloseStore(const std::string &bundleName, int32_t user, int32_t index,
     int32_t tokenId) const
 {
@@ -990,7 +1050,8 @@ RdbServiceImpl::~RdbServiceImpl()
     DumpManager::GetInstance().RemoveHandler("FEATURE_INFO", uintptr_t(this));
 }
 
-int32_t RdbServiceImpl::NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData)
+int32_t RdbServiceImpl::NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData,
+    const RdbNotifyConfig &rdbNotifyConfig)
 {
     XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
     if (!CheckAccess(param.bundleName_, param.storeName_)) {
@@ -1008,13 +1069,67 @@ int32_t RdbServiceImpl::NotifyDataChange(const RdbSyncerParam &param, const RdbC
     storeInfo.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
 
     DataChangeEvent::EventInfo eventInfo;
+    eventInfo.isFull = rdbNotifyConfig.isFull_;
     for (const auto& [key, value] : rdbChangedData.tableData) {
         DataChangeEvent::TableChangeProperties tableChangeProperties = {value.isTrackedDataChange};
         eventInfo.tableProperties.insert_or_assign(key, std::move(tableChangeProperties));
     }
 
-    auto evt = std::make_unique<DataChangeEvent>(std::move(storeInfo), std::move(eventInfo));
+    bool postImmediately = false;
+    heartbeatTaskIds_.Compute(param.storeName_, [this, &postImmediately, &rdbNotifyConfig, &storeInfo, &eventInfo]
+        (const std::string &key, ExecutorPool::TaskId &value) {
+        if (rdbNotifyConfig.delay_ == 0) {
+            if (value != ExecutorPool::INVALID_TASK_ID && executors_ != nullptr) {
+                executors_->Remove(value);
+            }
+            postImmediately = true;
+            return false;
+        }
+
+        if (executors_ != nullptr) {
+            auto task = [storeInfoInner = storeInfo, eventInfoInner = eventInfo]() {
+                auto evt = std::make_unique<DataChangeEvent>(std::move(storeInfoInner), std::move(eventInfoInner));
+                EventCenter::GetInstance().PostEvent(std::move(evt));
+            };
+            if (value == ExecutorPool::INVALID_TASK_ID) {
+                value = executors_->Schedule(std::chrono::milliseconds(rdbNotifyConfig.delay_), task);
+            } else {
+                value = executors_->Reset(value, std::chrono::milliseconds(rdbNotifyConfig.delay_));
+            }
+        }
+        return true;
+    });
+
+    if (postImmediately) {
+        auto evt = std::make_unique<DataChangeEvent>(std::move(storeInfo), std::move(eventInfo));
+        EventCenter::GetInstance().PostEvent(std::move(evt));
+    }
+
+    return RDB_OK;
+}
+
+int32_t RdbServiceImpl::SetSearchable(const RdbSyncerParam& param, bool isSearchable)
+{
+    XCollie xcollie(__FUNCTION__, HiviewDFX::XCOLLIE_FLAG_LOG | HiviewDFX::XCOLLIE_FLAG_RECOVERY);
+    if (!CheckAccess(param.bundleName_, param.storeName_)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. Permission error", param.bundleName_.c_str(),
+            Anonymous::Change(param.storeName_).c_str());
+        return RDB_ERROR;
+    }
+    StoreInfo storeInfo;
+    storeInfo.tokenId = IPCSkeleton::GetCallingTokenID();
+    storeInfo.bundleName = param.bundleName_;
+    storeInfo.storeName = RemoveSuffix(param.storeName_);
+    auto [instanceId,  user]= GetInstIndexAndUser(storeInfo.tokenId, param.bundleName_);
+    storeInfo.instanceId = instanceId;
+    storeInfo.user = user;
+    storeInfo.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+
+    SetSearchableEvent::EventInfo eventInfo;
+    eventInfo.isSearchable = isSearchable;
+    auto evt = std::make_unique<SetSearchableEvent>(std::move(storeInfo), std::move(eventInfo));
     EventCenter::GetInstance().PostEvent(std::move(evt));
+
     return RDB_OK;
 }
 
@@ -1023,13 +1138,91 @@ int32_t RdbServiceImpl::Disable(const RdbSyncerParam& param)
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto storeId = RemoveSuffix(param.storeName_);
     AutoCache::GetInstance().Disable(tokenId, storeId);
-    return E_OK;
+    return RDB_OK;
 }
+
 int32_t RdbServiceImpl::Enable(const RdbSyncerParam& param)
 {
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto storeId = RemoveSuffix(param.storeName_);
     AutoCache::GetInstance().Enable(tokenId, storeId);
-    return E_OK;
+    return RDB_OK;
+}
+
+int32_t RdbServiceImpl::GetPassword(const RdbSyncerParam &param, std::vector<uint8_t> &password)
+{
+    if (!CheckAccess(param.bundleName_, param.storeName_)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. Permission error", param.bundleName_.c_str(),
+            Anonymous::Change(param.storeName_).c_str());
+        return RDB_ERROR;
+    }
+    auto meta = GetStoreMetaData(param);
+    SecretKeyMetaData secretKey;
+    if (!MetaDataManager::GetInstance().LoadMeta(meta.GetSecretKey(), secretKey, true)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. no meta", param.bundleName_.c_str(),
+            Anonymous::Change(param.storeName_).c_str());
+        return RDB_NO_META;
+    }
+
+    if (!CryptoManager::GetInstance().Decrypt(secretKey.sKey, password)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. decrypt err", param.bundleName_.c_str(),
+            Anonymous::Change(param.storeName_).c_str());
+        return RDB_ERROR;
+    }
+    return RDB_OK;
+}
+
+StoreInfo RdbServiceImpl::GetStoreInfo(const RdbSyncerParam &param)
+{
+    StoreInfo storeInfo;
+    storeInfo.bundleName = param.bundleName_;
+    storeInfo.tokenId = IPCSkeleton::GetCallingTokenID();
+    storeInfo.user = AccountDelegate::GetInstance()->GetUserByToken(storeInfo.tokenId);
+    storeInfo.storeName = RemoveSuffix(param.storeName_);
+    return storeInfo;
+}
+
+std::pair<int32_t, uint32_t> RdbServiceImpl::LockCloudContainer(const RdbSyncerParam &param)
+{
+    std::pair<int32_t, uint32_t> result { RDB_ERROR, 0 };
+    if (!CheckAccess(param.bundleName_, param.storeName_)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. Permission error", param.bundleName_.c_str(),
+              Anonymous::Change(param.storeName_).c_str());
+        return result;
+    }
+    ZLOGI("start to lock cloud db: bundleName:%{public}s, storeName:%{public}s", param.bundleName_.c_str(),
+        Anonymous::Change(param.storeName_).c_str());
+
+    auto storeInfo = GetStoreInfo(param);
+
+    CloudLockEvent::Callback callback = [&result](int32_t status, uint32_t expiredTime) {
+        result.first = status;
+        result.second = expiredTime;
+    };
+    auto evt = std::make_unique<CloudLockEvent>(CloudEvent::LOCK_CLOUD_CONTAINER, std::move(storeInfo), callback);
+    EventCenter::GetInstance().PostEvent(std::move(evt));
+    return result;
+}
+
+int32_t RdbServiceImpl::UnlockCloudContainer(const RdbSyncerParam &param)
+{
+    int32_t result = RDB_ERROR;
+    if (!CheckAccess(param.bundleName_, param.storeName_)) {
+        ZLOGE("bundleName:%{public}s, storeName:%{public}s. Permission error", param.bundleName_.c_str(),
+              Anonymous::Change(param.storeName_).c_str());
+        return result;
+    }
+    ZLOGI("start to unlock cloud db: bundleName:%{public}s, storeName:%{public}s", param.bundleName_.c_str(),
+        Anonymous::Change(param.storeName_).c_str());
+
+    auto storeInfo = GetStoreInfo(param);
+
+    CloudLockEvent::Callback callback = [&result](int32_t status, uint32_t expiredTime) {
+        (void)expiredTime;
+        result = status;
+    };
+    auto evt = std::make_unique<CloudLockEvent>(CloudEvent::UNLOCK_CLOUD_CONTAINER, std::move(storeInfo), callback);
+    EventCenter::GetInstance().PostEvent(std::move(evt));
+    return result;
 }
 } // namespace OHOS::DistributedRdb
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.h b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.h
index 344bf3bf4a0efcc9936abcfea90ea981586b1b3b..c110a4d779dfc6a1061f03d63b7cf980f7bbc58c 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.h
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_impl.h
@@ -85,7 +85,9 @@ public:
 
     int32_t OnInitialize() override;
 
-    int32_t NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData) override;
+    int32_t NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData,
+        const RdbNotifyConfig &rdbNotifyConfig) override;
+    int32_t SetSearchable(const RdbSyncerParam& param, bool isSearchable) override;
     int32_t Disable(const RdbSyncerParam& param) override;
     int32_t Enable(const RdbSyncerParam& param) override;
 
@@ -93,20 +95,29 @@ public:
 
     int32_t AfterOpen(const RdbSyncerParam &param) override;
 
+    int32_t GetPassword(const RdbSyncerParam &param, std::vector<uint8_t> &password) override;
+
+    std::pair<int32_t, uint32_t> LockCloudContainer(const RdbSyncerParam &param) override;
+
+    int32_t UnlockCloudContainer(const RdbSyncerParam &param) override;
+
 private:
     using Watchers = DistributedData::AutoCache::Watchers;
     using StaticActs = DistributedData::StaticActs;
+    using DBStatus = DistributedDB::DBStatus;
+    using SyncResult = std::pair<std::vector<std::string>, std::map<std::string, DBStatus>>;
     struct SyncAgent {
-        pid_t pid_ = 0;
+        SyncAgent() = default;
+        explicit SyncAgent(const std::string &bundleName);
         int32_t count_ = 0;
         std::map<std::string, int> callBackStores_;
         std::string bundleName_;
         sptr<RdbNotifierProxy> notifier_ = nullptr;
         std::shared_ptr<RdbWatcher> watcher_ = nullptr;
-        void ReInit(pid_t pid, const std::string &bundleName);
         void SetNotifier(sptr<RdbNotifierProxy> notifier);
         void SetWatcher(std::shared_ptr<RdbWatcher> watcher);
     };
+    using SyncAgents = std::map<int32_t, SyncAgent>;
 
     class RdbStatic : public StaticActs {
     public:
@@ -154,7 +165,7 @@ private:
 
     std::shared_ptr<DistributedData::GeneralStore> GetStore(const RdbSyncerParam& param);
 
-    void OnAsyncComplete(uint32_t tokenId, uint32_t seqNum, Details &&result);
+    void OnAsyncComplete(uint32_t tokenId, pid_t pid, uint32_t seqNum, Details &&result);
 
     StoreMetaData GetStoreMetaData(const RdbSyncerParam &param);
 
@@ -173,15 +184,22 @@ private:
 
     static std::pair<int32_t, int32_t> GetInstIndexAndUser(uint32_t tokenId, const std::string &bundleName);
 
-    static bool GetPassword(const StoreMetaData &metaData, DistributedDB::CipherPassword &password);
+    static bool GetDBPassword(const StoreMetaData &metaData, DistributedDB::CipherPassword &password);
 
     void GetCloudSchema(const RdbSyncerParam &param);
 
     void SetReturnParam(StoreMetaData &metadata, RdbSyncerParam &param);
 
+    bool IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids);
+
+    SyncResult ProcessResult(const std::map<std::string, int32_t> &results);
+
+    StoreInfo GetStoreInfo(const RdbSyncerParam &param);
+
     static Factory factory_;
-    ConcurrentMap<uint32_t, SyncAgent> syncAgents_;
+    ConcurrentMap<uint32_t, SyncAgents> syncAgents_;
     std::shared_ptr<ExecutorPool> executors_;
+    ConcurrentMap<std::string, ExecutorPool::TaskId> heartbeatTaskIds_;
 };
 } // namespace OHOS::DistributedRdb
 #endif
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.cpp b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.cpp
index 49274e8787d5d6ba899c4373ea893fabe3052321..a6736520dce8f3197ee0f2ae526ad28bf6da93b2 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.cpp
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.cpp
@@ -284,13 +284,32 @@ int32_t RdbServiceStub::OnRemoteNotifyDataChange(MessageParcel &data, MessagePar
 {
     RdbSyncerParam param;
     RdbChangedData rdbChangedData;
-    if (!ITypesUtil::Unmarshal(data, param, rdbChangedData)) {
+    RdbNotifyConfig rdbNotifyConfig;
+    if (!ITypesUtil::Unmarshal(data, param, rdbChangedData, rdbNotifyConfig)) {
         ZLOGE("Unmarshal bundleName_:%{public}s storeName_:%{public}s ", param.bundleName_.c_str(),
               Anonymous::Change(param.storeName_).c_str());
         return IPC_STUB_INVALID_DATA_ERR;
     }
 
-    auto status = NotifyDataChange(param, rdbChangedData);
+    auto status = NotifyDataChange(param, rdbChangedData, rdbNotifyConfig);
+    if (!ITypesUtil::Marshal(reply, status)) {
+        ZLOGE("Marshal status:0x%{public}x", status);
+        return IPC_STUB_WRITE_PARCEL_ERR;
+    }
+    return RDB_OK;
+}
+
+int32_t RdbServiceStub::OnRemoteSetSearchable(MessageParcel &data, MessageParcel &reply)
+{
+    RdbSyncerParam param;
+    bool isSearchable = true;
+    if (!ITypesUtil::Unmarshal(data, param, isSearchable)) {
+        ZLOGE("Unmarshal bundleName_:%{public}s storeName_:%{public}s ", param.bundleName_.c_str(),
+              Anonymous::Change(param.storeName_).c_str());
+        return IPC_STUB_INVALID_DATA_ERR;
+    }
+
+    auto status = SetSearchable(param, isSearchable);
     if (!ITypesUtil::Marshal(reply, status)) {
         ZLOGE("Marshal status:0x%{public}x", status);
         return IPC_STUB_WRITE_PARCEL_ERR;
@@ -351,4 +370,53 @@ int32_t RdbServiceStub::OnEnable(MessageParcel& data, MessageParcel& reply)
     }
     return RDB_OK;
 }
+
+int32_t RdbServiceStub::OnGetPassword(MessageParcel &data, MessageParcel &reply)
+{
+    RdbSyncerParam param;
+    if (!ITypesUtil::Unmarshal(data, param)) {
+        ZLOGE("Unmarshal bundleName_:%{public}s storeName_:%{public}s", param.bundleName_.c_str(),
+            Anonymous::Change(param.storeName_).c_str());
+        return IPC_STUB_INVALID_DATA_ERR;
+    }
+
+    std::vector<uint8_t> key;
+    auto status = GetPassword(param, key);
+    if (!ITypesUtil::Marshal(reply, status, key)) {
+        key.assign(key.size(), 0);
+        ZLOGE("Marshal status:0x%{public}x", status);
+        return IPC_STUB_WRITE_PARCEL_ERR;
+    }
+    key.assign(key.size(), 0);
+    return RDB_OK;
+}
+
+int32_t RdbServiceStub::OnLockCloudContainer(MessageParcel &data, MessageParcel &reply)
+{
+    RdbSyncerParam param;
+    uint32_t expiredTime = 0;
+    if (!ITypesUtil::Unmarshal(data, param, expiredTime)) {
+        ZLOGE("Unmarshal failed");
+        return IPC_STUB_INVALID_DATA_ERR;
+    }
+
+    auto result = LockCloudContainer(param);
+    return ITypesUtil::Marshal(reply, result.first, result.second) ? RDB_OK : IPC_STUB_WRITE_PARCEL_ERR;
+}
+
+int32_t RdbServiceStub::OnUnlockCloudContainer(MessageParcel &data, MessageParcel &reply)
+{
+    RdbSyncerParam param;
+    if (!ITypesUtil::Unmarshal(data, param)) {
+        ZLOGE("Unmarshal failed");
+        return IPC_STUB_INVALID_DATA_ERR;
+    }
+
+    auto status = UnlockCloudContainer(param);
+    if (!ITypesUtil::Marshal(reply, status)) {
+        ZLOGE("Marshal status:0x%{public}x", status);
+        return IPC_STUB_WRITE_PARCEL_ERR;
+    }
+    return RDB_OK;
+}
 } // namespace OHOS::DistributedRdb
diff --git a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.h b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.h
index eef8b94d62d833c8143aa73ebe154619751be247..a8ac6b9bc9298c25c109b674ed9ff86b86113765 100644
--- a/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.h
+++ b/datamgr_service/services/distributeddataservice/service/rdb/rdb_service_stub.h
@@ -56,6 +56,8 @@ private:
 
     int32_t OnRemoteNotifyDataChange(MessageParcel& data, MessageParcel& reply);
 
+    int32_t OnRemoteSetSearchable(MessageParcel& data, MessageParcel& reply);
+
     int32_t OnRemoteQuerySharingResource(MessageParcel& data, MessageParcel& reply);
 
     int32_t OnBeforeOpen(MessageParcel& data, MessageParcel& reply);
@@ -65,6 +67,12 @@ private:
     int32_t OnDisable(MessageParcel& data, MessageParcel& reply);
 
     int32_t OnEnable(MessageParcel& data, MessageParcel& reply);
+	
+    int32_t OnGetPassword(MessageParcel& data, MessageParcel& reply);
+
+    int32_t OnLockCloudContainer(MessageParcel& data, MessageParcel& reply);
+
+    int32_t OnUnlockCloudContainer(MessageParcel& data, MessageParcel& reply);
 
     using RequestHandle = int (RdbServiceStub::*)(MessageParcel &, MessageParcel &);
     static constexpr RequestHandle HANDLERS[static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_MAX)] = {
@@ -85,12 +93,19 @@ private:
             &RdbServiceStub::OnRemoteUnregisterDetailProgressObserver,
         [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_NOTIFY_DATA_CHANGE)] =
             &RdbServiceStub::OnRemoteNotifyDataChange,
+        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_SET_SEARCHABLE)] =
+            &RdbServiceStub::OnRemoteSetSearchable,
         [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_QUERY_SHARING_RESOURCE)] =
             &RdbServiceStub::OnRemoteQuerySharingResource,
         [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_DISABLE)] = &RdbServiceStub::OnDisable,
         [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_ENABLE)] = &RdbServiceStub::OnEnable,
         [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_BEFORE_OPEN)] = &RdbServiceStub::OnBeforeOpen,
-        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_AFTER_OPEN)] = &RdbServiceStub::OnAfterOpen
+        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_AFTER_OPEN)] = &RdbServiceStub::OnAfterOpen,
+        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_GET_PASSWORD)] = &RdbServiceStub::OnGetPassword,
+        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_LOCK_CLOUD_CONTAINER)] =
+            &RdbServiceStub::OnLockCloudContainer,
+        [static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_UNLOCK_CLOUD_CONTAINER)] =
+            &RdbServiceStub::OnUnlockCloudContainer
     };
 };
 } // namespace OHOS::DistributedRdb
diff --git a/datamgr_service/services/distributeddataservice/service/test/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/BUILD.gn
index 5aac474e418fe2d977fb2ff0a0ea9b872875d216..6e351661a65a1f083e7012c1d1f25f5053cbb519 100644
--- a/datamgr_service/services/distributeddataservice/service/test/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/BUILD.gn
@@ -46,6 +46,8 @@ config("module_private_config") {
     "${data_service_path}/service/waterversion",
     "${dataobject_path}/interfaces/innerkits",
     "${dataobject_path}/frameworks/innerkitsimpl/include",
+    "${kv_store_distributeddb_path}/interfaces/include/",
+    "${kv_store_distributeddb_path}/include/",
     "${relational_store_path}/interfaces/inner_api/cloud_data/include",
     "${relational_store_path}/interfaces/inner_api/common_type/include",
   ]
@@ -76,6 +78,7 @@ ohos_unittest("CloudDataTest") {
     "${data_service_path}/service/common/value_proxy.cpp",
     "${data_service_path}/service/common/xcollie.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
@@ -129,6 +132,94 @@ ohos_unittest("CloudDataTest") {
     "mock:distributeddata_mock_static",
     "//third_party/googletest:gtest_main",
   ]
+
+  cflags = [
+    "-fno-access-control",  # Ignore Private Member Access Control
+  ]
+
+  cflags_cc = cflags
+}
+
+ohos_unittest("CloudServiceImplTest") {
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  module_out_path = module_output_path
+  sources = [
+    "${data_service_path}/service/backup/src/backup_manager.cpp",
+    "${data_service_path}/service/bootstrap/src/bootstrap.cpp",
+    "${data_service_path}/service/cloud/cloud_service_impl.cpp",
+    "${data_service_path}/service/cloud/cloud_service_stub.cpp",
+    "${data_service_path}/service/cloud/cloud_types_util.cpp",
+    "${data_service_path}/service/cloud/cloud_value_util.cpp",
+    "${data_service_path}/service/cloud/sync_manager.cpp",
+    "${data_service_path}/service/cloud/sync_strategies/network_sync_strategy.cpp",
+    "${data_service_path}/service/common/common_types_utils.cpp",
+    "${data_service_path}/service/common/value_proxy.cpp",
+    "${data_service_path}/service/common/xcollie.cpp",
+    "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
+    "${data_service_path}/service/config/src/model/backup_config.cpp",
+    "${data_service_path}/service/config/src/model/checker_config.cpp",
+    "${data_service_path}/service/config/src/model/cloud_config.cpp",
+    "${data_service_path}/service/config/src/model/component_config.cpp",
+    "${data_service_path}/service/config/src/model/directory_config.cpp",
+    "${data_service_path}/service/config/src/model/global_config.cpp",
+    "${data_service_path}/service/config/src/model/network_config.cpp",
+    "${data_service_path}/service/config/src/model/protocol_config.cpp",
+    "${data_service_path}/service/crypto/src/crypto_manager.cpp",
+    "${data_service_path}/service/matrix/src/device_matrix.cpp",
+    "${data_service_path}/service/matrix/src/matrix_event.cpp",
+    "${data_service_path}/service/rdb/cache_cursor.cpp",
+    "${data_service_path}/service/rdb/rdb_asset_loader.cpp",
+    "${data_service_path}/service/rdb/rdb_cloud.cpp",
+    "${data_service_path}/service/rdb/rdb_cloud_data_translate.cpp",
+    "${data_service_path}/service/rdb/rdb_cursor.cpp",
+    "${data_service_path}/service/rdb/rdb_general_store.cpp",
+    "${data_service_path}/service/rdb/rdb_notifier_proxy.cpp",
+    "${data_service_path}/service/rdb/rdb_query.cpp",
+    "${data_service_path}/service/rdb/rdb_result_set_impl.cpp",
+    "${data_service_path}/service/rdb/rdb_result_set_stub.cpp",
+    "${data_service_path}/service/rdb/rdb_service_impl.cpp",
+    "${data_service_path}/service/rdb/rdb_service_stub.cpp",
+    "${data_service_path}/service/rdb/rdb_watcher.cpp",
+    "${data_service_path}/service/test/mock/checker_mock.cpp",
+    "${data_service_path}/service/waterversion/water_version_manager.cpp",
+    "cloud_service_impl_test.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  external_deps = [
+    "ability_base:base",
+    "ability_base:want",
+    "access_token:libaccesstoken_sdk",
+    "access_token:libtoken_setproc",
+    "access_token:libtokenid_sdk",
+    "c_utils:utils",
+    "hicollie:libhicollie",
+    "hilog:libhilog",
+    "huks:libhukssdk",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+    "kv_store:distributeddb",
+    "relational_store:native_rdb",
+  ]
+
+  deps = [
+    "../../adapter:distributeddata_adapter",
+    "../../framework:distributeddatasvcfwk",
+    "mock:distributeddata_mock_static",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  cflags = [
+    "-fno-access-control",  # Ignore Private Member Access Control
+  ]
+
+  cflags_cc = cflags
 }
 
 ohos_unittest("CloudTest") {
@@ -156,7 +247,7 @@ ohos_unittest("CloudTest") {
   ]
 }
 
-ohos_unittest("ValueProxyTest") {
+ohos_unittest("ValueProxyServiceTest") {
   module_out_path = module_output_path
   sources = [
     "../common/value_proxy.cpp",
@@ -170,6 +261,13 @@ ohos_unittest("ValueProxyTest") {
 
   configs = [ ":module_private_config" ]
 
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+    "-Wno-multichar",
+    "-Wno-c99-designator",
+  ]
+
   external_deps = [
     "ability_base:base",
     "ability_base:want",
@@ -294,45 +392,6 @@ ohos_unittest("DeviceMatrixTest") {
   ]
 }
 
-ohos_unittest("AutoSyncMatrixTest") {
-  module_out_path = module_output_path
-  sources = [
-    "${data_service_path}/app/src/kvstore_meta_manager.cpp",
-    "auto_sync_matrix_test.cpp",
-  ]
-
-  include_dirs = [
-    "${data_service_path}/app/src",
-    "${data_service_path}/service/kvdb",
-    "${data_service_path}/adapter/include/account",
-    "${kv_store_path}/frameworks/innerkitsimpl/kvdb/include",
-    "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include",
-    "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include",
-  ]
-
-  configs = [ ":module_private_config" ]
-
-  external_deps = [
-    "access_token:libaccesstoken_sdk",
-    "access_token:libnativetoken",
-    "access_token:libtoken_setproc",
-    "c_utils:utils",
-    "dataclassification:data_transit_mgr",
-    "hilog:libhilog",
-    "hisysevent:libhisysevent",
-    "ipc:ipc_core",
-    "kv_store:distributeddata_inner",
-  ]
-
-  deps = [
-    "${data_service_path}/adapter:distributeddata_adapter",
-    "${data_service_path}/framework:distributeddatasvcfwk",
-    "${data_service_path}/service:distributeddatasvc",
-    "${kv_store_distributeddb_path}:distributeddb",
-    "//third_party/googletest:gtest_main",
-  ]
-}
-
 ohos_unittest("KVDBGeneralStoreTest") {
   module_out_path = module_output_path
   sources = [
@@ -344,6 +403,8 @@ ohos_unittest("KVDBGeneralStoreTest") {
     "kvdb_general_store_test.cpp",
     "mock/db_change_data_mock.cpp",
     "mock/db_store_mock.cpp",
+    "mock/general_watcher_mock.cpp",
+    "mock/kv_store_nb_delegate_mock.cpp",
   ]
 
   include_dirs = [
@@ -357,6 +418,11 @@ ohos_unittest("KVDBGeneralStoreTest") {
 
   configs = [ ":module_private_config" ]
 
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
   external_deps = [
     "ability_base:base",
     "ability_base:want",
@@ -437,7 +503,9 @@ ohos_unittest("RdbServiceTest") {
     "${data_service_path}/service/rdb/rdb_query.cpp",
     "${data_service_path}/service/rdb/rdb_result_set_impl.cpp",
     "${data_service_path}/service/rdb/rdb_result_set_stub.cpp",
+    "${data_service_path}/service/rdb/rdb_watcher.cpp",
     "cache_cursor_test.cpp",
+    "mock/general_watcher_mock.cpp",
     "rdb_asset_loader_test.cpp",
     "rdb_cloud_test.cpp",
     "rdb_cursor_test.cpp",
@@ -484,6 +552,46 @@ ohos_unittest("RdbServiceTest") {
   ]
 }
 
+ohos_unittest("ObjectAssetLoaderTest") {
+  module_out_path = module_output_path
+  sources = [
+    "../object/object_asset_loader.cpp",
+    "../object/object_asset_machine.cpp",
+    "../object/object_snapshot.cpp",
+    "object_asset_loader_test.cpp",
+  ]
+
+  include_dirs = [
+    "${dataobject_path}/frameworks/innerkitsimpl/include/common",
+    "${dataobject_path}/interfaces/innerkits",
+    "${relational_store_path}/interfaces/inner_api/common_type/include",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  external_deps = [
+    "c_utils:utils",
+    "dfs_service:cloudsync_asset_kit_inner",
+    "dfs_service:distributed_file_daemon_kit_inner",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+  ]
+
+  deps = [
+    "${data_service_path}/adapter:distributeddata_adapter",
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+}
+
 ohos_unittest("ObjectAssetMachineTest") {
   module_out_path = module_output_path
   sources = [
@@ -518,6 +626,91 @@ ohos_unittest("ObjectAssetMachineTest") {
   ]
 }
 
+ohos_unittest("ObjectManagerTest") {
+  module_out_path = module_output_path
+  sources = [
+    "${data_service_path}/service/common/value_proxy.cpp",
+    "../object/object_asset_loader.cpp",
+    "../object/object_asset_machine.cpp",
+    "../object/object_callback_proxy.cpp",
+    "../object/object_data_listener.cpp",
+    "../object/object_manager.cpp",
+    "../object/object_snapshot.cpp",
+    "mock/kv_store_nb_delegate_mock.cpp",
+    "object_manager_test.cpp",
+  ]
+
+  include_dirs = [
+    "${dataobject_path}/frameworks/innerkitsimpl/include",
+    "${data_service_path}/service/common",
+    "${dataobject_path}/frameworks/innerkitsimpl/include/common",
+    "${dataobject_path}/interfaces/innerkits",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  external_deps = [
+    "access_token:libaccesstoken_sdk",
+    "access_token:libtokenid_sdk",
+    "c_utils:utils",
+    "dfs_service:cloudsync_asset_kit_inner",
+    "dfs_service:distributed_file_daemon_kit_inner",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+    "kv_store:distributeddb",
+    "relational_store:native_rdb",
+  ]
+
+  deps = [
+    "${data_service_path}/adapter:distributeddata_adapter",
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+}
+
+ohos_unittest("ObjectSnapshotTest") {
+  module_out_path = module_output_path
+  sources = [
+    "../object/object_asset_loader.cpp",
+    "../object/object_asset_machine.cpp",
+    "../object/object_snapshot.cpp",
+    "object_snapshot_test.cpp",
+  ]
+
+  include_dirs = [
+    "${dataobject_path}/frameworks/innerkitsimpl/include/common",
+    "${dataobject_path}/interfaces/innerkits",
+    "${relational_store_path}/interfaces/inner_api/common_type/include",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  external_deps = [
+    "c_utils:utils",
+    "dfs_service:cloudsync_asset_kit_inner",
+    "dfs_service:distributed_file_daemon_kit_inner",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+  ]
+
+  deps = [
+    "${data_service_path}/adapter:distributeddata_adapter",
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+    "//third_party/googletest:gtest_main",
+  ]
+}
+
 ohos_unittest("MetaDataTest") {
   module_out_path = module_output_path
   sources = [
@@ -623,6 +816,7 @@ ohos_unittest("WaterVersionManagerTest") {
     "${data_service_path}/service/backup/src/backup_manager.cpp",
     "${data_service_path}/service/bootstrap/src/bootstrap.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
@@ -804,7 +998,19 @@ ohos_unittest("KvdbServiceImplTest") {
   module_out_path = module_output_path
   sources = [
     "${data_service_path}/app/src/kvstore_meta_manager.cpp",
+    "${data_service_path}/service/common/value_proxy.cpp",
+    "${data_service_path}/service/kvdb/auth_delegate.cpp",
+    "${data_service_path}/service/kvdb/kvdb_general_store.cpp",
+    "${data_service_path}/service/kvdb/kvdb_notifier_proxy.cpp",
+    "${data_service_path}/service/kvdb/kvdb_watcher.cpp",
+    "${data_service_path}/service/kvdb/query_helper.cpp",
+    "${data_service_path}/service/kvdb/upgrade.cpp",
+    "${data_service_path}/service/kvdb/user_delegate.cpp",
+    "${data_service_path}/service/rdb/rdb_cloud.cpp",
+    "${data_service_path}/service/rdb/rdb_query.cpp",
+    "${data_service_path}/service/waterversion/water_version_manager.cpp",
     "kvdb_service_impl_test.cpp",
+    "kvdb_service_test.cpp",
   ]
 
   include_dirs = [
@@ -818,16 +1024,23 @@ ohos_unittest("KvdbServiceImplTest") {
 
   configs = [ ":module_private_config" ]
 
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
   external_deps = [
     "access_token:libaccesstoken_sdk",
     "access_token:libnativetoken",
     "access_token:libtoken_setproc",
     "c_utils:utils",
     "dataclassification:data_transit_mgr",
+    "device_auth:deviceauth_sdk",
     "hilog:libhilog",
     "hisysevent:libhisysevent",
     "ipc:ipc_core",
     "kv_store:distributeddata_inner",
+    "relational_store:native_rdb",
   ]
 
   deps = [
@@ -839,6 +1052,37 @@ ohos_unittest("KvdbServiceImplTest") {
   ]
 }
 
+ohos_unittest("DumpHelperTest") {
+  module_out_path = module_output_path
+  sources = [
+    "${data_service_path}/service/dumper/src/dump_helper.cpp",
+    "dump_helper_test.cpp",
+  ]
+
+  include_dirs = [ "${data_service_path}/service/dumper/include" ]
+
+  configs = [ ":module_private_config" ]
+
+  cflags = [
+    "-Dprivate=public",
+    "-Dprotected=public",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "kv_store:distributeddata_inner",
+    "kv_store:distributeddb",
+    "relational_store:native_rdb",
+  ]
+
+  deps = [
+    "${data_service_path}/framework:distributeddatasvcfwk",
+    "${data_service_path}/service:distributeddatasvc",
+    "//third_party/googletest:gtest_main",
+  ]
+}
+
 ###############################################################################
 group("unittest") {
   testonly = true
@@ -850,21 +1094,25 @@ group("unittest") {
   }
 
   deps += [
-    ":AutoSyncMatrixTest",
     ":CloudDataTest",
+    ":CloudServiceImplTest",
     ":CloudTest",
     ":CryptoManagerTest",
     ":DataShareServiceImplTest",
     ":DeviceMatrixTest",
     ":DirectoryManagerTest",
+    ":DumpHelperTest",
     ":KVDBGeneralStoreTest",
     ":KvdbServiceImplTest",
     ":MetaDataTest",
+    ":ObjectAssetLoaderTest",
     ":ObjectAssetMachineTest",
+    ":ObjectManagerTest",
+    ":ObjectSnapshotTest",
     ":RdbResultSetImplTest",
     ":RdbServiceTest",
     ":UdmfRunTimeStoreTest",
-    ":ValueProxyTest",
+    ":ValueProxyServiceTest",
     ":WaterVersionManagerTest",
   ]
 }
diff --git a/datamgr_service/services/distributeddataservice/service/test/auto_sync_matrix_test.cpp b/datamgr_service/services/distributeddataservice/service/test/auto_sync_matrix_test.cpp
deleted file mode 100644
index adc5022205b978765bbaf9e8ddd86314828b046e..0000000000000000000000000000000000000000
--- a/datamgr_service/services/distributeddataservice/service/test/auto_sync_matrix_test.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "auto_sync_matrix.h"
-
-#include <thread>
-#include "block_data.h"
-#include "bootstrap.h"
-#include "device_manager_adapter.h"
-#include "eventcenter/event_center.h"
-#include "executor_pool.h"
-#include "feature/feature_system.h"
-#include "gtest/gtest.h"
-#include "ipc_skeleton.h"
-#include "kvstore_meta_manager.h"
-#include "matrix_event.h"
-#include "metadata/meta_data_manager.h"
-#include "metadata/store_meta_data.h"
-#include "types.h"
-using namespace testing::ext;
-using namespace OHOS::DistributedData;
-using DMAdapter = DeviceManagerAdapter;
-using namespace DistributedDB;
-namespace OHOS::Test {
-namespace DistributedDataTest {
-class AutoSyncMatrixTest : public testing::Test {
-public:
-    static void SetUpTestCase(void);
-    static void TearDownTestCase(void);
-    void SetUp();
-    void TearDown();
-
-protected:
-    static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320";
-    static constexpr const char *TEST_BUNDLE = "auto_sync_matrix_test";
-    static constexpr const char *TEST_STORE = "auto_sync_matrix_store";
-    static constexpr const char *TEST_USER = "0";
-    void InitMetaData();
-
-    StoreMetaData metaData_;
-};
-
-void AutoSyncMatrixTest::SetUpTestCase(void)
-{
-    auto executors = std::make_shared<ExecutorPool>(12, 5);
-    Bootstrap::GetInstance().LoadComponents();
-    Bootstrap::GetInstance().LoadDirectory();
-    Bootstrap::GetInstance().LoadCheckers();
-    DMAdapter::GetInstance().Init(executors);
-    DistributedKv::KvStoreMetaManager::GetInstance().BindExecutor(executors);
-    DistributedKv::KvStoreMetaManager::GetInstance().InitMetaParameter();
-    DistributedKv::KvStoreMetaManager::GetInstance().InitMetaListener();
-    StoreMetaData meta;
-    meta.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
-    meta.appId = TEST_BUNDLE;
-    meta.bundleName = TEST_BUNDLE;
-    meta.user = TEST_USER;
-    meta.area = DistributedKv::EL1;
-    meta.tokenId = IPCSkeleton::GetCallingTokenID();
-    meta.instanceId = 0;
-    meta.isAutoSync = true;
-    meta.storeType = 1;
-    meta.storeId = "auto_sync_matrix_default_store";
-    meta.dataType = 1;
-    MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta);
-    AutoSyncMatrix::GetInstance().Initialize();
-}
-
-void AutoSyncMatrixTest::TearDownTestCase(void)
-{
-}
-
-void AutoSyncMatrixTest::SetUp()
-{
-    InitMetaData();
-}
-
-void AutoSyncMatrixTest::TearDown()
-{
-}
-
-void AutoSyncMatrixTest::InitMetaData()
-{
-    metaData_.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
-    metaData_.appId = TEST_BUNDLE;
-    metaData_.bundleName = TEST_BUNDLE;
-    metaData_.user = TEST_USER;
-    metaData_.area = DistributedKv::EL1;
-    metaData_.tokenId = IPCSkeleton::GetCallingTokenID();
-    metaData_.instanceId = 0;
-    metaData_.isAutoSync = true;
-    metaData_.storeType = 1;
-    metaData_.storeId = TEST_STORE;
-    metaData_.dataType = 1;
-}
-
-/**
-* @tc.name: GetChangedStore
-* @tc.desc: get changed store on init.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, GetChangedStore, TestSize.Level0)
-{
-    auto metas = AutoSyncMatrix::GetInstance().GetChangedStore("");
-    ASSERT_EQ(metas.size(), 0);
-    metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas.size(), 0);
-}
-
-/**
-* @tc.name: AutoSyncMatrixOnline
-* @tc.desc: auto sync matrix online.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, AutoSyncMatrixOnline, TestSize.Level0)
-{
-    AutoSyncMatrix::GetInstance().Online("");
-    auto metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas.size(), 0);
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas.size(), 0);
-    AutoSyncMatrix::GetInstance().Offline(TEST_DEVICE);
-    metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas.size(), 0);
-}
-
-/**
-* @tc.name: AutoSyncMatrixOffline
-* @tc.desc: auto sync matrix offline.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, AutoSyncMatrixOffline, TestSize.Level0)
-{
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    auto before = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(before.size(), 0);
-    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_);
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    auto after = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(after.size(), before.size());
-    AutoSyncMatrix::GetInstance().Offline(TEST_DEVICE);
-    auto metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas.size(), 0);
-}
-
-/**
-* @tc.name: AutoSyncMatrixOnChanged
-* @tc.desc: auto sync matrix on changed.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, AutoSyncMatrixOnChanged, TestSize.Level0)
-{
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    auto metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas.size(), 0);
-    AutoSyncMatrix::GetInstance().OnChanged(metaData_);
-    metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas.size(), 0);
-    AutoSyncMatrix::GetInstance().Offline(TEST_DEVICE);
-    metas = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas.size(), 0);
-}
-
-/**
-* @tc.name: AutoSyncMatrixOnExchanged
-* @tc.desc: auto sync matrix on exchanged.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, AutoSyncMatrixOnExchanged, TestSize.Level0)
-{
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    auto metas1 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas1.size(), 0);
-    AutoSyncMatrix::GetInstance().OnExchanged(TEST_DEVICE, metaData_);
-    auto metas2 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas2.size(), metas1.size() - 1);
-    AutoSyncMatrix::GetInstance().Offline(TEST_DEVICE);
-    AutoSyncMatrix::GetInstance().OnChanged(metaData_);
-    auto metas3 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_EQ(metas3.size(), 0);
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    auto metas4 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas4.size(), metas1.size());
-}
-
-/**
-* @tc.name: AutoSyncMatrixDeleteMeta
-* @tc.desc: auto sync matrix on delete Meta.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(AutoSyncMatrixTest, AutoSyncMatrixDeleteMeta, TestSize.Level0)
-{
-    AutoSyncMatrix::GetInstance().Online(TEST_DEVICE);
-    AutoSyncMatrix::GetInstance().OnChanged(metaData_);
-    auto metas1 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas1.size(), 0);
-    MetaDataManager::GetInstance().DelMeta(metaData_.GetKey());
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    auto metas2 = AutoSyncMatrix::GetInstance().GetChangedStore(TEST_DEVICE);
-    ASSERT_GE(metas2.size(), metas1.size() -1);
-    for (auto meta : metas2) {
-        ASSERT_NE(metaData_.GetKey(), meta.GetKey());
-    }
-}
-} // namespace DistributedDataTest
-} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/cloud_data_test.cpp b/datamgr_service/services/distributeddataservice/service/test/cloud_data_test.cpp
index 010d99940e6feda4008ae73227c2aa9445b13492..be76bb4d20bf46c5c8bd6358ce699c66c42c0fd4 100644
--- a/datamgr_service/services/distributeddataservice/service/test/cloud_data_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/cloud_data_test.cpp
@@ -23,9 +23,13 @@
 #include "cloud/change_event.h"
 #include "cloud/cloud_event.h"
 #include "cloud/cloud_server.h"
+#include "cloud/cloud_share_event.h"
+#include "cloud/make_query_event.h"
 #include "cloud/schema_meta.h"
 #include "cloud_service_impl.h"
 #include "cloud_types.h"
+#include "cloud_types_util.h"
+#include "cloud_value_util.h"
 #include "communicator/device_manager_adapter.h"
 #include "device_matrix.h"
 #include "eventcenter/event_center.h"
@@ -51,7 +55,11 @@ using namespace OHOS::Security::AccessToken;
 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 using Querykey = OHOS::CloudData::QueryKey;
 using CloudSyncInfo = OHOS::CloudData::CloudSyncInfo;
-
+using SharingCfm = OHOS::CloudData::SharingUtil::SharingCfm;
+using Confirmation = OHOS::CloudData::Confirmation;
+using CenterCode = OHOS::DistributedData::SharingCenter::SharingCode;
+using Status = OHOS::CloudData::CloudService::Status;
+using GenErr = OHOS::DistributedData::GeneralError;
 uint64_t g_selfTokenID = 0;
 
 void AllocHapToken(const HapPolicyParams &policy)
@@ -75,6 +83,32 @@ static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store";
 static constexpr const char *TEST_CLOUD_ID = "test_cloud_id";
 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1";
 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2";
+static constexpr const char *PERMISSION_CLOUDDATA_CONFIG = "ohos.permission.CLOUDDATA_CONFIG";
+static constexpr const char *PERMISSION_GET_NETWORK_INFO = "ohos.permission.GET_NETWORK_INFO";
+static constexpr const char *PERMISSION_DISTRIBUTED_DATASYNC = "ohos.permission.DISTRIBUTED_DATASYNC";
+static constexpr const char *PERMISSION_ACCESS_SERVICE_DM = "ohos.permission.ACCESS_SERVICE_DM";
+PermissionDef GetPermissionDef(const std::string &permission)
+{
+    PermissionDef def = { .permissionName = permission,
+        .bundleName = "test_cloud_bundleName",
+        .grantMode = 1,
+        .availableLevel = APL_SYSTEM_BASIC,
+        .label = "label",
+        .labelId = 1,
+        .description = "test_cloud_bundleName",
+        .descriptionId = 1 };
+    return def;
+}
+
+PermissionStateFull GetPermissionStateFull(const std::string &permission)
+{
+    PermissionStateFull stateFull = { .permissionName = permission,
+        .isGeneral = true,
+        .resDeviceID = { "local" },
+        .grantStatus = { PermissionState::PERMISSION_GRANTED },
+        .grantFlags = { 1 } };
+    return stateFull;
+}
 class CloudDataTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
@@ -102,6 +136,7 @@ public:
     virtual ~CloudServerMock() = default;
     static constexpr uint64_t REMAINSPACE = 1000;
     static constexpr uint64_t TATALSPACE = 2000;
+    static constexpr int32_t INVALID_USER_ID = -1;
 };
 
 CloudInfo CloudServerMock::GetServerInfo(int32_t userId, bool needSpaceInfo)
@@ -125,6 +160,14 @@ CloudInfo CloudServerMock::GetServerInfo(int32_t userId, bool needSpaceInfo)
 
 std::pair<int32_t, SchemaMeta> CloudServerMock::GetAppSchema(int32_t userId, const std::string &bundleName)
 {
+    if (userId == INVALID_USER_ID) {
+        return { E_ERROR, CloudDataTest::schemaMeta_ };
+    }
+
+    if (bundleName.empty()) {
+        SchemaMeta schemaMeta;
+        return { E_OK, schemaMeta };
+    }
     return { E_OK, CloudDataTest::schemaMeta_ };
 }
 
@@ -202,46 +245,29 @@ void CloudDataTest::SetUpTestCase(void)
 
     auto cloudServerMock = new CloudServerMock();
     CloudServer::RegisterCloudInstance(cloudServerMock);
-
     HapPolicyParams policy = { .apl = APL_SYSTEM_BASIC,
         .domain = "test.domain",
-        .permList = {
-            {
-                .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
-                .bundleName = "test_cloud_bundleName",
-                .grantMode = 1,
-                .availableLevel = APL_SYSTEM_BASIC,
-                .label = "label",
-                .labelId = 1,
-                .description = "test_cloud_bundleName",
-                .descriptionId = 1
-            }
-        },
-        .permStateList = {
-            {
-                .permissionName = "ohos.permission.CLOUDDATA_CONFIG",
-                .isGeneral = true,
-                .resDeviceID = { "local" },
-                .grantStatus = { PermissionState::PERMISSION_GRANTED },
-                .grantFlags = { 1 }
-            }
-        }
-    };
+        .permList = { GetPermissionDef(PERMISSION_CLOUDDATA_CONFIG), GetPermissionDef(PERMISSION_GET_NETWORK_INFO),
+            GetPermissionDef(PERMISSION_DISTRIBUTED_DATASYNC), GetPermissionDef(PERMISSION_ACCESS_SERVICE_DM) },
+        .permStateList = { GetPermissionStateFull(PERMISSION_CLOUDDATA_CONFIG),
+            GetPermissionStateFull(PERMISSION_GET_NETWORK_INFO),
+            GetPermissionStateFull(PERMISSION_DISTRIBUTED_DATASYNC),
+            GetPermissionStateFull(PERMISSION_ACCESS_SERVICE_DM) } };
     g_selfTokenID = GetSelfTokenID();
     AllocHapToken(policy);
-
-    InitCloudInfo();
-    InitMetaData();
-    InitSchemaMeta();
-
     size_t max = 12;
     size_t min = 5;
 
     auto executor = std::make_shared<ExecutorPool>(max, min);
     cloudServiceImpl_->OnBind(
         { "CloudDataTest", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-
     Bootstrap::GetInstance().LoadCheckers();
+    auto dmExecutor = std::make_shared<ExecutorPool>(max, min);
+    DeviceManagerAdapter::GetInstance().Init(dmExecutor);
+    InitCloudInfo();
+    InitMetaData();
+    InitSchemaMeta();
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
 }
 
 void CloudDataTest::TearDownTestCase()
@@ -282,7 +308,8 @@ HWTEST_F(CloudDataTest, GetSchema, TestSize.Level0)
     StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
     auto event = std::make_unique<CloudEvent>(CloudEvent::GET_SCHEMA, storeInfo);
     EventCenter::GetInstance().PostEvent(std::move(event));
-    ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true));
+    auto ret = MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
+    ASSERT_TRUE(ret);
 }
 
 /**
@@ -455,17 +482,7 @@ HWTEST_F(CloudDataTest, QueryLastSyncInfo004, TestSize.Level0)
     ZLOGI("CloudDataTest QueryLastSyncInfo004 start");
     auto ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
-
-    auto rdbServiceImpl = std::make_shared<DistributedRdb::RdbServiceImpl>();
-    DistributedRdb::RdbSyncerParam param;
-    param.bundleName_ = TEST_CLOUD_BUNDLE;
-    param.storeName_ = TEST_CLOUD_DATABASE_ALIAS_1;
-    DistributedRdb::RdbService::Option option;
-    option.mode = DistributedRdb::SyncMode::CLOUD_FIRST;
-    option.isAutoSync = true;
-    option.isAsync = false;
-    DistributedRdb::PredicatesMemo memo;
-    rdbServiceImpl->Sync(param, option, memo, nullptr);
+    cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
 
     sleep(1);
 
@@ -487,23 +504,11 @@ HWTEST_F(CloudDataTest, QueryLastSyncInfo005, TestSize.Level0)
     ZLOGI("CloudDataTest QueryLastSyncInfo005 start");
     std::map<std::string, int32_t> switches;
     switches.emplace(TEST_CLOUD_ID, true);
-    auto ret = cloudServiceImpl_->EnableCloud(TEST_CLOUD_ID, switches);
-    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
-
-    ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, false);
-    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
-
-    auto rdbServiceImpl = std::make_shared<DistributedRdb::RdbServiceImpl>();
-    DistributedRdb::RdbSyncerParam param;
-    param.bundleName_ = TEST_CLOUD_BUNDLE;
-    param.storeName_ = TEST_CLOUD_DATABASE_ALIAS_1;
-    DistributedRdb::RdbService::Option option;
-    option.mode = DistributedRdb::SyncMode::CLOUD_FIRST;
-    option.isAutoSync = true;
-    option.isAsync = false;
-    DistributedRdb::PredicatesMemo memo;
-    rdbServiceImpl->Sync(param, option, memo, nullptr);
-
+    CloudInfo info;
+    MetaDataManager::GetInstance().LoadMeta(cloudInfo_.GetKey(), info, true);
+    info.apps[TEST_CLOUD_BUNDLE].cloudSwitch = false;
+    MetaDataManager::GetInstance().SaveMeta(info.GetKey(), info, true);
+    cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
     sleep(1);
 
     auto [status, result] =
@@ -512,5 +517,1458 @@ HWTEST_F(CloudDataTest, QueryLastSyncInfo005, TestSize.Level0)
     EXPECT_TRUE(!result.empty());
     EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code = E_CLOUD_DISABLED);
 }
+
+/**
+* @tc.name: QueryLastSyncInfo006
+* @tc.desc: The query last sync info interface failed when schema is invalid.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, QueryLastSyncInfo006, TestSize.Level0)
+{
+    ZLOGI("CloudDataTest QueryLastSyncInfo006 start");
+    MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
+    auto [status, result] =
+        cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+    EXPECT_TRUE(result.empty());
+    SchemaMeta meta;
+    meta.bundleName = "test";
+    MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), meta, true);
+    std::tie(status, result) =
+        cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+    EXPECT_TRUE(result.empty());
+}
+
+/**
+* @tc.name: Share
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Share001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    CloudData::Participants participants{};
+    CloudData::Results results;
+    auto ret = cloudServiceImpl_->Share(sharingRes, participants, results);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: Unshare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Unshare001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    CloudData::Participants participants{};
+    CloudData::Results results;
+    auto ret = cloudServiceImpl_->Unshare(sharingRes, participants, results);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: ChangePrivilege
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, ChangePrivilege001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    CloudData::Participants participants{};
+    CloudData::Results results;
+    auto ret = cloudServiceImpl_->ChangePrivilege(sharingRes, participants, results);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: ChangeConfirmation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, ChangeConfirmation001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    int32_t confirmation = 0;
+    std::pair<int32_t, std::string> result;
+    auto ret = cloudServiceImpl_->ChangeConfirmation(sharingRes, confirmation, result);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: ConfirmInvitation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, ConfirmInvitation001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    int32_t confirmation = 0;
+    std::tuple<int32_t, std::string, std::string> result;
+    auto ret = cloudServiceImpl_->ConfirmInvitation(sharingRes, confirmation, result);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: Exit
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Exit001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    std::pair<int32_t, std::string> result;
+    auto ret = cloudServiceImpl_->Exit(sharingRes, result);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: Query
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Query001, TestSize.Level0)
+{
+    std::string sharingRes = "";
+    CloudData::QueryResults result;
+    auto ret = cloudServiceImpl_->Query(sharingRes, result);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: QueryByInvitation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, QueryByInvitation001, TestSize.Level0)
+{
+    std::string invitation = "";
+    CloudData::QueryResults result;
+    auto ret = cloudServiceImpl_->QueryByInvitation(invitation, result);
+    EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
+}
+
+/**
+* @tc.name: AllocResourceAndShare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, AllocResourceAndShare001, TestSize.Level0)
+{
+    DistributedRdb::PredicatesMemo predicates;
+    predicates.tables_.push_back(TEST_CLOUD_BUNDLE);
+    std::vector<std::string> columns;
+    CloudData::Participants participants;
+    auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
+    EXPECT_EQ(ret, E_ERROR);
+    EventCenter::GetInstance().Subscribe(CloudEvent::MAKE_QUERY, [](const Event& event) {
+        auto& evt = static_cast<const DistributedData::MakeQueryEvent&>(event);
+        auto callback = evt.GetCallback();
+        if (!callback) {
+            return;
+        }
+        auto predicate = evt.GetPredicates();
+        auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
+        rdbQuery->MakeQuery(*predicate);
+        rdbQuery->SetColumns(evt.GetColumns());
+        callback(rdbQuery);
+    });
+    std::tie(ret, _) = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
+    EXPECT_EQ(ret, E_ERROR);
+}
+
+/**
+* @tc.name: SetGlobalCloudStrategy
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SetGlobalCloudStrategy001, TestSize.Level0)
+{
+    std::vector<CommonType::Value> values;
+    values.push_back(CloudData::NetWorkStrategy::WIFI);
+    CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
+    auto ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    strategy = CloudData::Strategy::STRATEGY_NETWORK;
+    ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: SetCloudStrategy
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SetCloudStrategy001, TestSize.Level0)
+{
+    std::vector<CommonType::Value> values;
+    values.push_back(CloudData::NetWorkStrategy::WIFI);
+    CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
+    auto ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    strategy = CloudData::Strategy::STRATEGY_NETWORK;
+    ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: Clean
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Clean001, TestSize.Level0)
+{
+    std::map<std::string, int32_t> actions;
+    actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_BUTT);
+    std::string id = "testId";
+    std::string bundleName = "testBundleName";
+    auto ret = cloudServiceImpl_->Clean(id, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::ERROR);
+    ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::ERROR);
+    actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
+    actions.insert_or_assign(bundleName, CloudData::CloudService::Action::CLEAR_CLOUD_DATA_AND_INFO);
+    ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: Clean
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Clean002, TestSize.Level0)
+{
+    MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
+    std::map<std::string, int32_t> actions;
+    actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
+    auto ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    StoreMetaDataLocal localMeta;
+    localMeta.isPublic = false;
+    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
+    ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    localMeta.isPublic = true;
+    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
+    ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    metaData_.user = "0";
+    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
+    ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
+    metaData_.user = std::to_string(DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
+    MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true);
+}
+
+/**
+* @tc.name: NotifyDataChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, NotifyDataChange001, TestSize.Level0)
+{
+    auto ret = cloudServiceImpl_->NotifyDataChange(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: NotifyDataChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, NotifyDataChange002, TestSize.Level0)
+{
+    constexpr const int32_t invalidUserId = -1;
+    std::string extraData;
+    auto ret = cloudServiceImpl_->NotifyDataChange("", extraData, invalidUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    extraData = "{data:test}";
+    ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    extraData = "{\"data\":\"{\\\"accountId\\\":\\\"id\\\",\\\"bundleName\\\":\\\"test_cloud_"
+                "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
+                "\\\"[\\\\\\\"private\\\\\\\", "
+                "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
+    ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"cloud_"
+                "bundleName_test\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
+                "\\\"databaseScopes\\\": "
+                "\\\"[\\\\\\\"private\\\\\\\", "
+                "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
+    ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+}
+
+/**
+* @tc.name: NotifyDataChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, NotifyDataChange003, TestSize.Level0)
+{
+    constexpr const int32_t userId = 100;
+    constexpr const int32_t defaultUserId = 0;
+    std::string extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
+                            "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
+                            "\\\"databaseScopes\\\": "
+                            "\\\"[\\\\\\\"private\\\\\\\", "
+                            "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"\\\\\\\"]\\\"}\"}";
+    auto ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, defaultUserId);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
+                "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
+                "\\\"[\\\\\\\"private\\\\\\\", "
+                "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
+    ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, userId);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: OnReady
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnReady001, TestSize.Level0)
+{
+    std::string device = "test";
+    auto ret = cloudServiceImpl_->OnReady(device);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    ret = cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: Offline
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, Offline001, TestSize.Level0)
+{
+    std::string device = "test";
+    auto ret = cloudServiceImpl_->Offline(device);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+    ret = cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: CloudShare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, CloudShare001, TestSize.Level0)
+{
+    ZLOGI("weisx CloudShare start");
+    StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
+    std::pair<int32_t, std::shared_ptr<Cursor>> result;
+    CloudShareEvent::Callback asyncCallback = [&result](int32_t status, std::shared_ptr<Cursor> cursor) {
+        result.first = status;
+        result.second = cursor;
+    };
+    auto event = std::make_unique<CloudShareEvent>(storeInfo, nullptr, nullptr);
+    EventCenter::GetInstance().PostEvent(std::move(event));
+    auto event1 = std::make_unique<CloudShareEvent>(storeInfo, nullptr, asyncCallback);
+    EventCenter::GetInstance().PostEvent(std::move(event1));
+    EXPECT_EQ(result.first, GeneralError::E_ERROR);
+    auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
+    auto event2 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, nullptr);
+    EventCenter::GetInstance().PostEvent(std::move(event2));
+    auto event3 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, asyncCallback);
+    EventCenter::GetInstance().PostEvent(std::move(event3));
+    EXPECT_EQ(result.first, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: OnUserChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnUserChange001, TestSize.Level0)
+{
+    constexpr const uint32_t ACCOUNT_DEFAULT = 2;
+    constexpr const uint32_t ACCOUNT_DELETE = 3;
+    constexpr const uint32_t ACCOUNT_SWITCHED = 4;
+    constexpr const uint32_t ACCOUNT_UNLOCKED = 5;
+    auto ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DEFAULT, "0", "test");
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DELETE, "0", "test");
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = cloudServiceImpl_->OnUserChange(ACCOUNT_SWITCHED, "0", "test");
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = cloudServiceImpl_->OnUserChange(ACCOUNT_UNLOCKED, "0", "test");
+    EXPECT_EQ(ret, GeneralError::E_OK);
+}
+
+/**
+* @tc.name: DisableCloud
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, DisableCloud001, TestSize.Level0)
+{
+    auto ret = cloudServiceImpl_->DisableCloud("test");
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: ChangeAppSwitch
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, ChangeAppSwitch, TestSize.Level0)
+{
+    std::string id = "testId";
+    std::string bundleName = "testName";
+    auto ret = cloudServiceImpl_->ChangeAppSwitch(id, bundleName, CloudData::CloudService::SWITCH_ON);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, bundleName, CloudData::CloudService::SWITCH_ON);
+    EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
+    ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_OFF);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: EnableCloud
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, EnableCloud, TestSize.Level0)
+{
+    std::string bundleName = "testName";
+    std::map<std::string, int32_t> switches;
+    switches.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
+    switches.insert_or_assign(bundleName, CloudData::CloudService::SWITCH_ON);
+    auto ret = cloudServiceImpl_->EnableCloud(TEST_CLOUD_ID, switches);
+    EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
+}
+
+/**
+* @tc.name: OnEnableCloud
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnEnableCloud, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string id = "testId";
+    std::map<std::string, int32_t> switches;
+    ITypesUtil::Marshal(data, id, switches);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnDisableCloud
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnDisableCloud, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnChangeAppSwitch
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnChangeAppSwitch, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    data.WriteString(TEST_CLOUD_BUNDLE);
+    data.WriteInt32(CloudData::CloudService::SWITCH_ON);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnClean
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnClean, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string id = TEST_CLOUD_ID;
+    std::map<std::string, int32_t> actions;
+    ITypesUtil::Marshal(data, id, actions);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnNotifyDataChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnNotifyDataChange, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    data.WriteString(TEST_CLOUD_BUNDLE);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnNotifyChange
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnNotifyChange, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    data.WriteString(TEST_CLOUD_BUNDLE);
+    int32_t userId = 100;
+    data.WriteInt32(userId);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnQueryStatistics
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnQueryStatistics, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    data.WriteString(TEST_CLOUD_BUNDLE);
+    data.WriteString(TEST_CLOUD_STORE);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnQueryLastSyncInfo
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnQueryLastSyncInfo, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    data.WriteString(TEST_CLOUD_ID);
+    data.WriteString(TEST_CLOUD_BUNDLE);
+    data.WriteString(TEST_CLOUD_STORE);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnSetGlobalCloudStrategy
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnSetGlobalCloudStrategy, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret =
+        cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    uint32_t strategy = 0;
+    std::vector<CommonType::Value> values;
+    ITypesUtil::Marshal(data, strategy, values);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnAllocResourceAndShare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnAllocResourceAndShare, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string storeId = "storeId";
+    DistributedRdb::PredicatesMemo predicates;
+    std::vector<std::string> columns;
+    std::vector<CloudData::Participant> participants;
+    ITypesUtil::Marshal(data, storeId, predicates, columns, participants);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnShare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnShare, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    ITypesUtil::Marshal(data, sharingRes, participants, results);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnUnshare
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnUnshare, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    ITypesUtil::Marshal(data, sharingRes, participants, results);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnExit
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnExit, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    std::pair<int32_t, std::string> result;
+    ITypesUtil::Marshal(data, sharingRes, result);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnChangePrivilege
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnChangePrivilege, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    ITypesUtil::Marshal(data, sharingRes, participants, results);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnQuery
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnQuery, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    CloudData::QueryResults results;
+    ITypesUtil::Marshal(data, sharingRes, results);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnQueryByInvitation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnQueryByInvitation, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string invitation;
+    CloudData::QueryResults results;
+    ITypesUtil::Marshal(data, invitation, results);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnConfirmInvitation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnConfirmInvitation, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string invitation;
+    int32_t confirmation = 0;
+    std::tuple<int32_t, std::string, std::string> result;
+    ITypesUtil::Marshal(data, invitation, confirmation, result);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnChangeConfirmation
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnChangeConfirmation, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    std::string sharingRes;
+    int32_t confirmation = 0;
+    std::pair<int32_t, std::string> result;
+    ITypesUtil::Marshal(data, sharingRes, confirmation, result);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: OnSetCloudStrategy
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnSetCloudStrategy, TestSize.Level0)
+{
+    MessageParcel reply;
+    MessageParcel data;
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
+    EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
+    data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
+    uint32_t strategy = 0;
+    std::vector<CommonType::Value> values;
+    ITypesUtil::Marshal(data, strategy, values);
+    ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
+    EXPECT_EQ(ret, ERR_NONE);
+}
+
+/**
+* @tc.name: SharingUtil001
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SharingUtil001, TestSize.Level0)
+{
+    auto cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNKNOWN);
+    EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
+    cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_ACCEPTED);
+    EXPECT_EQ(cfm, SharingCfm::CFM_ACCEPTED);
+    cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_REJECTED);
+    EXPECT_EQ(cfm, SharingCfm::CFM_REJECTED);
+    cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_SUSPENDED);
+    EXPECT_EQ(cfm, SharingCfm::CFM_SUSPENDED);
+    cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNAVAILABLE);
+    EXPECT_EQ(cfm, SharingCfm::CFM_UNAVAILABLE);
+    cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_BUTT);
+    EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
+}
+
+/**
+* @tc.name: SharingUtil002
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SharingUtil002, TestSize.Level0)
+{
+    auto cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNKNOWN);
+    EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
+    cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_ACCEPTED);
+    EXPECT_EQ(cfm, Confirmation::CFM_ACCEPTED);
+    cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_REJECTED);
+    EXPECT_EQ(cfm, Confirmation::CFM_REJECTED);
+    cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_SUSPENDED);
+    EXPECT_EQ(cfm, Confirmation::CFM_SUSPENDED);
+    cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNAVAILABLE);
+    EXPECT_EQ(cfm, Confirmation::CFM_UNAVAILABLE);
+    cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_BUTT);
+    EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
+}
+
+/**
+* @tc.name: SharingUtil003
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SharingUtil003, TestSize.Level0)
+{
+    auto status = CloudData::SharingUtil::Convert(CenterCode::IPC_ERROR);
+    EXPECT_EQ(status, Status::IPC_ERROR);
+    status = CloudData::SharingUtil::Convert(CenterCode::NOT_SUPPORT);
+    EXPECT_EQ(status, Status::SUCCESS);
+}
+
+/**
+* @tc.name: SharingUtil004
+* @tc.desc:
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SharingUtil004, TestSize.Level0)
+{
+    auto status = CloudData::SharingUtil::Convert(GenErr::E_OK);
+    EXPECT_EQ(status, Status::SUCCESS);
+    status = CloudData::SharingUtil::Convert(GenErr::E_ERROR);
+    EXPECT_EQ(status, Status::ERROR);
+    status = CloudData::SharingUtil::Convert(GenErr::E_INVALID_ARGS);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+    status = CloudData::SharingUtil::Convert(GenErr::E_BLOCKED_BY_NETWORK_STRATEGY);
+    EXPECT_EQ(status, Status::STRATEGY_BLOCKING);
+    status = CloudData::SharingUtil::Convert(GenErr::E_CLOUD_DISABLED);
+    EXPECT_EQ(status, Status::CLOUD_DISABLE);
+    status = CloudData::SharingUtil::Convert(GenErr::E_NETWORK_ERROR);
+    EXPECT_EQ(status, Status::NETWORK_ERROR);
+    status = CloudData::SharingUtil::Convert(GenErr::E_BUSY);
+    EXPECT_EQ(status, Status::ERROR);
+}
+
+/**
+* @tc.name: DoCloudSync
+* @tc.desc: Test the executor_ uninitialized and initialized scenarios
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, DoCloudSync, TestSize.Level0)
+{
+    int32_t user = 100;
+    CloudData::SyncManager sync;
+    CloudData::SyncManager::SyncInfo info(user);
+    auto ret = sync.DoCloudSync(info);
+    EXPECT_EQ(ret, GenErr::E_NOT_INIT);
+    ret = sync.StopCloudSync(user);
+    EXPECT_EQ(ret, GenErr::E_NOT_INIT);
+    size_t max = 12;
+    size_t min = 5;
+    sync.executor_ = std::make_shared<ExecutorPool>(max, min);
+    ret = sync.DoCloudSync(info);
+    EXPECT_EQ(ret, GenErr::E_OK);
+    int32_t invalidUser = -1;
+    sync.StopCloudSync(invalidUser);
+    ret = sync.StopCloudSync(user);
+    EXPECT_EQ(ret, GenErr::E_OK);
+}
+
+/**
+* @tc.name: GetPostEventTask
+* @tc.desc: Test the interface to verify the package name and table name
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetPostEventTask, TestSize.Level0)
+{
+    std::vector<SchemaMeta> schemas;
+    schemaMeta_.databases[0].name = "test";
+    schemas.push_back(schemaMeta_);
+    schemaMeta_.bundleName = "test";
+    schemas.push_back(schemaMeta_);
+
+    int32_t user = 100;
+    CloudData::SyncManager::SyncInfo info(user);
+    std::vector<std::string> value;
+    info.tables_.insert_or_assign(TEST_CLOUD_STORE, value);
+
+    CloudData::SyncManager sync;
+    auto task = sync.GetPostEventTask(schemas, cloudInfo_, info, true);
+    auto ret = task();
+    EXPECT_TRUE(ret);
+}
+
+/**
+* @tc.name: GetRetryer
+* @tc.desc: Test the input parameters of different interfaces
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetRetryer, TestSize.Level0)
+{
+    int32_t user = 100;
+    CloudData::SyncManager::SyncInfo info(user);
+    CloudData::SyncManager sync;
+    CloudData::SyncManager::Duration duration;
+    auto ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info)(duration, E_OK, E_OK);
+    EXPECT_TRUE(ret);
+    ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info)(duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED);
+    EXPECT_TRUE(ret);
+    ret = sync.GetRetryer(0, info)(duration, E_OK, E_OK);
+    EXPECT_TRUE(ret);
+    ret = sync.GetRetryer(0, info)(duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED);
+    EXPECT_TRUE(ret);
+}
+
+/**
+* @tc.name: GetCallback
+* @tc.desc: Test the processing logic of different progress callbacks
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetCallback, TestSize.Level0)
+{
+    int32_t user = 100;
+    CloudData::SyncManager::SyncInfo info(user);
+    CloudData::SyncManager sync;
+    DistributedData::GenDetails result;
+    StoreInfo storeInfo;
+    storeInfo.user = user;
+    storeInfo.bundleName = "testBundleName";
+    int32_t triggerMode = MODE_DEFAULT;
+    GenAsync async = nullptr;
+    sync.GetCallback(async, storeInfo, triggerMode)(result);
+    int32_t process = 0;
+    async = [&process](const GenDetails &details) { process = details.begin()->second.progress; };
+    GenProgressDetail detail;
+    detail.progress = GenProgress::SYNC_IN_PROGRESS;
+    result.insert_or_assign("test", detail);
+    sync.GetCallback(async, storeInfo, triggerMode)(result);
+    EXPECT_EQ(process, GenProgress::SYNC_IN_PROGRESS);
+    detail.progress = GenProgress::SYNC_FINISH;
+    result.insert_or_assign("test", detail);
+    storeInfo.user = -1;
+    sync.GetCallback(async, storeInfo, triggerMode)(result);
+    storeInfo.user = user;
+    sync.GetCallback(async, storeInfo, triggerMode)(result);
+    EXPECT_EQ(process, GenProgress::SYNC_FINISH);
+}
+
+/**
+* @tc.name: GetInterval
+* @tc.desc: Test the Interval transformation logic of the interface
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetInterval, TestSize.Level0)
+{
+    CloudData::SyncManager sync;
+
+    auto ret = sync.GetInterval(E_LOCKED_BY_OTHERS);
+    EXPECT_EQ(ret, CloudData::SyncManager::LOCKED_INTERVAL);
+    ret = sync.GetInterval(E_BUSY);
+    EXPECT_EQ(ret, CloudData::SyncManager::BUSY_INTERVAL);
+    ret = sync.GetInterval(E_OK);
+    EXPECT_EQ(ret, CloudData::SyncManager::RETRY_INTERVAL);
+}
+
+/**
+* @tc.name: GetCloudSyncInfo
+* @tc.desc: Test get cloudInfo
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetCloudSyncInfo, TestSize.Level0)
+{
+    CloudData::SyncManager sync;
+    CloudInfo cloud;
+    cloud.user = cloudInfo_.user;
+    cloud.enableCloud = false;
+    CloudData::SyncManager::SyncInfo info(cloudInfo_.user);
+    MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
+    info.bundleName_ = "test";
+    auto ret = sync.GetCloudSyncInfo(info, cloud);
+    EXPECT_TRUE(!ret.empty());
+}
+
+/**
+* @tc.name: RetryCallback
+* @tc.desc: Test the retry logic
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, RetryCallback, TestSize.Level0)
+{
+    CloudData::SyncManager sync;
+    StoreInfo storeInfo;
+    int32_t retCode = -1;
+    CloudData::SyncManager::Retryer retry = [&retCode](CloudData::SyncManager::Duration interval, int32_t code,
+                                                int32_t dbCode) {
+        retCode = code;
+        return true;
+    };
+    DistributedData::GenDetails result;
+    auto task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT);
+    task(result);
+    GenProgressDetail detail;
+    detail.progress = GenProgress::SYNC_IN_PROGRESS;
+    detail.code = 100;
+    result.insert_or_assign("test", detail);
+    task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT);
+    task(result);
+    EXPECT_EQ(retCode, detail.code);
+}
+
+/**
+* @tc.name: UpdateCloudInfoFromServer
+* @tc.desc: Test updating cloudinfo from the server
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, UpdateCloudInfoFromServer, TestSize.Level0)
+{
+    auto ret = cloudServiceImpl_->UpdateCloudInfoFromServer(cloudInfo_.user);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+* @tc.name: GetCloudInfo
+* @tc.desc: Test get cloudInfo
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetCloudInfo, TestSize.Level0)
+{
+    MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
+    auto ret = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
+    EXPECT_EQ(ret.first, CloudData::SUCCESS);
+}
+
+/**
+* @tc.name: SubTask
+* @tc.desc: Test the subtask execution logic
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, SubTask, TestSize.Level0)
+{
+    DistributedData::Subscription sub;
+    cloudServiceImpl_->InitSubTask(sub, 0);
+    MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(cloudInfo_.user), sub, true);
+    cloudServiceImpl_->InitSubTask(sub, 0);
+    int32_t userId = 0;
+    CloudData::CloudServiceImpl::Task task = [&userId]() { userId = cloudInfo_.user; };
+    cloudServiceImpl_->GenSubTask(task, cloudInfo_.user)();
+    EXPECT_EQ(userId, cloudInfo_.user);
+}
+
+/**
+* @tc.name: ConvertCursor
+* @tc.desc: Test the cursor conversion logic when the ResultSet is empty and non-null
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, ConvertCursor, TestSize.Level0)
+{
+    std::map<std::string, DistributedData::Value> entry;
+    entry.insert_or_assign("test", "entry");
+    auto resultSet = std::make_shared<CursorMock::ResultSet>(1, entry);
+    auto cursor = std::make_shared<CursorMock>(resultSet);
+    auto result = cloudServiceImpl_->ConvertCursor(cursor);
+    EXPECT_TRUE(!result.empty());
+    auto resultSet1 = std::make_shared<CursorMock::ResultSet>();
+    auto cursor1 = std::make_shared<CursorMock>(resultSet1);
+    auto result1 = cloudServiceImpl_->ConvertCursor(cursor1);
+    EXPECT_TRUE(result1.empty());
+}
+
+/**
+* @tc.name: GetDbInfoFromExtraData
+* @tc.desc: Test the GetDbInfoFromExtraData function input parameters of different parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetDbInfoFromExtraData, TestSize.Level0)
+{
+    SchemaMeta::Database database;
+    database.name = TEST_CLOUD_STORE;
+    database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
+
+    SchemaMeta schemaMeta;
+    schemaMeta.databases.push_back(database);
+
+    SchemaMeta::Table table;
+    table.name = "test_cloud_table_name";
+    table.alias = "test_cloud_table_alias";
+    database.tables.push_back(table);
+    SchemaMeta::Table table1;
+    table1.name = "test_cloud_table_name1";
+    table1.alias = "test_cloud_table_alias1";
+    table1.sharedTableName = "test_share_table_name1";
+    database.tables.emplace_back(table1);
+
+    database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
+    schemaMeta.databases.push_back(database);
+
+    ExtraData extraData;
+    extraData.info.containerName = TEST_CLOUD_DATABASE_ALIAS_2;
+    auto result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
+    EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
+
+    std::string tableName = "test_cloud_table_alias2";
+    extraData.info.tables.emplace_back(tableName);
+    result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
+    EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
+
+    std::string tableName1 = "test_cloud_table_alias1";
+    extraData.info.tables.emplace_back(tableName1);
+    extraData.info.scopes.emplace_back(DistributedData::ExtraData::SHARED_TABLE);
+    result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
+    EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
+}
+
+/**
+* @tc.name: QueryTableStatistic
+* @tc.desc: Test the QueryTableStatistic function input parameters of different parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, QueryTableStatistic, TestSize.Level0)
+{
+    auto store = std::make_shared<GeneralStoreMock>();
+    if (store != nullptr) {
+        std::map<std::string, Value> entry = { { "inserted", "TEST" }, { "updated", "TEST" }, { "normal", "TEST" } };
+        store->MakeCursor(entry);
+    }
+    auto [ret, result] = cloudServiceImpl_->QueryTableStatistic("test", store);
+    EXPECT_TRUE(ret);
+    if (store != nullptr) {
+        std::map<std::string, Value> entry = { { "Test", 1 } };
+        store->MakeCursor(entry);
+    }
+    std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
+    EXPECT_TRUE(ret);
+
+    if (store != nullptr) {
+        store->cursor_ = nullptr;
+    }
+    std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
+    EXPECT_FALSE(ret);
+}
+
+/**
+* @tc.name: GetSchemaMeta
+* @tc.desc: Test the GetSchemaMeta function input parameters of different parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetSchemaMeta, TestSize.Level0)
+{
+    int32_t userId = 101;
+    int32_t instanceId = 0;
+    CloudInfo cloudInfo;
+    cloudInfo.user = userId;
+    cloudInfo.id = TEST_CLOUD_ID;
+    cloudInfo.enableCloud = true;
+
+    CloudInfo::AppInfo appInfo;
+    appInfo.bundleName = TEST_CLOUD_BUNDLE;
+    appInfo.appId = TEST_CLOUD_APPID;
+    appInfo.version = 1;
+    appInfo.cloudSwitch = true;
+
+    cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
+    MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
+    std::string bundleName = "testName";
+    auto [status, meta] = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+    bundleName = TEST_CLOUD_BUNDLE;
+    DistributedData::SchemaMeta schemeMeta;
+    schemeMeta.bundleName = TEST_CLOUD_BUNDLE;
+    schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION + 1;
+    MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
+    std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+    schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION;
+    MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
+    std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+    EXPECT_EQ(meta.metaVersion, DistributedData::SchemaMeta::CURRENT_VERSION);
+    MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), true);
+    MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true);
+}
+
+/**
+* @tc.name: GetAppSchemaFromServer
+* @tc.desc: Test the GetAppSchemaFromServer function input parameters of different parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetAppSchemaFromServer, TestSize.Level0)
+{
+    int32_t userId = CloudServerMock::INVALID_USER_ID;
+    std::string bundleName;
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::NONE);
+    DeviceManagerAdapter::GetInstance().expireTime_ =
+        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch())
+            .count() +
+        1000;
+    auto [status, meta] = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
+    EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
+    std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
+    EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
+    userId = 100;
+    std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
+    EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
+    bundleName = TEST_CLOUD_BUNDLE;
+    std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
+    EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
+    EXPECT_EQ(meta.bundleName, schemaMeta_.bundleName);
+}
+
+/**
+* @tc.name: OnAppUninstall
+* @tc.desc: Test the OnAppUninstall function delete the subscription data
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, OnAppUninstall, TestSize.Level0)
+{
+    ZLOGI("weisx test OnAppUninstall 111");
+    CloudData::CloudServiceImpl::CloudStatic cloudStatic;
+    int32_t userId = 1001;
+    Subscription sub;
+    sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, 0);
+    MetaDataManager::GetInstance().SaveMeta(Subscription::GetKey(userId), sub, true);
+    CloudInfo cloudInfo;
+    cloudInfo.user = userId;
+    CloudInfo::AppInfo appInfo;
+    cloudInfo.apps.insert_or_assign(TEST_CLOUD_BUNDLE, appInfo);
+    MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
+    int32_t index = 1;
+    auto ret = cloudStatic.OnAppUninstall(TEST_CLOUD_BUNDLE, userId, index);
+    EXPECT_EQ(ret, E_OK);
+    Subscription sub1;
+    EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(userId), sub1, true));
+    EXPECT_EQ(sub1.expiresTime.size(), 0);
+}
+
+/**
+* @tc.name: GetCloudInfo
+* @tc.desc: Test the GetCloudInfo with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, GetCloudInfo001, TestSize.Level0)
+{
+    ZLOGI("weisx test OnAppUninstall 111");
+    int32_t userId = 1000;
+    auto [status, cloudInfo] = cloudServiceImpl_->GetCloudInfo(userId);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::NONE);
+    DeviceManagerAdapter::GetInstance().expireTime_ =
+        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch())
+            .count() +
+        1000;
+    MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
+    std::tie(status, cloudInfo) = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
+    EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
+}
+
+/**
+* @tc.name: PreShare
+* @tc.desc: Test the PreShare with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, PreShare, TestSize.Level0)
+{
+    int32_t userId = 1000;
+    StoreInfo info;
+    info.instanceId = 0;
+    info.bundleName = TEST_CLOUD_BUNDLE;
+    info.storeName = TEST_CLOUD_BUNDLE;
+    info.user = userId;
+    StoreMetaData meta(info);
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true);
+    DistributedRdb::RdbQuery query;
+    auto [status, cursor] = cloudServiceImpl_->PreShare(info, query);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: InitSubTask
+* @tc.desc: Test the InitSubTask with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, InitSubTask, TestSize.Level0)
+{
+    uint64_t minInterval = 0;
+    uint64_t expire = 24 * 60 * 60 * 1000; // 24hours, ms
+    ExecutorPool::TaskId taskId = 100;
+    Subscription sub;
+    sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
+    std::shared_ptr<ExecutorPool> executor = std::move(cloudServiceImpl_->executor_);
+    cloudServiceImpl_->executor_ = nullptr;
+    cloudServiceImpl_->InitSubTask(sub, minInterval);
+    EXPECT_EQ(sub.GetMinExpireTime(), expire);
+    cloudServiceImpl_->executor_ = std::move(executor);
+    cloudServiceImpl_->subTask_ = taskId;
+    cloudServiceImpl_->InitSubTask(sub, minInterval);
+    EXPECT_NE(cloudServiceImpl_->subTask_, taskId);
+    cloudServiceImpl_->subTask_ = taskId;
+    cloudServiceImpl_->expireTime_ = 0;
+    cloudServiceImpl_->InitSubTask(sub, minInterval);
+    EXPECT_EQ(cloudServiceImpl_->subTask_, taskId);
+    cloudServiceImpl_->subTask_ = ExecutorPool::INVALID_TASK_ID;
+    cloudServiceImpl_->InitSubTask(sub, minInterval);
+    EXPECT_NE(cloudServiceImpl_->subTask_, ExecutorPool::INVALID_TASK_ID);
+}
+
+/**
+* @tc.name: DoSubscribe
+* @tc.desc: Test DoSubscribe functions with invalid parameter.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudDataTest, DoSubscribe, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest DoSubscribe start");
+    Subscription sub;
+    sub.userId = cloudInfo_.user;
+    MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
+    int user = cloudInfo_.user;
+    auto status = cloudServiceImpl_->DoSubscribe(user);
+    EXPECT_FALSE(status);
+    sub.id = "testId";
+    MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
+    status = cloudServiceImpl_->DoSubscribe(user);
+    EXPECT_FALSE(status);
+    sub.id = TEST_CLOUD_APPID;
+    MetaDataManager::GetInstance().SaveMeta(sub.GetKey(), sub, true);
+    status = cloudServiceImpl_->DoSubscribe(user);
+    EXPECT_FALSE(status);
+    MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
+    status = cloudServiceImpl_->DoSubscribe(user);
+    EXPECT_FALSE(status);
+}
 } // namespace DistributedDataTest
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/datamgr_service/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..16c3bc7a1499af99c1ebe2c451b0f038f0fb8d2b
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
@@ -0,0 +1,488 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#define LOG_TAG "CloudServiceImplTest"
+#include "cloud_service_impl.h"
+
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "accesstoken_kit.h"
+#include "account/account_delegate.h"
+#include "bootstrap.h"
+#include "checker_mock.h"
+#include "cloud/change_event.h"
+#include "cloud/cloud_event.h"
+#include "cloud/cloud_server.h"
+#include "cloud/cloud_share_event.h"
+#include "cloud/schema_meta.h"
+#include "cloud_types.h"
+#include "cloud_types_util.h"
+#include "cloud_value_util.h"
+#include "communicator/device_manager_adapter.h"
+#include "device_matrix.h"
+#include "eventcenter/event_center.h"
+#include "feature/feature_system.h"
+#include "ipc_skeleton.h"
+#include "log_print.h"
+#include "metadata/meta_data_manager.h"
+#include "metadata/store_meta_data.h"
+#include "metadata/store_meta_data_local.h"
+#include "mock/db_store_mock.h"
+#include "mock/general_store_mock.h"
+#include "rdb_query.h"
+#include "rdb_service.h"
+#include "rdb_service_impl.h"
+#include "rdb_types.h"
+#include "store/auto_cache.h"
+#include "store/store_info.h"
+#include "token_setproc.h"
+
+using namespace testing::ext;
+using namespace OHOS::DistributedData;
+using namespace OHOS::Security::AccessToken;
+using Confirmation = OHOS::CloudData::Confirmation;
+using Status = OHOS::CloudData::CloudService::Status;
+
+namespace OHOS::Test {
+namespace DistributedDataTest {
+static constexpr const char *TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
+static constexpr const char *TEST_CLOUD_APPID = "test_cloud_appid";
+static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store";
+static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1";
+class CloudServiceImplTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+
+    static std::shared_ptr<CloudData::CloudServiceImpl> cloudServiceImpl_;
+};
+std::shared_ptr<CloudData::CloudServiceImpl> CloudServiceImplTest::cloudServiceImpl_ =
+    std::make_shared<CloudData::CloudServiceImpl>();
+
+void CloudServiceImplTest::SetUpTestCase(void)
+{
+    size_t max = 12;
+    size_t min = 5;
+    auto executor = std::make_shared<ExecutorPool>(max, min);
+    DeviceManagerAdapter::GetInstance().Init(executor);
+}
+
+void CloudServiceImplTest::TearDownTestCase()
+{
+}
+
+void CloudServiceImplTest::SetUp()
+{
+}
+
+void CloudServiceImplTest::TearDown()
+{
+}
+
+/**
+* @tc.name: EnableCloud001
+* @tc.desc: Test EnableCloud functions with user is invalid.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, EnableCloud001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest EnableCloud001 start");
+    std::map<std::string, int32_t> switches;
+    switches.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
+    auto status = cloudServiceImpl_->EnableCloud(TEST_CLOUD_APPID, switches);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: DisableCloud001
+* @tc.desc: Test DisableCloud functions with user is invalid.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, DisableCloud001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest DisableCloud001 start");
+    auto status = cloudServiceImpl_->DisableCloud(TEST_CLOUD_APPID);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: ChangeAppSwitch001
+* @tc.desc: Test ChangeAppSwitch functions with user is invalid.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ChangeAppSwitch001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest ChangeAppSwitch001 start");
+    auto status =
+        cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_APPID, TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: Clean001
+* @tc.desc: Test Clean functions with user is invalid.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, Clean001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest Clean001 start");
+    std::map<std::string, int32_t> actions;
+    actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
+    auto status = cloudServiceImpl_->Clean(TEST_CLOUD_APPID, actions);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: NotifyDataChange001
+* @tc.desc: Test the EnableCloud function in case it doesn't get cloudInfo.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, NotifyDataChange001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest NotifyDataChange001 start");
+    auto status = cloudServiceImpl_->NotifyDataChange(TEST_CLOUD_APPID, TEST_CLOUD_BUNDLE);
+    EXPECT_EQ(status, CloudData::CloudService::INVALID_ARGUMENT);
+}
+
+/**
+* @tc.name: ExecuteStatistics001
+* @tc.desc: Test the ExecuteStatistics function if the package name does not support CloudSync.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ExecuteStatistics001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest ExecuteStatistics001 start");
+    CloudInfo cloudInfo;
+    CloudInfo::AppInfo appInfo;
+    appInfo.bundleName = TEST_CLOUD_BUNDLE;
+    cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
+    SchemaMeta::Database database;
+    database.name = TEST_CLOUD_STORE;
+    database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
+    SchemaMeta schemaMeta;
+    schemaMeta.bundleName = "testBundle";
+    schemaMeta.databases.emplace_back(database);
+    auto result = cloudServiceImpl_->ExecuteStatistics("", cloudInfo, schemaMeta);
+    EXPECT_TRUE(result.empty());
+}
+
+/**
+* @tc.name: QueryStatistics001
+* @tc.desc: When metadata is not supported store test the QueryStatistics function.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, QueryStatistics001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest QueryStatistics start");
+    StoreMetaData metaData;
+    metaData.storeType = -1;
+    DistributedData::Database database;
+    auto result = cloudServiceImpl_->QueryStatistics(metaData, database);
+    EXPECT_TRUE(result.empty());
+}
+
+/**
+* @tc.name: QueryLastSyncInfo001
+* @tc.desc: Test QueryLastSyncInfo functions with invalid parameter.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, QueryLastSyncInfo001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest QueryLastSyncInfo start");
+    auto [status, result] = cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_APPID, TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+    EXPECT_TRUE(result.empty());
+}
+
+/**
+* @tc.name: OnBind001
+* @tc.desc: Test OnBind functions with invalid parameter.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, OnBind001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest OnBind001 start");
+    auto status = cloudServiceImpl_->OnBind({});
+    EXPECT_EQ(status, GeneralError::E_INVALID_ARGS);
+}
+
+/**
+* @tc.name: UpdateSchema001
+* @tc.desc: Test UpdateSchema001 functions with invalid parameter.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, UpdateSchema001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest UpdateSchema001 start");
+    int user = -1;
+    auto status = cloudServiceImpl_->UpdateSchema(user);
+    EXPECT_FALSE(status);
+}
+
+/**
+* @tc.name: GetAppSchemaFromServer001
+* @tc.desc: Test GetAppSchemaFromServer functions not support CloudService.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, GetAppSchemaFromServer001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest GetAppSchemaFromServer001 start");
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
+    int user = -1;
+    auto [status, result] = cloudServiceImpl_->GetAppSchemaFromServer(user, TEST_CLOUD_BUNDLE);
+    EXPECT_EQ(status, CloudData::CloudService::SERVER_UNAVAILABLE);
+}
+
+/**
+* @tc.name: GetCloudInfoFromServer001
+* @tc.desc: Test GetCloudInfoFromServer functions not support CloudService.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, GetCloudInfoFromServer001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest GetCloudInfoFromServer001 start");
+    DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
+    int user = -1;
+    auto [status, result] = cloudServiceImpl_->GetCloudInfoFromServer(user);
+    EXPECT_EQ(status, CloudData::CloudService::SERVER_UNAVAILABLE);
+}
+
+/**
+* @tc.name: ReleaseUserInfo001
+* @tc.desc: Test ReleaseUserInfo functions with invalid parameter.
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ReleaseUserInfo001, TestSize.Level0)
+{
+    ZLOGI("CloudServiceImplTest ReleaseUserInfo001 start");
+    int user = 100;
+    auto status = cloudServiceImpl_->ReleaseUserInfo(user);
+    EXPECT_TRUE(status);
+}
+
+/**
+* @tc.name: DoSubscribe
+* @tc.desc: Test the DoSubscribe with not support CloudService
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, DoSubscribe, TestSize.Level0)
+{
+    int32_t user = 100;
+    auto status = cloudServiceImpl_->DoSubscribe(user);
+    EXPECT_TRUE(status);
+}
+
+/**
+* @tc.name: Share001
+* @tc.desc: Test the Share with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, Share001, TestSize.Level0)
+{
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    auto status = cloudServiceImpl_->Share(sharingRes, participants, results);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: Unshare001
+* @tc.desc: Test the Unshare with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, Unshare001, TestSize.Level0)
+{
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    auto status = cloudServiceImpl_->Unshare(sharingRes, participants, results);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: Exit001
+* @tc.desc: Test the Exit with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, Exit001, TestSize.Level0)
+{
+    std::string sharingRes;
+    std::pair<int32_t, std::string> result;
+    auto status = cloudServiceImpl_->Exit(sharingRes, result);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: ChangePrivilege001
+* @tc.desc: Test the ChangePrivilege with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ChangePrivilege001, TestSize.Level0)
+{
+    std::string sharingRes;
+    CloudData::Participants participants;
+    CloudData::Results results;
+    auto status = cloudServiceImpl_->ChangePrivilege(sharingRes, participants, results);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: Query001
+* @tc.desc: Test the Query with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, Query001, TestSize.Level0)
+{
+    std::string sharingRes;
+    CloudData::QueryResults results;
+    auto status = cloudServiceImpl_->Query(sharingRes, results);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: QueryByInvitation001
+* @tc.desc: Test the QueryByInvitation with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, QueryByInvitation001, TestSize.Level0)
+{
+    std::string invitation;
+    CloudData::QueryResults results;
+    auto status = cloudServiceImpl_->QueryByInvitation(invitation, results);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: ConfirmInvitation001
+* @tc.desc: Test the ConfirmInvitation with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ConfirmInvitation001, TestSize.Level0)
+{
+    int32_t confirmation = 0;
+    std::tuple<int32_t, std::string, std::string> result{ 0, "", "" };
+    std::string invitation;
+    auto status = cloudServiceImpl_->ConfirmInvitation(invitation, confirmation, result);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: ChangeConfirmation001
+* @tc.desc: Test the ChangeConfirmation with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, ChangeConfirmation001, TestSize.Level0)
+{
+    int32_t confirmation = 0;
+    std::string sharingRes;
+    std::pair<int32_t, std::string> result;
+    auto status = cloudServiceImpl_->ChangeConfirmation(sharingRes, confirmation, result);
+    EXPECT_EQ(status, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: GetSharingHandle001
+* @tc.desc: Test the GetSharingHandle with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, GetSharingHandle001, TestSize.Level0)
+{
+    CloudData::CloudServiceImpl::HapInfo hapInfo;
+    auto status = cloudServiceImpl_->GetSharingHandle(hapInfo);
+    EXPECT_EQ(status, nullptr);
+}
+
+/**
+* @tc.name: SetCloudStrategy001
+* @tc.desc: Test the SetCloudStrategy with get hapInfo failed
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, SetCloudStrategy001, TestSize.Level0)
+{
+    CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_NETWORK;
+    std::vector<CommonType::Value> values;
+    values.push_back(CloudData::NetWorkStrategy::WIFI);
+
+    auto status = cloudServiceImpl_->SetCloudStrategy(strategy, values);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: SetGlobalCloudStrategy001
+* @tc.desc: Test the SetGlobalCloudStrategy with get hapInfo failed
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, SetGlobalCloudStrategy001, TestSize.Level0)
+{
+    CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_NETWORK;
+    std::vector<CommonType::Value> values;
+    values.push_back(CloudData::NetWorkStrategy::WIFI);
+
+    auto status = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
+    EXPECT_EQ(status, CloudData::CloudService::ERROR);
+}
+
+/**
+* @tc.name: CheckNotifyConditions001
+* @tc.desc: Test the CheckNotifyConditions with invalid parameters
+* @tc.type: FUNC
+* @tc.require:
+ */
+HWTEST_F(CloudServiceImplTest, CheckNotifyConditions, TestSize.Level0)
+{
+    CloudInfo cloudInfo;
+    cloudInfo.enableCloud = false;
+    cloudInfo.id = TEST_CLOUD_APPID;
+
+    auto status = cloudServiceImpl_->CheckNotifyConditions(TEST_CLOUD_APPID, TEST_CLOUD_BUNDLE, cloudInfo);
+    EXPECT_EQ(status, CloudData::CloudService::CLOUD_DISABLE);
+    cloudInfo.enableCloud = true;
+    CloudInfo::AppInfo appInfo;
+    appInfo.bundleName = TEST_CLOUD_BUNDLE;
+    appInfo.cloudSwitch = false;
+    cloudInfo.apps.insert_or_assign(TEST_CLOUD_BUNDLE, appInfo);
+    status = cloudServiceImpl_->CheckNotifyConditions(TEST_CLOUD_APPID, TEST_CLOUD_BUNDLE, cloudInfo);
+    EXPECT_EQ(status, CloudData::CloudService::CLOUD_DISABLE_SWITCH);
+}
+} // namespace DistributedDataTest
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/cloud_test.cpp b/datamgr_service/services/distributeddataservice/service/test/cloud_test.cpp
index 607179ab752c8f5ffca90d50e80653381ebd4197..e49c66ca9570cc4e9c025a2300896774cdb90e1f 100644
--- a/datamgr_service/services/distributeddataservice/service/test/cloud_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/cloud_test.cpp
@@ -35,8 +35,8 @@ public:
     void TearDown(){};
 
 protected:
-    static constexpr const char* testCloudBundle = "test_cloud_bundleName";
-    static constexpr const char* testCloudStore = "test_cloud_database_name";
+    static constexpr const char* TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
+    static constexpr const char* TEST_CLOUD_STORE = "test_cloud_database_name";
     static std::shared_ptr<DBStoreMock> dbStoreMock_;
 };
 std::shared_ptr<DBStoreMock> CloudTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
@@ -65,7 +65,7 @@ HWTEST_F(CloudTest, EventInfo, TestSize.Level1)
     SyncEvent::EventInfo eventInfo1(mode, wait, retry, query, async);
     SyncEvent::EventInfo eventInfo2(std::move(eventInfo1));
     SyncEvent::EventInfo eventInfo3 = std::move(eventInfo2);
-    StoreInfo storeInfo{ IPCSkeleton::GetCallingTokenID(), testCloudBundle, testCloudStore, 0 };
+    StoreInfo storeInfo{ IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
     SyncEvent evt(storeInfo, eventInfo3);
     EXPECT_EQ(evt.GetMode(), mode);
     EXPECT_EQ(evt.GetWait(), wait);
@@ -88,11 +88,11 @@ HWTEST_F(CloudTest, Serializable_Marshal, TestSize.Level1)
     EXPECT_EQ(false, ret);
 
     SchemaMeta::Database database;
-    database.name = testCloudStore;
+    database.name = TEST_CLOUD_STORE;
     database.alias = "database_alias_test";
 
     schemaMeta.version = 1;
-    schemaMeta.bundleName = testCloudBundle;
+    schemaMeta.bundleName = TEST_CLOUD_BUNDLE;
     schemaMeta.databases.emplace_back(database);
     ret = schemaMeta.IsValid();
     EXPECT_EQ(true, ret);
@@ -103,8 +103,12 @@ HWTEST_F(CloudTest, Serializable_Marshal, TestSize.Level1)
 
     EXPECT_EQ(schemaMeta.version, schemaMeta2.version);
     EXPECT_EQ(schemaMeta.bundleName, schemaMeta2.bundleName);
-    Database database2 = schemaMeta2.GetDataBase(testCloudStore);
+    Database database2 = schemaMeta2.GetDataBase(TEST_CLOUD_STORE);
     EXPECT_EQ(database.alias, database2.alias);
+
+    std::string storeId = "storeId";
+    Database database3 = schemaMeta2.GetDataBase(storeId);
+    EXPECT_NE(database.alias, database3.alias);
 }
 
 /**
@@ -149,7 +153,7 @@ HWTEST_F(CloudTest, Database_Marshal, TestSize.Level1)
     table2.alias = "test_cloud_table_alias2";
 
     SchemaMeta::Database database1;
-    database1.name = testCloudStore;
+    database1.name = TEST_CLOUD_STORE;
     database1.alias = "test_cloud_database_alias";
     database1.tables.emplace_back(table1);
     database1.tables.emplace_back(table2);
@@ -177,8 +181,9 @@ HWTEST_F(CloudTest, Database_Marshal, TestSize.Level1)
  */
 HWTEST_F(CloudTest, CloudInfoUpgrade, TestSize.Level0)
 {
+    int32_t defaultUser = 100;
     CloudInfo oldInfo;
-    auto user = DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
+    auto user = defaultUser;
     oldInfo.user = user;
     EXPECT_NE(oldInfo.maxNumber, CloudInfo::DEFAULT_BATCH_NUMBER);
     EXPECT_NE(oldInfo.maxSize, CloudInfo::DEFAULT_BATCH_SIZE);
diff --git a/datamgr_service/services/distributeddataservice/service/test/data_share_profile_config_test.cpp b/datamgr_service/services/distributeddataservice/service/test/data_share_profile_config_test.cpp
index 3c2ec549af5267aa48ca65c15b546d37dc3d0ea1..c8454845ddd875261ec074303e7433ccdd88296a 100644
--- a/datamgr_service/services/distributeddataservice/service/test/data_share_profile_config_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/data_share_profile_config_test.cpp
@@ -17,8 +17,6 @@
 #include <gtest/gtest.h>
 #include <unistd.h>
 
-#define private public
-#include "data_share_profile_config.h"
 #include "datashare_errno.h"
 #include "data_share_db_config.h"
 #include "data_share_profile_config.h"
@@ -49,18 +47,19 @@ public:
 HWTEST_F(DataShareProfileConfigTest, GetDbConfig, TestSize.Level1)
 {
     DataShareDbConfig dbConfig;
-    auto result = dbConfig.GetDbConfig("", false, "", "", 0);
+    DataShareDbConfig::DbConfig config {"", "", "", "", "", 0, false};
+    auto result = dbConfig.GetDbConfig(config);
     EXPECT_EQ(std::get<0>(result), NativeRdb::E_DB_NOT_EXIST);
 
-    bool hasExtension = true;
-    result = dbConfig.GetDbConfig("", hasExtension, "", "", 0);
+    config.hasExtension = true;
+    result = dbConfig.GetDbConfig(config);
     EXPECT_EQ(std::get<0>(result), NativeRdb::E_DB_NOT_EXIST);
 
-    std::string uri = DATA_SHARE_URI;
-    std::string bundleName = "bundleName";
-    std::string storeName = "storeName";
-    int32_t userId = USER_TEST;
-    result = dbConfig.GetDbConfig(uri, hasExtension, bundleName, storeName, userId);
+    config.uri = DATA_SHARE_URI;
+    config.bundleName = "bundleName";
+    config.storeName = "storeName";
+    config.userId = USER_TEST;
+    result = dbConfig.GetDbConfig(config);
     EXPECT_NE(std::get<0>(result), DataShare::E_OK);
 }
 
diff --git a/datamgr_service/services/distributeddataservice/service/test/data_share_service_impl_test.cpp b/datamgr_service/services/distributeddataservice/service/test/data_share_service_impl_test.cpp
index d86bd4aaa36b0307e03b0415014e6c7ae1469806..9d7648f9361bd661dcc43d4e6c48775b9d5273ce 100644
--- a/datamgr_service/services/distributeddataservice/service/test/data_share_service_impl_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/data_share_service_impl_test.cpp
@@ -16,7 +16,6 @@
 
 #include <gtest/gtest.h>
 #include <unistd.h>
-#define private public
 #include "log_print.h"
 #include "ipc_skeleton.h"
 #include "data_share_service_stub.h"
@@ -95,7 +94,7 @@ void DataShareServiceImplTest::TearDown(void)
 
 /**
 * @tc.name: DataShareServiceImpl001
-* @tc.desc: test Insert Update Query Delete abnormal scene
+* @tc.desc: test InsertEx UpdateEx Query DeleteEx abnormal scene
 * @tc.type: FUNC
 * @tc.require:SQL
 */
@@ -110,19 +109,19 @@ HWTEST_F(DataShareServiceImplTest, DataShareServiceImpl001, TestSize.Level1)
     DataShare::DataShareValuesBucket valuesBucket;
     std::string name0 = "";
     valuesBucket.Put("", name0);
-    auto result = dataShareServiceImpl.Insert(uri, valuesBucket);
-    EXPECT_EQ((result > 0), true);
+    auto [errCode, result] = dataShareServiceImpl.InsertEx(uri, "", valuesBucket);
+    EXPECT_EQ((errCode != 0), true);
 
     DataShare::DataSharePredicates predicates;
     std::string selections = "";
     predicates.SetWhereClause(selections);
-    result = dataShareServiceImpl.Update(uri, predicates, valuesBucket);
-    EXPECT_EQ((result > 0), true);
+    auto [errCode1, result1] = dataShareServiceImpl.UpdateEx(uri, "", predicates, valuesBucket);
+    EXPECT_EQ((errCode1 != 0), true);
 
     predicates.EqualTo("", "");
     std::vector<std::string> columns;
-    int errCode = 0;
-    auto resQuery = dataShareServiceImpl.Query(uri, predicates, columns, errCode);
+    int errVal = 0;
+    auto resQuery = dataShareServiceImpl.Query(uri, "", predicates, columns, errVal);
     int resultSet = 0;
     if (resQuery != nullptr) {
         resQuery->GetRowCount(resultSet);
@@ -130,8 +129,8 @@ HWTEST_F(DataShareServiceImplTest, DataShareServiceImpl001, TestSize.Level1)
     EXPECT_EQ(resultSet, 0);
 
     predicates.SetWhereClause(selections);
-    result = dataShareServiceImpl.Delete(uri, predicates);
-    EXPECT_EQ((result > 0), true);
+    auto [errCode2, result2] = dataShareServiceImpl.DeleteEx(uri, "", predicates);
+    EXPECT_EQ((errCode2 != 0), true);
 }
 
 /**
@@ -286,8 +285,8 @@ HWTEST_F(DataShareServiceImplTest, SubscribeRdbData001, TestSize.Level1)
     DataShare::DataShareValuesBucket valuesBucket1, valuesBucket2;
     std::string name0 = "wang";
     valuesBucket1.Put(TBL_NAME0, name0);
-    auto result4 = dataShareServiceImpl.Insert(uri, valuesBucket1);
-    EXPECT_EQ((result4 > 0), true);
+    auto [errCode4, result4] = dataShareServiceImpl.InsertEx(uri, "", valuesBucket1);
+    EXPECT_EQ((errCode4 != 0), true);
 
     std::vector<OperationResult> result5 = dataShareServiceImpl.UnsubscribeRdbData(uris, tplId);
     EXPECT_EQ(result5.size(), uris.size());
@@ -297,8 +296,8 @@ HWTEST_F(DataShareServiceImplTest, SubscribeRdbData001, TestSize.Level1)
 
     std::string name1 = "wu";
     valuesBucket2.Put(TBL_NAME1, name1);
-    auto result6 = dataShareServiceImpl.Insert(uri, valuesBucket2);
-    EXPECT_EQ((result6 > 0), true);
+    auto [errCode6, result6] = dataShareServiceImpl.InsertEx(uri, "", valuesBucket2);
+    EXPECT_EQ((errCode6 != 0), true);
 
     std::vector<OperationResult> result7 = dataShareServiceImpl.DisableRdbSubs(uris, tplId);
     for (auto const &operationResult : result7) {
diff --git a/datamgr_service/services/distributeddataservice/service/test/data_share_service_stub_test.cpp b/datamgr_service/services/distributeddataservice/service/test/data_share_service_stub_test.cpp
index 0adae040d183304777c2b0431c4fd51240d4741b..d006a70be73b307e22916d471ae3ca0ad7926224 100644
--- a/datamgr_service/services/distributeddataservice/service/test/data_share_service_stub_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/data_share_service_stub_test.cpp
@@ -16,7 +16,6 @@
 
 #include <gtest/gtest.h>
 #include <unistd.h>
-#define private public
 #include "log_print.h"
 #include "ipc_skeleton.h"
 #include "data_share_service_impl.h"
@@ -59,7 +58,7 @@ HWTEST_F(DataShareServiceStubTest, OnRemoteRequest001, TestSize.Level1)
     request.RewindRead(0);
     MessageParcel reply;
     auto result = dataShareServiceStub->OnRemoteRequest(code, request, reply);
-    EXPECT_NE(result, IDataShareService::DATA_SHARE_ERROR);
+    EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
 
     result = dataShareServiceStub->OnNotifyConnectDone(request, reply);
     EXPECT_EQ(result, IDataShareService::DATA_SHARE_OK);
@@ -87,7 +86,7 @@ HWTEST_F(DataShareServiceStubTest, OnRemoteRequest002, TestSize.Level1)
 
 /**
 * @tc.name: OnInsert001
-* @tc.desc: test Insert Update Query Delete function of abnormal scene
+* @tc.desc: test InsertEx UpdateEx Query DeleteEx function of abnormal scene
 * @tc.type: FUNC
 * @tc.require:SQL
 */
@@ -101,16 +100,16 @@ HWTEST_F(DataShareServiceStubTest, OnInsert001, TestSize.Level1)
     request.WriteBuffer(data, size);
     request.RewindRead(0);
     MessageParcel reply;
-    auto result = dataShareServiceStub->OnInsert(request, reply);
+    auto result = dataShareServiceStub->OnInsertEx(request, reply);
     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
 
-    result = dataShareServiceStub->OnUpdate(request, reply);
+    result = dataShareServiceStub->OnUpdateEx(request, reply);
     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
 
     result = dataShareServiceStub->OnQuery(request, reply);
     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
 
-    result = dataShareServiceStub->OnDelete(request, reply);
+    result = dataShareServiceStub->OnDeleteEx(request, reply);
     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
 }
 
diff --git a/datamgr_service/services/distributeddataservice/service/test/data_share_subscriber_managers_test.cpp b/datamgr_service/services/distributeddataservice/service/test/data_share_subscriber_managers_test.cpp
index bd34b243f73c87d98d5778a782b41dcee9a06f3f..eedf4ba159ec0143f6439b03e8a364b05a42a381 100644
--- a/datamgr_service/services/distributeddataservice/service/test/data_share_subscriber_managers_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/data_share_subscriber_managers_test.cpp
@@ -15,8 +15,8 @@
 #define LOG_TAG "DataShareSubscriberManagersTest"
 
 #include <gtest/gtest.h>
+#include <unistd.h>
 
-#define private public
 #include "accesstoken_kit.h"
 #include "datashare_errno.h"
 #include "data_share_service_impl.h"
diff --git a/datamgr_service/services/distributeddataservice/service/test/device_matrix_test.cpp b/datamgr_service/services/distributeddataservice/service/test/device_matrix_test.cpp
index 975e45f01ef865bd157767501d19ac6d8485c5c3..f72ffc5676763092954985f00f6124aaf9e7b5ad 100644
--- a/datamgr_service/services/distributeddataservice/service/test/device_matrix_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/device_matrix_test.cpp
@@ -55,8 +55,8 @@ protected:
 
     static inline std::vector<std::pair<std::string, std::string>> staticStores_ = { { "bundle0", "store0" },
         { "bundle1", "store0" } };
-    static inline std::vector<std::pair<std::string, std::string>> dynamicStores_ = {
-        { "distributeddata", "service_meta" }, { "bundle0", "store1" }, { "bundle3", "store0" } };
+    static inline std::vector<std::pair<std::string, std::string>> dynamicStores_ = { { "bundle0", "store1" },
+        { "bundle3", "store0" } };
     static BlockData<Result> isFinished_;
     static std::shared_ptr<DBStoreMock> dbStoreMock_;
     static uint32_t selfToken_;
@@ -89,38 +89,12 @@ void DeviceMatrixTest::SetUpTestCase(void)
     }
     Bootstrap::GetInstance().LoadCheckers();
     DeviceMatrix::GetInstance().Initialize(selfToken_, "service_meta");
-    EventCenter::GetInstance().Subscribe(DeviceMatrix::MATRIX_ONLINE, [](const Event &event) {
-        auto &evt = static_cast<const MatrixEvent &>(event);
-        auto data = evt.GetMatrixData();
-        auto deviceId = evt.GetDeviceId();
-        if ((data.dynamic & DeviceMatrix::META_STORE_MASK) != 0) {
-            auto onComplete = [deviceId](const std::map<std::string, DBStatus> &) {
-                DeviceMatrix::GetInstance().OnExchanged(deviceId, DeviceMatrix::META_STORE_MASK);
-            };
-            dbStoreMock_->Sync({ deviceId }, SYNC_MODE_PUSH_PULL, onComplete, false);
-        }
-#ifdef TEST_ON_DEVICE
-        auto finEvent = std::make_unique<MatrixEvent>(DeviceMatrix::MATRIX_META_FINISHED, deviceId, data);
-        EventCenter::GetInstance().PostEvent(std::move(finEvent));
-#endif
-    });
-
-    EventCenter::GetInstance().Subscribe(DeviceMatrix::MATRIX_META_FINISHED, [](const Event &event) {
-        auto &evt = static_cast<const MatrixEvent &>(event);
-        Result result;
-        result.deviceId_ = evt.GetDeviceId();
-        result.mask_ = evt.GetMatrixData().dynamic;
-        isFinished_.SetValue(result);
-    });
-
     mkdir("/data/service/el1/public/database/matrix_test", (S_IRWXU | S_IRWXG | S_IRWXO));
     mkdir("/data/service/el1/public/database/matrix_test/kvdb", (S_IRWXU | S_IRWXG | S_IRWXO));
 }
 
 void DeviceMatrixTest::TearDownTestCase(void)
 {
-    EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_ONLINE);
-    EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_META_FINISHED);
     EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_BROADCAST);
 }
 
@@ -171,86 +145,6 @@ void DeviceMatrixTest::InitMetaData()
     localMeta_.policies = { std::move(value) };
 }
 
-/**
-* @tc.name: FirstOnline
-* @tc.desc: the first online time;
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: blue sky
-*/
-HWTEST_F(DeviceMatrixTest, FirstOnline, TestSize.Level0)
-{
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    auto result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x7);
-}
-
-/**
-* @tc.name: OnlineAgainNoData
-* @tc.desc: the second online with no data change;
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: blue sky
-*/
-HWTEST_F(DeviceMatrixTest, OnlineAgainNoData, TestSize.Level0)
-{
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    auto result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x7);
-    isFinished_.Clear(Result());
-    DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x6);
-}
-
-/**
-* @tc.name: OnlineAgainWithData
-* @tc.desc: the second online with sync data change;
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: blue sky
-*/
-HWTEST_F(DeviceMatrixTest, OnlineAgainWithData, TestSize.Level0)
-{
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    auto result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x7);
-    isFinished_.Clear(Result());
-    DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
-    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_);
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x7);
-}
-
-/**
-* @tc.name: OnlineAgainWithLocal
-* @tc.desc: the second online with local data change;
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: blue sky
-*/
-HWTEST_F(DeviceMatrixTest, OnlineAgainWithLocal, TestSize.Level0)
-{
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    auto result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x7);
-    isFinished_.Clear(Result());
-    DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
-    MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta_, true);
-    DeviceMatrix::GetInstance().Online(TEST_DEVICE);
-    result = isFinished_.GetValue();
-    ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
-    ASSERT_EQ(result.mask_, 0x6);
-}
-
 /**
 * @tc.name: GetMetaStoreCode
 * @tc.desc: get the meta data store mask code;
@@ -283,7 +177,7 @@ HWTEST_F(DeviceMatrixTest, GetAllCode, TestSize.Level0)
     for (size_t i = 0; i < dynamicStores_.size(); ++i) {
         meta.appId = dynamicStores_[i].first;
         meta.bundleName = dynamicStores_[i].first;
-        ASSERT_EQ(DeviceMatrix::GetInstance().GetCode(meta), 0x1 << i);
+        ASSERT_EQ(DeviceMatrix::GetInstance().GetCode(meta), 0x1 << (i + 1));
     }
 }
 
@@ -327,8 +221,8 @@ HWTEST_F(DeviceMatrixTest, BroadcastMeta, TestSize.Level0)
 HWTEST_F(DeviceMatrixTest, BroadcastFirst, TestSize.Level0)
 {
     StoreMetaData meta = metaData_;
-    meta.appId = dynamicStores_[1].first;
-    meta.bundleName = dynamicStores_[1].first;
+    meta.appId = dynamicStores_[0].first;
+    meta.bundleName = dynamicStores_[0].first;
     auto code = DeviceMatrix::GetInstance().GetCode(meta);
     ASSERT_EQ(code, 0x2);
     DeviceMatrix::DataLevel level = {
@@ -371,13 +265,13 @@ HWTEST_F(DeviceMatrixTest, BroadcastAll, TestSize.Level0)
     auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
     ASSERT_EQ(mask.first, DeviceMatrix::META_STORE_MASK);
     StoreMetaData meta = metaData_;
-    for (size_t i = 1; i < dynamicStores_.size(); ++i) {
+    for (size_t i = 0; i < dynamicStores_.size(); ++i) {
         meta.appId = dynamicStores_[i].first;
         meta.bundleName = dynamicStores_[i].first;
         auto code = DeviceMatrix::GetInstance().GetCode(meta);
         level.dynamic = code;
         mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
-        ASSERT_EQ(mask.first, (0x1 << i) + 1);
+        ASSERT_EQ(mask.first, (0x1 << (i + 1)) + 1);
         DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, code);
     }
     DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
@@ -405,7 +299,7 @@ HWTEST_F(DeviceMatrixTest, UpdateMatrixMeta, TestSize.Level0)
     metaData.dynamic = 0x1F;
     metaData.deviceId = TEST_DEVICE;
     metaData.origin = MatrixMetaData::Origin::REMOTE_RECEIVED;
-    metaData.dynamicInfo = { TEST_BUNDLE, dynamicStores_[1].first };
+    metaData.dynamicInfo = { TEST_BUNDLE, dynamicStores_[0].first };
     MetaDataManager::GetInstance().Subscribe(MatrixMetaData::GetPrefix({ TEST_DEVICE }),
         [](const std::string &, const std::string &value, int32_t flag) {
             if (flag != MetaDataManager::INSERT && flag != MetaDataManager::UPDATE) {
diff --git a/datamgr_service/services/distributeddataservice/service/test/dump_helper_test.cpp b/datamgr_service/services/distributeddataservice/service/test/dump_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..86ce2efb7db433e6e076b9eb81ff6b7dbeb8b2a2
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/dump_helper_test.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "DumpHelperTest "
+
+#include "gtest/gtest.h"
+#include "log_print.h"
+#include "dump_helper.h"
+#include "dump/dump_manager.h"
+#include "types.h"
+
+using namespace OHOS;
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS::DistributedData;
+namespace OHOS::Test {
+namespace DistributedDataTest {
+class DumpHelperTest  : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp();
+    void TearDown(){};
+};
+
+void DumpHelperTest::SetUp(void)
+{
+    DumpManager &dumpManager = DumpManager::GetInstance();
+    DumpManager::Config config;
+    config.dumpName = "test_dump";
+    config.fullCmd = "test_full_cmd";
+    config.abbrCmd = "test_abbr_cmd";
+    config.countPrintf = 1;
+    config.infoName = "test_info";
+    config.minParamsNum = 2; //minParamsNum is 2
+    config.maxParamsNum = 5; //maxParamsNum is 5
+    config.parentNode = "test_parent";
+    config.childNode = "test_child";
+    config.dumpCaption = {"test_caption1", "test_caption2"};
+
+    dumpManager.AddConfig("111", config);
+    dumpManager.GetHandler(config.infoName);
+    DumpManager::Config result = dumpManager.GetConfig("111");
+    ASSERT_EQ(result.dumpName, config.dumpName);
+}
+
+/**
+* @tc.name: GetInstanceTest
+* @tc.desc: GetInstance test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(DumpHelperTest, GetInstanceTest, TestSize.Level0)
+{
+    DumpHelper &dumpHelper = DumpHelper::GetInstance();
+    EXPECT_NE(&dumpHelper, nullptr);
+
+    int fd = 1;
+    std::vector<std::string> args;
+    EXPECT_TRUE(dumpHelper.Dump(fd, args));
+
+    args = {"COMMAND_A", "ARG_1", "ARG_2"};
+    EXPECT_TRUE(dumpHelper.Dump(fd, args));
+}
+
+/**
+* @tc.name: AddErrorInfoTest
+* @tc.desc: AddErrorInfo test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(DumpHelperTest, AddErrorInfoTest, TestSize.Level0)
+{
+    DumpHelper &dumpHelper = DumpHelper::GetInstance();
+    EXPECT_NE(&dumpHelper, nullptr);
+    int32_t errorCode = 1001;
+    std::string errorInfo = "Test error information";
+
+    dumpHelper.AddErrorInfo(errorCode, errorInfo);
+
+    const OHOS::DistributedData::DumpHelper::ErrorInfo& lastError = dumpHelper.errorInfo_.back();
+    EXPECT_EQ(lastError.errorCode, errorCode);
+    EXPECT_EQ(lastError.errorInfo, errorInfo);
+}
+} // namespace DistributedDataTest
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn
index 2007179cd6f0d852d467b542be5e1970056f20ab..4f44b6a128887890b0b18fa83a9248cd5b6ed6e4 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn
@@ -75,6 +75,7 @@ ohos_fuzztest("CloudServiceStubFuzzTest") {
     "${data_service_path}/service/common/value_proxy.cpp",
     "${data_service_path}/service/common/xcollie.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/customutdinstaller_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/customutdinstaller_fuzzer/BUILD.gn
index 485c816f6e2d887c8415f4b02f10db49ab13b02c..c495c98f2507352fc7be8f2af14896936221f078 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/customutdinstaller_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/customutdinstaller_fuzzer/BUILD.gn
@@ -99,6 +99,7 @@ ohos_fuzztest("CustomUtdInstallerFuzzTest") {
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
     "udmf:udmf_client",
+    "udmf:utd_client",
   ]
 }
 
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn
index 7e0a82496eaab9618c39b0dfb816ef04b328fb91..83c0d39844230f6f731274e4f10e1087b397d133 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn
@@ -63,6 +63,7 @@ ohos_fuzztest("KvdbServiceStubFuzzTest") {
     "${data_service_path}/service/bootstrap/src/bootstrap.cpp",
     "${data_service_path}/service/common/value_proxy.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
@@ -83,7 +84,6 @@ ohos_fuzztest("KvdbServiceStubFuzzTest") {
     "${data_service_path}/service/kvdb/query_helper.cpp",
     "${data_service_path}/service/kvdb/upgrade.cpp",
     "${data_service_path}/service/kvdb/user_delegate.cpp",
-    "${data_service_path}/service/matrix/src/auto_sync_matrix.cpp",
     "${data_service_path}/service/matrix/src/device_matrix.cpp",
     "${data_service_path}/service/matrix/src/matrix_event.cpp",
     "${data_service_path}/service/permission/src/permit_delegate.cpp",
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn
index 9f31030817a47d99ddde2c4f3c688d080cb9d5fe..d268b6b6bde89c43efedd1a05a3de171d805069f 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn
@@ -62,6 +62,7 @@ ohos_fuzztest("ObjectServiceStubFuzzTest") {
     "${data_service_path}/service/common/common_types_utils.cpp",
     "${data_service_path}/service/common/value_proxy.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn
index f45834eef869489f2f3413fb570e03baab800d97..a6ffe6bb80601d514d992035cc5f049921cc2111 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn
@@ -69,6 +69,7 @@ ohos_fuzztest("RdbServiceStubFuzzTest") {
     "${data_service_path}/service/common/value_proxy.cpp",
     "${data_service_path}/service/common/xcollie.cpp",
     "${data_service_path}/service/config/src/config_factory.cpp",
+    "${data_service_path}/service/config/src/model/app_id_mapping_config.cpp",
     "${data_service_path}/service/config/src/model/backup_config.cpp",
     "${data_service_path}/service/config/src/model/checker_config.cpp",
     "${data_service_path}/service/config/src/model/cloud_config.cpp",
diff --git a/datamgr_service/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn
index 2c399378cce589d21b55e9a00cef499667a97e7a..82fe2b8671d5cfd82742dcd3cc3e41dfa7f08362 100644
--- a/datamgr_service/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/BUILD.gn
@@ -56,7 +56,6 @@ ohos_fuzztest("UdmfServiceFuzzTest") {
     "bundle_framework:appexecfwk_core",
     "c_utils:utils",
     "hilog:libhilog",
-    "image_framework:image",
     "ipc:ipc_core",
     "kv_store:distributeddata_inner",
     "kv_store:distributeddata_mgr",
diff --git a/datamgr_service/services/distributeddataservice/service/test/kvdb_general_store_test.cpp b/datamgr_service/services/distributeddataservice/service/test/kvdb_general_store_test.cpp
index 23a555dd4ae0e94e5390aae56cf40b4a0139721c..557d62d531d7c233ed813ccee1939ddc04335d1b 100644
--- a/datamgr_service/services/distributeddataservice/service/test/kvdb_general_store_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/kvdb_general_store_test.cpp
@@ -18,30 +18,38 @@
 
 #include <gtest/gtest.h>
 #include <random>
+#include <thread>
 
 #include "bootstrap.h"
+#include "cloud/schema_meta.h"
+#include "cloud/asset_loader.h"
+#include "cloud/cloud_db.h"
 #include "crypto_manager.h"
 #include "kvdb_query.h"
+#include "kv_store_nb_delegate_mock.h"
 #include "log_print.h"
 #include "metadata/meta_data_manager.h"
 #include "metadata/secret_key_meta_data.h"
 #include "metadata/store_meta_data.h"
 #include "metadata/store_meta_data_local.h"
 #include "mock/db_store_mock.h"
+#include "mock/general_watcher_mock.h"
 
 using namespace testing::ext;
+using namespace DistributedDB;
+using namespace OHOS::DistributedData;
 using DBStoreMock = OHOS::DistributedData::DBStoreMock;
 using StoreMetaData = OHOS::DistributedData::StoreMetaData;
-
-namespace OHOS {
-namespace DistributedKv {
+using SecurityLevel = OHOS::DistributedKv::SecurityLevel;
+using KVDBGeneralStore = OHOS::DistributedKv::KVDBGeneralStore;
+namespace OHOS::Test {
+namespace DistributedDataTest {
 class KVDBGeneralStoreTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
     void SetUp();
     void TearDown();
-
 protected:
     static constexpr const char *bundleName = "test_distributeddata";
     static constexpr const char *storeName = "test_service_meta";
@@ -64,7 +72,7 @@ void KVDBGeneralStoreTest::InitMetaData()
     metaData_.area = OHOS::DistributedKv::EL1;
     metaData_.instanceId = 0;
     metaData_.isAutoSync = true;
-    metaData_.storeType = KvStoreType::SINGLE_VERSION;
+    metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
     metaData_.storeId = storeName;
     metaData_.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb";
     metaData_.securityLevel = SecurityLevel::S2;
@@ -95,6 +103,48 @@ void KVDBGeneralStoreTest::SetUp()
 
 void KVDBGeneralStoreTest::TearDown() {}
 
+class MockGeneralWatcher : public DistributedData::GeneralWatcher {
+public:
+    int32_t OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values) override
+    {
+        return GeneralError::E_OK;
+    }
+
+    int32_t OnChange(const Origin &origin, const Fields &fields, ChangeData &&datas) override
+    {
+        return GeneralError::E_OK;
+    }
+};
+
+class MockKvStoreChangedData : public DistributedDB::KvStoreChangedData {
+public:
+    MockKvStoreChangedData() {}
+    virtual ~MockKvStoreChangedData() {}
+    std::list<DistributedDB::Entry> entriesInserted = {};
+    std::list<DistributedDB::Entry> entriesUpdated = {};
+    std::list<DistributedDB::Entry> entriesDeleted = {};
+    bool isCleared = true;
+    const std::list<DistributedDB::Entry>& GetEntriesInserted() const override
+    {
+        return entriesInserted;
+    }
+
+    const std::list<DistributedDB::Entry>& GetEntriesUpdated() const override
+    {
+        return entriesUpdated;
+    }
+
+    const std::list<Entry>& GetEntriesDeleted() const override
+    {
+        return entriesDeleted;
+    }
+
+    bool IsCleared() const override
+    {
+        return isCleared;
+    }
+};
+
 /**
 * @tc.name: GetDBPasswordTest_001
 * @tc.desc: GetDBPassword from meta.
@@ -177,6 +227,11 @@ HWTEST_F(KVDBGeneralStoreTest, GetDBSecurityTest, TestSize.Level0)
     dbSecurity = KVDBGeneralStore::GetDBSecurity(SecurityLevel::S4);
     EXPECT_EQ(dbSecurity.securityLabel, DistributedDB::S4);
     EXPECT_EQ(dbSecurity.securityFlag, DistributedDB::ECE);
+
+    auto action = static_cast<int32_t>(SecurityLevel::S4 + 1);
+    dbSecurity = KVDBGeneralStore::GetDBSecurity(action);
+    EXPECT_EQ(dbSecurity.securityLabel, DistributedDB::NOT_SET);
+    EXPECT_EQ(dbSecurity.securityFlag, DistributedDB::ECE);
 }
 
 /**
@@ -206,7 +261,7 @@ HWTEST_F(KVDBGeneralStoreTest, GetDBOptionTest, TestSize.Level0)
 
 /**
 * @tc.name: CloseTest
-* @tc.desc: Close kvdb general store.
+* @tc.desc: Close kvdb general store and  test the functionality of different branches.
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: Hollokin
@@ -217,6 +272,36 @@ HWTEST_F(KVDBGeneralStoreTest, CloseTest, TestSize.Level0)
     ASSERT_NE(store, nullptr);
     auto ret = store->Close();
     EXPECT_EQ(ret, GeneralError::E_OK);
+
+    KvStoreNbDelegateMock mockDelegate;
+    mockDelegate.taskCountMock_ = 1;
+    store->delegate_ = &mockDelegate;
+    EXPECT_NE(store->delegate_, nullptr);
+    ret = store->Close();
+    EXPECT_EQ(ret, GeneralError::E_BUSY);
+}
+
+/**
+* @tc.name: Close
+* @tc.desc: RdbGeneralStore Close test
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: shaoyuanzhao
+*/
+HWTEST_F(KVDBGeneralStoreTest, BusyClose, TestSize.Level0)
+{
+    auto store = std::make_shared<KVDBGeneralStore>(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::thread thread([store]() {
+        std::unique_lock<decltype(store->rwMutex_)> lock(store->rwMutex_);
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    });
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    auto ret = store->Close();
+    EXPECT_EQ(ret, GeneralError::E_BUSY);
+    thread.join();
+    ret = store->Close();
+    EXPECT_EQ(ret, GeneralError::E_OK);
 }
 
 /**
@@ -237,7 +322,7 @@ HWTEST_F(KVDBGeneralStoreTest, SyncTest, TestSize.Level0)
     uint32_t highMode = GeneralStore::HighMode::MANUAL_SYNC_MODE;
     auto mixMode = GeneralStore::MixMode(syncMode, highMode);
     std::string kvQuery = "";
-    KVDBQuery query(kvQuery);
+    DistributedKv::KVDBQuery query(kvQuery);
     SyncParam syncParam{};
     syncParam.mode = mixMode;
     auto ret = store->Sync(
@@ -246,5 +331,396 @@ HWTEST_F(KVDBGeneralStoreTest, SyncTest, TestSize.Level0)
     ret = store->Close();
     EXPECT_EQ(ret, GeneralError::E_OK);
 }
+
+/**
+* @tc.name: BindTest
+* @tc.desc: Bind test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, BindTest, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    DistributedData::Database database;
+    std::map<uint32_t, GeneralStore::BindInfo> bindInfos;
+    GeneralStore::CloudConfig config;
+    EXPECT_EQ(bindInfos.empty(), true);
+    auto ret = store->Bind(database, bindInfos, config);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    std::shared_ptr<CloudDB> db;
+    std::shared_ptr<AssetLoader> loader;
+    GeneralStore::BindInfo bindInfo1(db, loader);
+    uint32_t key = 1;
+    bindInfos[key] = bindInfo1;
+    ret = store->Bind(database, bindInfos, config);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+    std::shared_ptr<CloudDB> dbs = std::make_shared<CloudDB>();
+    std::shared_ptr<AssetLoader> loaders = std::make_shared<AssetLoader>();
+    GeneralStore::BindInfo bindInfo2(dbs, loaders);
+    bindInfos[key] = bindInfo2;
+    EXPECT_EQ(store->IsBound(), false);
+    ret = store->Bind(database, bindInfos, config);
+    EXPECT_EQ(ret, GeneralError::E_ALREADY_CLOSED);
+
+    store->isBound_ = false;
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    EXPECT_NE(store->delegate_, nullptr);
+    EXPECT_EQ(store->IsBound(), false);
+    ret = store->Bind(database, bindInfos, config);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    EXPECT_EQ(store->IsBound(), true);
+    ret = store->Bind(database, bindInfos, config);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+}
+
+/**
+* @tc.name: GetDBSyncCompleteCB
+* @tc.desc: GetDBSyncCompleteCB test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, GetDBSyncCompleteCB, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    GeneralStore::DetailAsync async;
+    EXPECT_EQ(async, nullptr);
+    KVDBGeneralStore::DBSyncCallback ret = store->GetDBSyncCompleteCB(async);
+    EXPECT_NE(ret, nullptr);
+    auto asyncs = [](const GenDetails &result) {};
+    EXPECT_NE(asyncs, nullptr);
+    ret = store->GetDBSyncCompleteCB(asyncs);
+    EXPECT_NE(ret, nullptr);
+}
+
+/**
+* @tc.name: CloudSync
+* @tc.desc: CloudSync test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, CloudSync, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    store->SetEqualIdentifier(bundleName, storeName);
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    std::vector<std::string> devices = {"device1", "device2"};
+    auto asyncs = [](const GenDetails &result) {};
+    store->storeInfo_.user = 0;
+    auto cloudSyncMode = DistributedDB::SyncMode::SYNC_MODE_PUSH_ONLY;
+    store->SetEqualIdentifier(bundleName, storeName);
+    auto ret = store->CloudSync(devices, cloudSyncMode, asyncs, 0);
+    EXPECT_EQ(ret, DBStatus::OK);
+
+    store->storeInfo_.user = 1;
+    cloudSyncMode = DistributedDB::SyncMode::SYNC_MODE_CLOUD_FORCE_PUSH;
+    ret = store->CloudSync(devices, cloudSyncMode, asyncs, 0);
+    EXPECT_EQ(ret, DBStatus::OK);
+}
+
+/**
+* @tc.name: Sync
+* @tc.desc: Sync test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Sync, TestSize.Level0)
+{
+    mkdir(("/data/service/el1/public/database/" + std::string(bundleName)).c_str(),
+        (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    uint32_t syncMode = GeneralStore::SyncMode::CLOUD_BEGIN;
+    uint32_t highMode = GeneralStore::HighMode::MANUAL_SYNC_MODE;
+    auto mixMode = GeneralStore::MixMode(syncMode, highMode);
+    std::string kvQuery = "";
+    DistributedKv::KVDBQuery query(kvQuery);
+    SyncParam syncParam{};
+    syncParam.mode = mixMode;
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    auto ret = store->Sync({}, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_NOT_SUPPORT);
+    GeneralStore::StoreConfig storeConfig;
+    storeConfig.enableCloud_ = true;
+    store->SetConfig(storeConfig);
+    ret = store->Sync({}, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    syncMode = GeneralStore::SyncMode::NEARBY_END;
+    mixMode = GeneralStore::MixMode(syncMode, highMode);
+    syncParam.mode = mixMode;
+    ret = store->Sync({}, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+
+    std::vector<std::string> devices = {"device1", "device2"};
+    syncMode = GeneralStore::SyncMode::NEARBY_SUBSCRIBE_REMOTE;
+    mixMode = GeneralStore::MixMode(syncMode, highMode);
+    syncParam.mode = mixMode;
+    ret = store->Sync(devices, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    syncMode = GeneralStore::SyncMode::NEARBY_UNSUBSCRIBE_REMOTE;
+    mixMode = GeneralStore::MixMode(syncMode, highMode);
+    syncParam.mode = mixMode;
+    ret = store->Sync(devices, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    syncMode = GeneralStore::SyncMode::NEARBY_PULL_PUSH;
+    mixMode = GeneralStore::MixMode(syncMode, highMode);
+    syncParam.mode = mixMode;
+    ret = store->Sync(devices, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    syncMode = GeneralStore::SyncMode::MODE_BUTT;
+    mixMode = GeneralStore::MixMode(syncMode, highMode);
+    syncParam.mode = mixMode;
+    ret = store->Sync(devices, query, [](const GenDetails &result) {}, syncParam);
+    EXPECT_EQ(ret, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: Clean
+* @tc.desc: Clean test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Clean, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::vector<std::string> devices = {"device1", "device2"};
+    std::string tableName = "tableName";
+    auto ret = store->Clean(devices, -1, tableName);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+    ret = store->Clean(devices, 5, tableName);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+    ret = store->Clean(devices, GeneralStore::CleanMode::NEARBY_DATA, tableName);
+    EXPECT_EQ(ret, GeneralError::E_ALREADY_CLOSED);
+
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    ret = store->Clean(devices, GeneralStore::CleanMode::CLOUD_INFO, tableName);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    ret = store->Clean(devices, GeneralStore::CleanMode::CLOUD_DATA, tableName);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    ret = store->Clean({}, GeneralStore::CleanMode::NEARBY_DATA, tableName);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = store->Clean(devices, GeneralStore::CleanMode::NEARBY_DATA, tableName);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+
+    ret = store->Clean(devices, GeneralStore::CleanMode::LOCAL_DATA, tableName);
+    EXPECT_EQ(ret, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: Watch
+* @tc.desc: Watch and Unwatch test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Watch, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    DistributedDataTest::MockGeneralWatcher watcher;
+    auto ret = store->Watch(GeneralWatcher::Origin::ORIGIN_CLOUD, watcher);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+    ret = store->Unwatch(GeneralWatcher::Origin::ORIGIN_CLOUD, watcher);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+
+    ret = store->Watch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = store->Watch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+
+    ret = store->Unwatch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = store->Unwatch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(ret, GeneralError::E_INVALID_ARGS);
+}
+
+/**
+* @tc.name: Release
+* @tc.desc: Release and AddRef test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Release, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    auto ret = store->Release();
+    EXPECT_EQ(ret, 0);
+    store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    store->ref_ = 0;
+    ret = store->Release();
+    EXPECT_EQ(ret, 0);
+    store->ref_ = 2;
+    ret = store->Release();
+    EXPECT_EQ(ret, 1);
+
+    ret = store->AddRef();
+    EXPECT_EQ(ret, 2);
+    store->ref_ = 0;
+    ret = store->AddRef();
+    EXPECT_EQ(ret, 0);
+}
+
+/**
+* @tc.name: ConvertStatus
+* @tc.desc: ConvertStatus test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, ConvertStatus, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    auto ret = store->ConvertStatus(DBStatus::OK);
+    EXPECT_EQ(ret, GeneralError::E_OK);
+    ret = store->ConvertStatus(DBStatus::CLOUD_NETWORK_ERROR);
+    EXPECT_EQ(ret, GeneralError::E_NETWORK_ERROR);
+    ret = store->ConvertStatus(DBStatus::CLOUD_LOCK_ERROR);
+    EXPECT_EQ(ret, GeneralError::E_LOCKED_BY_OTHERS);
+    ret = store->ConvertStatus(DBStatus::CLOUD_FULL_RECORDS);
+    EXPECT_EQ(ret, GeneralError::E_RECODE_LIMIT_EXCEEDED);
+    ret = store->ConvertStatus(DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT);
+    EXPECT_EQ(ret, GeneralError::E_NO_SPACE_FOR_ASSET);
+    ret = store->ConvertStatus(DBStatus::CLOUD_SYNC_TASK_MERGED);
+    EXPECT_EQ(ret, GeneralError::E_SYNC_TASK_MERGED);
+    ret = store->ConvertStatus(DBStatus::DB_ERROR);
+    EXPECT_EQ(ret, GeneralError::E_ERROR);
+}
+
+/**
+* @tc.name: GetWaterVersion
+* @tc.desc: GetWaterVersion test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, GetWaterVersion, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::string deviceId = "deviceId";
+    std::vector<std::string> res = {};
+    auto ret = store->GetWaterVersion(deviceId);
+    EXPECT_EQ(ret, res);
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    ret = store->GetWaterVersion("");
+    EXPECT_EQ(ret, res);
+    ret = store->GetWaterVersion("test");
+    EXPECT_EQ(ret, res);
+    ret = store->GetWaterVersion("device");
+    EXPECT_EQ(ret, res);
+    res = {"deviceId"};
+    ret = store->GetWaterVersion(deviceId);
+    EXPECT_EQ(ret, res);
+}
+
+/**
+* @tc.name: OnChange
+* @tc.desc: OnChange test the functionality of different branches.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, OnChange, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    DistributedDataTest::MockGeneralWatcher watcher;
+    DistributedDataTest::MockKvStoreChangedData data;
+    DistributedDB::ChangedData changedData;
+    store->observer_.OnChange(data);
+    store->observer_.OnChange(DistributedDB::Origin::ORIGIN_CLOUD, "originalId", std::move(changedData));
+    auto result = store->Watch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(result, GeneralError::E_OK);
+    store->observer_.OnChange(data);
+    store->observer_.OnChange(DistributedDB::Origin::ORIGIN_CLOUD, "originalId", std::move(changedData));
+    result = store->Unwatch(GeneralWatcher::Origin::ORIGIN_ALL, watcher);
+    EXPECT_EQ(result, GeneralError::E_OK);
+}
+
+/**
+* @tc.name: Delete
+* @tc.desc: Delete test the function.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Delete, TestSize.Level0)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    KvStoreNbDelegateMock mockDelegate;
+    store->delegate_ = &mockDelegate;
+    store->SetDBPushDataInterceptor(DistributedKv::KvStoreType::DEVICE_COLLABORATION);
+    store->SetDBReceiveDataInterceptor(DistributedKv::KvStoreType::DEVICE_COLLABORATION);
+    DistributedData::VBuckets values;
+    auto ret = store->Insert("table", std::move(values));
+    EXPECT_EQ(ret, GeneralError::E_NOT_SUPPORT);
+
+    DistributedData::Values args;
+    store->SetDBPushDataInterceptor(DistributedKv::KvStoreType::SINGLE_VERSION);
+    store->SetDBReceiveDataInterceptor(DistributedKv::KvStoreType::SINGLE_VERSION);
+    ret = store->Delete("table", "sql", std::move(args));
+    EXPECT_EQ(ret, GeneralError::E_NOT_SUPPORT);
+}
+
+/**
+* @tc.name: Query001
+* @tc.desc: KVDBGeneralStoreTest Query function test
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Query001, TestSize.Level1)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::string table = "table";
+    std::string sql = "sql";
+    auto [errCode, result] = store->Query(table, sql, {});
+    EXPECT_EQ(errCode, GeneralError::E_NOT_SUPPORT);
+    EXPECT_EQ(result, nullptr);
+}
+
+/**
+* @tc.name: Query002
+* @tc.desc: KVDBGeneralStoreTest Query function test
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBGeneralStoreTest, Query002, TestSize.Level1)
+{
+    auto store = new (std::nothrow) KVDBGeneralStore(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::string table = "table";
+    MockQuery query;
+    auto [errCode, result] = store->Query(table, query);
+    EXPECT_EQ(errCode, GeneralError::E_NOT_SUPPORT);
+    EXPECT_EQ(result, nullptr);
+}
 } // namespace DistributedDataTest
-} // namespace OHOS::Test
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp b/datamgr_service/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp
index 6360e4cd96331db454ecc2523e73d50c33a7b4ea..2fb8c1861498c822b262e714aba05a6a8d0fe72a 100644
--- a/datamgr_service/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/kvdb_service_impl_test.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2022 Huawei Device Co., Ltd.
+* Copyright (c) 2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
@@ -16,32 +16,40 @@
 #include <gtest/gtest.h>
 #include "log_print.h"
 #include "accesstoken_kit.h"
+#include "bootstrap.h"
+#include "checker/checker_manager.h"
+#include "distributed_kv_data_manager.h"
+#include "device_manager_adapter.h"
+#include "ipc_skeleton.h"
 #include "nativetoken_kit.h"
-
+#include "kvdb_service_impl.h"
 #include "kvdb_service_stub.h"
-#include "checker/checker_manager.h"
+#include "kvstore_death_recipient.h"
+#include "kvstore_meta_manager.h"
 #include "utils/constant.h"
 #include "utils/anonymous.h"
-#include "distributed_kv_data_manager.h"
-
-#include <vector>
-#include "kvstore_death_recipient.h"
+#include "token_setproc.h"
 #include "types.h"
-#include "kvdb_service_impl.h"
+#include <vector>
 
 using namespace testing::ext;
 using namespace OHOS::DistributedData;
 using namespace OHOS::Security::AccessToken;
-
-using Status = OHOS::DistributedKv::Status;
+using Action = OHOS::DistributedData::MetaDataManager::Action;
+using AppId = OHOS::DistributedKv::AppId;
+using ChangeType = OHOS::DistributedData::DeviceMatrix::ChangeType;
+using DistributedKvDataManager = OHOS::DistributedKv::DistributedKvDataManager;
+using DBStatus = DistributedDB::DBStatus;
+using DBMode = DistributedDB::SyncMode;
 using Options = OHOS::DistributedKv::Options;
+using Status = OHOS::DistributedKv::Status;
 using SingleKvStore = OHOS::DistributedKv::SingleKvStore;
-using DistributedKvDataManager = OHOS::DistributedKv::DistributedKvDataManager;
-using UserId = OHOS::DistributedKv::UserId;
-
 using StoreId = OHOS::DistributedKv::StoreId;
-using AppId = OHOS::DistributedKv::AppId;
 using SyncInfo = OHOS::DistributedKv::KVDBService::SyncInfo;
+using SyncMode = OHOS::DistributedKv::SyncMode;
+using SyncAction = OHOS::DistributedKv::KVDBServiceImpl::SyncAction;
+using SwitchState = OHOS::DistributedKv::SwitchState;
+using UserId = OHOS::DistributedKv::UserId;
 static OHOS::DistributedKv::StoreId storeId = { "kvdb_test_storeid" };
 static OHOS::DistributedKv::AppId appId = { "ohos.test.kvdb" };
 
@@ -90,7 +98,6 @@ void KvdbServiceImplTest::SetUpTestCase(void)
 {
     auto executors = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     manager.SetExecutors(executors);
-
     userId.userId = "kvdbserviceimpltest1";
     appId.appId = "ohos.kvdbserviceimpl.test";
     create.createIfMissing = true;
@@ -128,6 +135,45 @@ void KvdbServiceImplTest::TearDown(void)
 KvdbServiceImplTest::KvdbServiceImplTest(void)
 {}
 
+/**
+* @tc.name: KvdbServiceImpl001
+* @tc.desc: KvdbServiceImplTest function test.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, KvdbServiceImpl001, TestSize.Level0)
+{
+    std::string device = "OH_device_test";
+    StoreId id1;
+    id1.storeId = "id1";
+    Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
+    EXPECT_NE(kvStore, nullptr);
+    EXPECT_EQ(status, Status::SUCCESS);
+    int32_t result = kvdbServiceImpl_->OnInitialize();
+    EXPECT_EQ(result, Status::SUCCESS);
+    FeatureSystem::Feature::BindInfo bindInfo;
+    result = kvdbServiceImpl_->OnBind(bindInfo);
+    EXPECT_EQ(result, Status::SUCCESS);
+    result = kvdbServiceImpl_->Online(device);
+    EXPECT_EQ(result, Status::SUCCESS);
+    status = kvdbServiceImpl_->SubscribeSwitchData(appId);
+    EXPECT_EQ(status, Status::SUCCESS);
+    SyncInfo syncInfo;
+    status = kvdbServiceImpl_->CloudSync(appId, id1, syncInfo);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+
+    DistributedKv::StoreConfig storeConfig;
+    status = kvdbServiceImpl_->SetConfig(appId, id1, storeConfig);
+    EXPECT_EQ(status, Status::SUCCESS);
+    status = kvdbServiceImpl_->NotifyDataChange(appId, id1, 0);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+
+    status = kvdbServiceImpl_->UnsubscribeSwitchData(appId);
+    EXPECT_EQ(status, Status::SUCCESS);
+    status = kvdbServiceImpl_->Close(appId, id1);
+    EXPECT_EQ(status, Status::SUCCESS);
+}
+
 /**
 * @tc.name: GetStoreIdsTest001
 * @tc.desc: GetStoreIds
@@ -536,6 +582,218 @@ HWTEST_F(KvdbServiceImplTest, OnReadyTest001, TestSize.Level0)
     auto status = kvdbServiceImpl_->OnReady(device);
     ZLOGI("OnReadyTest001 status = :%{public}d", status);
     ASSERT_EQ(status, Status::SUCCESS);
+    status = kvdbServiceImpl_->OnSessionReady(device);
+    ASSERT_EQ(status, Status::SUCCESS);
+}
+
+/**
+* @tc.name: ResolveAutoLaunch
+* @tc.desc: ResolveAutoLaunch function test.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ResolveAutoLaunch, TestSize.Level0)
+{
+    StoreId id1;
+    id1.storeId = "id1";
+    Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
+    EXPECT_NE(kvStore, nullptr);
+    EXPECT_EQ(status, Status::SUCCESS);
+    std::string identifier = "identifier";
+    DistributedKv::KVDBServiceImpl::DBLaunchParam launchParam;
+    auto result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
+    EXPECT_EQ(result, Status::STORE_NOT_FOUND);
+    std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(1, 0);
+    Bootstrap::GetInstance().LoadDirectory();
+    Bootstrap::GetInstance().LoadCheckers();
+    DistributedKv::KvStoreMetaManager::GetInstance().BindExecutor(executors);
+    DistributedKv::KvStoreMetaManager::GetInstance().InitMetaParameter();
+    DistributedKv::KvStoreMetaManager::GetInstance().InitMetaListener();
+    result = kvdbServiceImpl_->ResolveAutoLaunch(identifier, launchParam);
+    EXPECT_EQ(result, Status::SUCCESS);
+}
+
+/**
+* @tc.name: PutSwitch
+* @tc.desc: PutSwitch function test.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, PutSwitch, TestSize.Level0)
+{
+    StoreId id1;
+    id1.storeId = "id1";
+    Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
+    ASSERT_NE(kvStore, nullptr);
+    ASSERT_EQ(status, Status::SUCCESS);
+    DistributedKv::SwitchData switchData;
+    status = kvdbServiceImpl_->PutSwitch(appId, switchData);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+    switchData.value = DeviceMatrix::INVALID_VALUE;
+    switchData.length = DeviceMatrix::INVALID_LEVEL;
+    status = kvdbServiceImpl_->PutSwitch(appId, switchData);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+    switchData.value = DeviceMatrix::INVALID_MASK;
+    switchData.length = DeviceMatrix::INVALID_LENGTH;
+    status = kvdbServiceImpl_->PutSwitch(appId, switchData);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+    switchData.value = DeviceMatrix::INVALID_VALUE;
+    switchData.length = DeviceMatrix::INVALID_LENGTH;
+    status = kvdbServiceImpl_->PutSwitch(appId, switchData);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+    switchData.value = DeviceMatrix::INVALID_MASK;
+    switchData.length = DeviceMatrix::INVALID_LEVEL;
+    status = kvdbServiceImpl_->PutSwitch(appId, switchData);
+    EXPECT_EQ(status, Status::SUCCESS);
+    std::string networkId = "networkId";
+    status = kvdbServiceImpl_->GetSwitch(appId, networkId, switchData);
+    EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+}
+
+/**
+* @tc.name: DoCloudSync
+* @tc.desc: DoCloudSync error function test.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, DoCloudSync, TestSize.Level0)
+{
+    StoreId id1;
+    id1.storeId = "id1";
+    Status status = manager.GetSingleKvStore(create, appId, id1, kvStore);
+    ASSERT_NE(kvStore, nullptr);
+    ASSERT_EQ(status, Status::SUCCESS);
+    StoreMetaData metaData;
+    SyncInfo syncInfo;
+    status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
+    EXPECT_EQ(status, Status::NOT_SUPPORT);
+    syncInfo.devices = {"device1", "device2"};
+    syncInfo.query = "query";
+    metaData.enableCloud = true;
+    status = kvdbServiceImpl_->DoCloudSync(metaData, syncInfo);
+    EXPECT_EQ(status, Status::CLOUD_DISABLED);
+}
+
+/**
+* @tc.name: ConvertDbStatus
+* @tc.desc: ConvertDbStatus test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ConvertDbStatus, TestSize.Level0)
+{
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::BUSY), Status::DB_ERROR);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::DB_ERROR), Status::DB_ERROR);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OK), Status::SUCCESS);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_ARGS), Status::INVALID_ARGUMENT);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_FOUND), Status::KEY_NOT_FOUND);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_VALUE_FIELDS), Status::INVALID_VALUE_FIELDS);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FIELD_TYPE), Status::INVALID_FIELD_TYPE);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::CONSTRAIN_VIOLATION), Status::CONSTRAIN_VIOLATION);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_FORMAT), Status::INVALID_FORMAT);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FORMAT), Status::INVALID_QUERY_FORMAT);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::INVALID_QUERY_FIELD), Status::INVALID_QUERY_FIELD);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::NOT_SUPPORT), Status::NOT_SUPPORT);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::TIME_OUT), Status::TIME_OUT);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::OVER_MAX_LIMITS), Status::OVER_MAX_LIMITS);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::EKEYREVOKED_ERROR), Status::SECURITY_LEVEL_ERROR);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SECURITY_OPTION_CHECK_ERROR), Status::SECURITY_LEVEL_ERROR);
+    EXPECT_EQ(kvdbServiceImpl_->ConvertDbStatus(DBStatus::SCHEMA_VIOLATE_VALUE), Status::ERROR);
+}
+
+/**
+* @tc.name: ConvertDBMode
+* @tc.desc: ConvertDBMode test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ConvertDBMode, TestSize.Level0)
+{
+    auto status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH);
+    EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_ONLY);
+    status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PULL);
+    EXPECT_EQ(status, DBMode::SYNC_MODE_PULL_ONLY);
+    status = kvdbServiceImpl_->ConvertDBMode(SyncMode::PUSH_PULL);
+    EXPECT_EQ(status, DBMode::SYNC_MODE_PUSH_PULL);
+}
+
+/**
+* @tc.name: ConvertGeneralSyncMode
+* @tc.desc: ConvertGeneralSyncMode test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ConvertGeneralSyncMode, TestSize.Level0)
+{
+    auto status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SUBSCRIBE);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_SUBSCRIBE_REMOTE);
+    status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_UNSUBSCRIBE);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_UNSUBSCRIBE_REMOTE);
+    status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, SyncAction::ACTION_SYNC);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PUSH);
+    status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PULL, SyncAction::ACTION_SYNC);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL);
+    status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH_PULL, SyncAction::ACTION_SYNC);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_PULL_PUSH);
+    auto action = static_cast<SyncAction>(SyncAction::ACTION_UNSUBSCRIBE + 1);
+    status = kvdbServiceImpl_->ConvertGeneralSyncMode(SyncMode::PUSH, action);
+    EXPECT_EQ(status, GeneralStore::SyncMode::NEARBY_END);
+}
+
+/**
+* @tc.name: ConvertType
+* @tc.desc: ConvertType test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ConvertType, TestSize.Level0)
+{
+    auto status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH);
+    EXPECT_EQ(status, ChangeType::CHANGE_LOCAL);
+    status = kvdbServiceImpl_->ConvertType(SyncMode::PULL);
+    EXPECT_EQ(status, ChangeType::CHANGE_REMOTE);
+    status = kvdbServiceImpl_->ConvertType(SyncMode::PUSH_PULL);
+    EXPECT_EQ(status, ChangeType::CHANGE_ALL);
+    auto action = static_cast<SyncMode>(SyncMode::PUSH_PULL + 1);
+    status = kvdbServiceImpl_->ConvertType(action);
+    EXPECT_EQ(status, ChangeType::CHANGE_ALL);
+}
+
+/**
+* @tc.name: ConvertAction
+* @tc.desc: ConvertAction test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, ConvertAction, TestSize.Level0)
+{
+    auto status = kvdbServiceImpl_->ConvertAction(Action::INSERT);
+    EXPECT_EQ(status, SwitchState::INSERT);
+    status = kvdbServiceImpl_->ConvertAction(Action::UPDATE);
+    EXPECT_EQ(status, SwitchState::UPDATE);
+    status = kvdbServiceImpl_->ConvertAction(Action::DELETE);
+    EXPECT_EQ(status, SwitchState::DELETE);
+    auto action = static_cast<Action>(Action::DELETE + 1);
+    status = kvdbServiceImpl_->ConvertAction(action);
+    EXPECT_EQ(status, SwitchState::INSERT);
+}
+
+/**
+* @tc.name: GetSyncMode
+* @tc.desc: GetSyncMode test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvdbServiceImplTest, GetSyncMode, TestSize.Level0)
+{
+    auto status = kvdbServiceImpl_->GetSyncMode(true, true);
+    EXPECT_EQ(status, SyncMode::PUSH_PULL);
+    status = kvdbServiceImpl_->GetSyncMode(true, false);
+    EXPECT_EQ(status, SyncMode::PUSH);
+    status = kvdbServiceImpl_->GetSyncMode(false, true);
+    EXPECT_EQ(status, SyncMode::PULL);
+    status = kvdbServiceImpl_->GetSyncMode(false, false);
+    EXPECT_EQ(status, SyncMode::PUSH_PULL);
 }
 } // namespace DistributedDataTest
-} // namespace OHOS::Test
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/kvdb_service_test.cpp b/datamgr_service/services/distributeddataservice/service/test/kvdb_service_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..026b9c039349a5cf5d5544bdc8b270d98d0d45b9
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/kvdb_service_test.cpp
@@ -0,0 +1,685 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include "log_print.h"
+#include "accesstoken_kit.h"
+#include "auth_delegate.h"
+#include "bootstrap.h"
+#include "crypto_manager.h"
+#include "device_manager_adapter.h"
+#include "directory/directory_manager.h"
+#include "metadata/meta_data_manager.h"
+#include "metadata/secret_key_meta_data.h"
+#include "metadata/store_meta_data.h"
+#include "metadata/store_meta_data_local.h"
+#include "query_helper.h"
+#include "upgrade.h"
+#include "user_delegate.h"
+#include "kvdb_general_store.h"
+#include "kvdb_watcher.h"
+#include "kvdb_notifier_proxy.h"
+#include "kvstore_sync_manager.h"
+#include "kvstore_meta_manager.h"
+
+using namespace testing::ext;
+using namespace DistributedDB;
+using namespace OHOS::DistributedData;
+using StoreMetaData = OHOS::DistributedData::StoreMetaData;
+using DBPassword = DistributedDB::CipherPassword;
+using DBStatus = DistributedDB::DBStatus;
+using Status = OHOS::DistributedKv::Status;
+using KVDBWatcher = OHOS::DistributedKv::KVDBWatcher;
+using KVDBNotifierProxy = OHOS::DistributedKv::KVDBNotifierProxy;
+using QueryHelper = OHOS::DistributedKv::QueryHelper;
+namespace OHOS::Test {
+namespace DistributedDataTest {
+class UpgradeTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp();
+    void TearDown(){};
+protected:
+    static constexpr const char *bundleName = "test_upgrade";
+    static constexpr const char *storeName = "test_upgrade_meta";
+    void InitMetaData();
+    StoreMetaData metaData_;
+};
+
+void UpgradeTest::InitMetaData()
+{
+    metaData_.bundleName = bundleName;
+    metaData_.appId = bundleName;
+    metaData_.user = "0";
+    metaData_.area = OHOS::DistributedKv::EL1;
+    metaData_.instanceId = 0;
+    metaData_.isAutoSync = true;
+    metaData_.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
+    metaData_.storeId = storeName;
+    metaData_.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade";
+    metaData_.securityLevel = DistributedKv::SecurityLevel::S2;
+}
+
+void UpgradeTest::SetUp()
+{
+    Bootstrap::GetInstance().LoadDirectory();
+    InitMetaData();
+}
+
+class KvStoreSyncManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+protected:
+};
+
+class KVDBWatcherTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+protected:
+};
+
+class UserDelegateTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+protected:
+};
+
+class QueryHelperTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+protected:
+};
+
+class AuthHandlerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+protected:
+};
+
+/**
+* @tc.name: UpdateStore
+* @tc.desc: UpdateStore test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(UpgradeTest, UpdateStore, TestSize.Level0)
+{
+    DistributedKv::Upgrade upgrade;
+    StoreMetaData oldMeta = metaData_;
+    oldMeta.version = 1;
+    oldMeta.storeType = DistributedKv::KvStoreType::DEVICE_COLLABORATION;
+    oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
+    std::vector<uint8_t> password = {0x01, 0x02, 0x03};
+    auto dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
+
+    oldMeta.version = StoreMetaData::CURRENT_VERSION;
+    dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
+
+    oldMeta.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
+    DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
+        return "testexporter";
+    };
+    upgrade.exporter_ = exporter;
+    dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
+
+    oldMeta.version = 1;
+    DistributedKv::Upgrade::Cleaner cleaner = [](const StoreMetaData &meta) -> DistributedKv::Status {
+        return DistributedKv::Status::SUCCESS;
+    };
+    upgrade.cleaner_ = cleaner;
+    upgrade.exporter_ = nullptr;
+    upgrade.UpdatePassword(metaData_, password);
+    dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
+
+    metaData_.isEncrypt = true;
+    upgrade.UpdatePassword(metaData_, password);
+    EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
+    EXPECT_TRUE(upgrade.RegisterCleaner(oldMeta.version, cleaner));
+    dbStatus = upgrade.UpdateStore(oldMeta, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::DB_ERROR);
+
+    StoreMetaData oldMetas = metaData_;
+    dbStatus = upgrade.UpdateStore(oldMetas, metaData_, password);
+    EXPECT_EQ(dbStatus, DBStatus::OK);
+}
+
+/**
+* @tc.name: ExportStore
+* @tc.desc: ExportStore test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(UpgradeTest, ExportStore, TestSize.Level0)
+{
+    DistributedKv::Upgrade upgrade;
+    StoreMetaData oldMeta = metaData_;
+    auto dbStatus = upgrade.ExportStore(oldMeta, metaData_);
+    EXPECT_EQ(dbStatus, DBStatus::OK);
+
+    oldMeta.dataDir = "/data/service/el1/public/database/" + std::string(bundleName) + "/kvdb/upgrade/old";
+    dbStatus = upgrade.ExportStore(oldMeta, metaData_);
+    EXPECT_EQ(dbStatus, DBStatus::NOT_SUPPORT);
+
+    DistributedKv::Upgrade::Exporter exporter = [](const StoreMetaData &, DBPassword &) {
+        return "testexporter";
+    };
+    EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, exporter));
+    dbStatus = upgrade.ExportStore(oldMeta, metaData_);
+    EXPECT_EQ(dbStatus, DBStatus::OK);
+
+    DistributedKv::Upgrade::Exporter test = [](const StoreMetaData &, DBPassword &) {
+        return "";
+    };
+    EXPECT_TRUE(upgrade.RegisterExporter(oldMeta.version, test));
+    dbStatus = upgrade.ExportStore(oldMeta, metaData_);
+    EXPECT_EQ(dbStatus, DBStatus::NOT_FOUND);
+}
+
+/**
+* @tc.name: GetEncryptedUuidByMeta
+* @tc.desc: GetEncryptedUuidByMeta test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(UpgradeTest, GetEncryptedUuidByMeta, TestSize.Level0)
+{
+    DistributedKv::Upgrade upgrade;
+    auto dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
+    EXPECT_EQ(dbStatus, metaData_.deviceId);
+    metaData_.appId = "";
+    dbStatus = upgrade.GetEncryptedUuidByMeta(metaData_);
+    EXPECT_EQ(dbStatus, metaData_.appId);
+}
+
+/**
+* @tc.name: AddSyncOperation
+* @tc.desc: AddSyncOperation test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvStoreSyncManagerTest, AddSyncOperation, TestSize.Level0)
+{
+    DistributedKv::KvStoreSyncManager syncManager;
+    uintptr_t syncId = 0;
+    DistributedKv::KvStoreSyncManager::SyncFunc syncFunc = nullptr;
+    DistributedKv::KvStoreSyncManager::SyncEnd syncEnd = nullptr;
+    auto kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
+    EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
+    syncId = 1;
+    kvStatus = syncManager.AddSyncOperation(syncId, 0, syncFunc, syncEnd);
+    EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
+    syncFunc = [](const DistributedKv::KvStoreSyncManager::SyncEnd &callback) -> Status {
+        std::map<std::string, DBStatus> status_map =
+            {{"key1", DBStatus::OK}, {"key2", DBStatus::DB_ERROR}};
+        callback(status_map);
+        return Status::SUCCESS;
+    };
+    kvStatus = syncManager.AddSyncOperation(0, 0, syncFunc, syncEnd);
+    EXPECT_EQ(kvStatus, Status::INVALID_ARGUMENT);
+}
+
+/**
+* @tc.name: RemoveSyncOperation
+* @tc.desc: RemoveSyncOperation test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvStoreSyncManagerTest, RemoveSyncOperation, TestSize.Level0)
+{
+    DistributedKv::KvStoreSyncManager syncManager;
+    uintptr_t syncId = 0;
+    auto kvStatus = syncManager.RemoveSyncOperation(syncId);
+    EXPECT_EQ(kvStatus, Status::ERROR);
+}
+
+/**
+* @tc.name: DoRemoveSyncingOp
+* @tc.desc: DoRemoveSyncingOp test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KvStoreSyncManagerTest, GetTimeoutSyncOps, TestSize.Level0)
+{
+    DistributedKv::KvStoreSyncManager syncManager;
+    DistributedKv::KvStoreSyncManager::TimePoint currentTime = std::chrono::steady_clock::now();
+    DistributedKv::KvStoreSyncManager::KvSyncOperation syncOp;
+    syncOp.syncId = 1;
+    syncOp.beginTime = std::chrono::steady_clock::now() + std::chrono::milliseconds(1);
+    std::list<DistributedKv::KvStoreSyncManager::KvSyncOperation> syncOps;
+
+    EXPECT_TRUE(syncManager.realtimeSyncingOps_.empty());
+    EXPECT_TRUE(syncManager.scheduleSyncOps_.empty());
+    auto kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
+    EXPECT_EQ(kvStatus, false);
+    syncManager.realtimeSyncingOps_.push_back(syncOp);
+    kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
+    EXPECT_EQ(kvStatus, false);
+    syncManager.realtimeSyncingOps_ = syncOps;
+    syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
+    kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
+    EXPECT_EQ(kvStatus, false);
+
+    syncManager.realtimeSyncingOps_.push_back(syncOp);
+    syncManager.scheduleSyncOps_.insert(std::make_pair(syncOp.beginTime, syncOp));
+    EXPECT_TRUE(!syncManager.realtimeSyncingOps_.empty());
+    EXPECT_TRUE(!syncManager.scheduleSyncOps_.empty());
+    kvStatus = syncManager.GetTimeoutSyncOps(currentTime, syncOps);
+    EXPECT_EQ(kvStatus, true);
+}
+
+/**
+* @tc.name: KVDBWatcher
+* @tc.desc: KVDBWatcher test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBWatcherTest, KVDBWatcher, TestSize.Level0)
+{
+    GeneralWatcher::Origin origin;
+    GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
+    GeneralWatcher::ChangeInfo values;
+    std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
+    sptr<OHOS::DistributedKv::IKvStoreObserver> observer;
+    watcher->SetObserver(observer);
+    EXPECT_EQ(watcher->observer_, nullptr);
+    auto result = watcher->OnChange(origin, primaryFields, std::move(values));
+    EXPECT_EQ(result, GeneralError::E_OK);
+    GeneralWatcher::Fields fields;
+    GeneralWatcher::ChangeData data;
+    result = watcher->OnChange(origin, fields, std::move(data));
+    EXPECT_EQ(result, GeneralError::E_OK);
+}
+
+/**
+* @tc.name: ConvertToEntries
+* @tc.desc: ConvertToEntries test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBWatcherTest, ConvertToEntries, TestSize.Level0)
+{
+    std::vector<Values> values;
+    Values info1;
+    info1.emplace_back(Bytes({1, 2, 3}));
+    info1.emplace_back(Bytes({4, 5, 6}));
+    values.emplace_back(info1);
+    Values info2;
+    info2.emplace_back(Bytes({7, 8, 9}));
+    info2.emplace_back(Bytes({10, 11, 12}));
+    values.emplace_back(info2);
+    Values info3;
+    info3.emplace_back(Bytes({16, 17, 18}));
+    info3.emplace_back(int64_t(1));
+    values.emplace_back(info3);
+    Values info4;
+    info4.emplace_back(int64_t(1));
+    info4.emplace_back(Bytes({19, 20, 21}));
+    values.emplace_back(info4);
+    Values info5;
+    info5.emplace_back(int64_t(1));
+    info5.emplace_back(int64_t(1));
+    values.emplace_back(info5);
+    std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
+    auto result = watcher->ConvertToEntries(values);
+    EXPECT_EQ(result.size(), 2);
+    EXPECT_EQ(result[0].key, Bytes({1, 2, 3}));
+    EXPECT_EQ(result[0].value, Bytes({4, 5, 6}));
+    EXPECT_EQ(result[1].key, Bytes({7, 8, 9}));
+    EXPECT_EQ(result[1].value, Bytes({10, 11, 12}));
+}
+
+/**
+* @tc.name: ConvertToKeys
+* @tc.desc: ConvertToKeys test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(KVDBWatcherTest, ConvertToKeys, TestSize.Level0)
+{
+    std::vector<GeneralWatcher::PRIValue> values = { "key1", 123, "key3", 456, "key5" };
+    std::shared_ptr<KVDBWatcher> watcher = std::make_shared<KVDBWatcher>();
+    auto result = watcher->ConvertToKeys(values);
+    EXPECT_EQ(result.size(), 3);
+    EXPECT_EQ(result[0], "key1");
+    EXPECT_EQ(result[1], "key3");
+    EXPECT_EQ(result[2], "key5");
+}
+
+/**
+* @tc.name: UserDelegate
+* @tc.desc: UserDelegate test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(UserDelegateTest, UserDelegate, TestSize.Level0)
+{
+    std::shared_ptr<UserDelegate> userDelegate = std::make_shared<UserDelegate>();
+    auto result = userDelegate->GetLocalUserStatus();
+    EXPECT_EQ(result.size(), 0);
+    std::string deviceId = "";
+    result = userDelegate->GetRemoteUserStatus(deviceId);
+    EXPECT_TRUE(deviceId.empty());
+    EXPECT_TRUE(result.empty());
+    deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
+    result = userDelegate->GetRemoteUserStatus(deviceId);
+    EXPECT_EQ(result.size(), 0);
+}
+
+/**
+* @tc.name: StringToDbQuery
+* @tc.desc: StringToDbQuery test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, StringToDbQuery, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    bool isSuccess = false;
+    std::string query = "";
+    auto result = queryHelper->StringToDbQuery(query, isSuccess);
+    EXPECT_TRUE(isSuccess);
+    std::string querys(5 * 1024, 'a');
+    query = "querys" + querys;
+    result = queryHelper->StringToDbQuery(query, isSuccess);
+    EXPECT_FALSE(isSuccess);
+    query = "query";
+    result = queryHelper->StringToDbQuery(query, isSuccess);
+    EXPECT_FALSE(isSuccess);
+}
+
+/**
+* @tc.name: Handle001
+* @tc.desc: Handle test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, Handle001, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
+    int pointer = 0;
+    int end = 1;
+    int ends = 4;
+    DistributedDB::Query dbQuery;
+    EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
+
+    pointer = 0;
+    words = {"INTEGER", "LONG", "DOUBLE", "STRING"};
+    EXPECT_FALSE(queryHelper->Handle(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleExtra(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleEqualTo(words, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleNotEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotEqualTo(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleGreaterThan(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThan(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleLessThan(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThan(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleGreaterThanOrEqualTo(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleLessThanOrEqualTo(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLessThanOrEqualTo(words, pointer, end, dbQuery));
+}
+
+/**
+* @tc.name: Handle002
+* @tc.desc: Handle test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, Handle002, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4"};
+    int pointer = 1;
+    int end = 1;
+    int ends = 4;
+    DistributedDB::Query dbQuery;
+    EXPECT_TRUE(queryHelper->HandleIsNull(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleIsNull(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleIsNotNull(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleIsNotNull(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleLike(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLike(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleNotLike(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotLike(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleOrderByAsc(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleOrderByAsc(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleOrderByDesc(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleOrderByDesc(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleOrderByWriteTime(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleOrderByWriteTime(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleLimit(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleLimit(words, pointer, end, dbQuery));
+    pointer = 0;
+    EXPECT_TRUE(queryHelper->HandleKeyPrefix(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleKeyPrefix(words, pointer, end, dbQuery));
+}
+
+/**
+* @tc.name: Handle003
+* @tc.desc: Handle test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, Handle003, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
+    std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
+    int pointer = 0;
+    int end = 1;
+    int ends = 5;
+    DistributedDB::Query dbQuery;
+    EXPECT_FALSE(queryHelper->HandleIn(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleIn(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleIn(wordss, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleIn(wordss, pointer, ends, dbQuery));
+    pointer = 0;
+    EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotIn(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleNotIn(wordss, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleNotIn(wordss, pointer, ends, dbQuery));
+}
+
+/**
+* @tc.name: Handle004
+* @tc.desc: Handle test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, Handle004, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::vector<std::string> words = {"query0", "query1", "query2", "query3", "query4", "query5"};
+    std::vector<std::string> wordss = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
+    int pointer = 2;
+    int end = 3;
+    int ends = 5;
+    DistributedDB::Query dbQuery;
+    EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, ends, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleInKeys(words, pointer, end, dbQuery));
+    EXPECT_FALSE(queryHelper->HandleInKeys(wordss, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleInKeys(wordss, pointer, ends, dbQuery));
+    pointer = 3;
+    EXPECT_FALSE(queryHelper->HandleSetSuggestIndex(wordss, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleSetSuggestIndex(wordss, pointer, ends, dbQuery));
+    pointer = 3;
+    EXPECT_FALSE(queryHelper->HandleDeviceId(wordss, pointer, end, dbQuery));
+    EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
+    queryHelper->hasPrefixKey_ = true;
+    pointer = 3;
+    EXPECT_TRUE(queryHelper->HandleDeviceId(wordss, pointer, ends, dbQuery));
+}
+
+/**
+* @tc.name: StringTo
+* @tc.desc: StringTo test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, StringTo, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::string word = "true";
+    EXPECT_TRUE(queryHelper->StringToBoolean(word));
+    word = "false";
+    EXPECT_FALSE(queryHelper->StringToBoolean(word));
+    word = "BOOL";
+    EXPECT_FALSE(queryHelper->StringToBoolean(word));
+
+    word = "^EMPTY_STRING";
+    auto result = queryHelper->StringToString(word);
+    EXPECT_EQ(result, "");
+    word = "START";
+    result = queryHelper->StringToString(word);
+    EXPECT_EQ(result, "START");
+    word = "START^^START";
+    result = queryHelper->StringToString(word);
+    EXPECT_EQ(result, "START START");
+    word = "START(^)START";
+    result = queryHelper->StringToString(word);
+    EXPECT_EQ(result, "START^START");
+}
+
+/**
+* @tc.name: Get
+* @tc.desc: Get test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(QueryHelperTest, Get, TestSize.Level0)
+{
+    std::shared_ptr<QueryHelper> queryHelper = std::make_shared<QueryHelper>();
+    std::vector<std::string> words = {"1", "2", "3", "4", "5", "^END"};
+    int elementPointer = 0;
+    int end = 5;
+    std::vector<int> ret = {1, 2, 3, 4, 5};
+    auto result = queryHelper->GetIntegerList(words, elementPointer, end);
+    EXPECT_EQ(result, ret);
+    elementPointer = 6;
+    ret = {};
+    result = queryHelper->GetIntegerList(words, elementPointer, end);
+    EXPECT_EQ(result, ret);
+
+    elementPointer = 0;
+    std::vector<int64_t> ret1 = {1, 2, 3, 4, 5};
+    auto result1 = queryHelper->GetLongList(words, elementPointer, end);
+    EXPECT_EQ(result1, ret1);
+    elementPointer = 6;
+    ret1 = {};
+    result1 = queryHelper->GetLongList(words, elementPointer, end);
+    EXPECT_EQ(result1, ret1);
+
+    elementPointer = 0;
+    std::vector<double> ret2 = {1, 2, 3, 4, 5};
+    auto result2 = queryHelper->GetDoubleList(words, elementPointer, end);
+    EXPECT_EQ(result2, ret2);
+    elementPointer = 6;
+    ret2 = {};
+    result2 = queryHelper->GetDoubleList(words, elementPointer, end);
+    EXPECT_EQ(result2, ret2);
+
+    std::vector<std::string> words1 = {"^NOT_IN", "INTEGER", "LONG", "^START", "STRING", "^END"};
+    elementPointer = 0;
+    std::vector<std::string> ret3 = { "^NOT_IN", "INTEGER", "LONG", "^START", "STRING" };
+    auto result3 = queryHelper->GetStringList(words1, elementPointer, end);
+    EXPECT_EQ(result3, ret3);
+    elementPointer = 6;
+    ret3 = {};
+    result3 = queryHelper->GetStringList(words1, elementPointer, end);
+    EXPECT_EQ(result3, ret3);
+}
+
+/**
+* @tc.name: AuthHandler
+* @tc.desc: AuthHandler test the return result of input with different values.
+* @tc.type: FUNC
+* @tc.author: SQL
+*/
+HWTEST_F(AuthHandlerTest, AuthHandler, TestSize.Level0)
+{
+    int localUserId = 0;
+    int peerUserId = 0;
+    std::string peerDeviceId = "";
+    int32_t authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
+    bool isSend = false;
+    auto result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_FALSE(result);
+    authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
+    result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_TRUE(result);
+
+    authType = static_cast<int32_t>(DistributedKv::AuthType::IDENTICAL_ACCOUNT);
+    peerDeviceId = "peerDeviceId";
+    result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_FALSE(result);
+
+    authType = static_cast<int32_t>(DistributedKv::AuthType::DEFAULT);
+    result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_TRUE(result);
+
+    localUserId = 1;
+    result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_FALSE(result);
+
+    peerUserId = 1;
+    result = AuthDelegate::GetInstance()->CheckAccess(localUserId, peerUserId, peerDeviceId, authType, isSend);
+    EXPECT_FALSE(result);
+}
+} // namespace DistributedDataTest
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/BUILD.gn b/datamgr_service/services/distributeddataservice/service/test/mock/BUILD.gn
index 4a458579a002f38c08e98e89e9bf2ef13a45de6a..2feaaa791831660d4eb32c5db3ba666dd4364b9e 100644
--- a/datamgr_service/services/distributeddataservice/service/test/mock/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/BUILD.gn
@@ -37,6 +37,7 @@ ohos_static_library("distributeddata_mock_static") {
     "db_change_data_mock.cpp",
     "db_store_mock.cpp",
     "general_store_mock.cpp",
+    "kv_store_nb_delegate_mock.cpp",
   ]
 
   external_deps = [
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp
index acb05513dc62d5049caed4623d88b668288a6a24..6466dd56c42129bffb3b4fd0e1e969b3384638a8 100644
--- a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.cpp
@@ -17,6 +17,10 @@
 namespace OHOS {
 namespace DistributedData {
 using namespace DistributedDB;
+DBStatus DBStoreMock::Reset()
+{
+    return OK;
+}
 DBStatus DBStoreMock::Get(const Key &key, Value &value) const
 {
     return Get(entries_, key, value);
@@ -263,7 +267,7 @@ DBStatus DBStoreMock::GetEntries(ConcurrentMap<Key, Value> &store, const Key &ke
     store.ForEach([&entries, &keyPrefix](const Key &key, Value &value) {
         auto it = std::search(key.begin(), key.end(), keyPrefix.begin(), keyPrefix.end());
         if (it == key.begin()) {
-            entries.push_back({key, value});  
+            entries.push_back({key, value});
         }
         return false;
     });
@@ -356,12 +360,13 @@ std::pair<DBStatus, std::map<std::string, std::string>> DBStoreMock::GetCloudVer
 {
     return { NOT_SUPPORT, {} };
 }
-DBStatus DBStoreMock::SetReceiveDataInterceptor(const DataInterceptor &interceptor)
+
+DBStatus DBStoreMock::SetCloudSyncConfig(const CloudSyncConfig &config)
 {
     return NOT_SUPPORT;
 }
 
-DBStatus DBStoreMock::SetCloudSyncConfig(const CloudSyncConfig &config)
+DBStatus DBStoreMock::SetReceiveDataInterceptor(const DataInterceptor &interceptor)
 {
     return NOT_SUPPORT;
 }
@@ -370,9 +375,15 @@ DBStatus DBStoreMock::GetDeviceEntries(const std::string &device, std::vector<En
 {
     return NOT_SUPPORT;
 }
-DBStatus DBStoreMock::Reset()
+
+DBStatus DBStoreMock::Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess)
 {
-    return OK;
+    return NOT_SUPPORT;
 }
+
+DBStatus DBStoreMock::CancelSync(uint32_t syncId)
+{
+    return NOT_SUPPORT;
+};
 } // namespace DistributedData
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h
index 051ef0459c01425bba1a7c51270b730a7a2fb6ae..07b36a03027f85963884826e587850f93998c30f 100644
--- a/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/db_store_mock.h
@@ -16,11 +16,13 @@
 #define OHOS_DISTRIBUTEDDATA_SERVICE_TEST_DB_STORE_MOCK_H
 #include "kv_store_nb_delegate.h"
 #include "concurrent_map.h"
+#include "store_types.h"
 namespace OHOS {
 namespace DistributedData {
 class DBStoreMock : public DistributedDB::KvStoreNbDelegate {
 public:
     using DBStatus = DistributedDB::DBStatus;
+    DBStatus Reset();
     using Entry = DistributedDB::Entry;
     using Key = DistributedDB::Key;
     using Value = DistributedDB::Value;
@@ -44,8 +46,10 @@ public:
     using CloudSyncOption = DistributedDB::CloudSyncOption;
     using SyncProcessCallback = DistributedDB::SyncProcessCallback;
     using GenerateCloudVersionCallback = DistributedDB::GenerateCloudVersionCallback;
-    using DataInterceptor = DistributedDB::DataInterceptor;
     using CloudSyncConfig = DistributedDB::CloudSyncConfig;
+    using DataInterceptor = DistributedDB::DataInterceptor;
+    using DeviceSyncOption = DistributedDB::DeviceSyncOption;
+    using DeviceSyncProcessCallback = DistributedDB::DeviceSyncProcessCallback;
     DBStatus Get(const Key &key, Value &value) const override;
     DBStatus GetEntries(const Key &keyPrefix, std::vector<Entry> &entries) const override;
     DBStatus GetEntries(const Key &keyPrefix, KvStoreResultSet *&resultSet) const override;
@@ -107,10 +111,11 @@ public:
     int32_t GetTaskCount() override;
     void SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback) override;
     std::pair<DBStatus, std::map<std::string, std::string>> GetCloudVersion(const std::string &device) override;
-    DBStatus SetReceiveDataInterceptor(const DataInterceptor &interceptor) override;
     DBStatus SetCloudSyncConfig(const CloudSyncConfig &config) override;
+    DBStatus SetReceiveDataInterceptor(const DataInterceptor &interceptor) override;
     DBStatus GetDeviceEntries(const std::string &device, std::vector<Entry> &entries) const override;
-    DBStatus Reset();
+    DBStatus Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess) override;
+    DBStatus CancelSync(uint32_t syncId) override;
 private:
     static const uint32_t DEFAULT_SIZE = 0;
     DBStatus Get(ConcurrentMap<Key, Value> &store, const Key &key, Value &value) const;
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.cpp b/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.cpp
index 748c022460587bf4d3b1f8432a61f85f14bf1d28..a3d3b7f93ee0920c46d0d35f3f6cbb6c4e598d22 100644
--- a/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.cpp
@@ -74,9 +74,9 @@ int32_t GeneralStoreMock::Delete(const std::string &table, const std::string &sq
     return 0;
 }
 
-std::shared_ptr<Cursor> GeneralStoreMock::Query(const std::string &table, GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> GeneralStoreMock::Query(const std::string &table, GenQuery &query)
 {
-    return nullptr;
+    return {GeneralError::E_NOT_SUPPORT, nullptr};
 }
 
 int32_t GeneralStoreMock::Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm)
@@ -84,9 +84,9 @@ int32_t GeneralStoreMock::Sync(const Devices &devices, GenQuery &query, DetailAs
     return 0;
 }
 
-std::shared_ptr<Cursor> GeneralStoreMock::PreSharing(GenQuery &query)
+std::pair<int32_t, std::shared_ptr<Cursor>> GeneralStoreMock::PreSharing(GenQuery &query)
 {
-    return nullptr;
+    return {GeneralError::E_NOT_SUPPORT, nullptr};
 }
 
 int32_t GeneralStoreMock::Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName)
@@ -114,17 +114,7 @@ int32_t GeneralStoreMock::UnregisterDetailProgressObserver()
     return 0;
 }
 
-int32_t GeneralStoreMock::OnChange(const GeneralWatcher::Origin& origin, const GeneralWatcher::PRIFields& primaries,
-    GeneralWatcher::ChangeInfo&& changeInfo)
-{
-    if (watcher_ != nullptr) {
-        watcher_->OnChange(origin, primaries, std::move(changeInfo));
-        return GeneralError::E_OK;
-    }
-    return GeneralError::E_ERROR;
-}
-
-int32_t GeneralStoreMock::Close()
+int32_t GeneralStoreMock::Close(bool isForce)
 {
     return 0;
 }
@@ -149,9 +139,10 @@ int32_t GeneralStoreMock::MergeMigratedData(const std::string &tableName, VBucke
     return 0;
 }
 
-std::shared_ptr<Cursor> GeneralStoreMock::Query(const std::string &table, const std::string &sql, Values &&args)
+std::pair<int32_t, std::shared_ptr<Cursor>> GeneralStoreMock::Query(const std::string &table, const std::string &sql,
+    Values &&args)
 {
-    return cursor_;
+    return {GeneralError::E_OK, cursor_};
 }
 
 std::vector<std::string> GeneralStoreMock::GetWaterVersion(const std::string &deviceId)
@@ -164,6 +155,26 @@ void GeneralStoreMock::MakeCursor(const std::map<std::string, Value> &entry)
     auto resultSet = std::make_shared<CursorMock::ResultSet>(1, entry);
     cursor_ = std::make_shared<CursorMock>(resultSet);
 }
+
+std::pair<int32_t, uint32_t> GeneralStoreMock::LockCloudDB()
+{
+    return { E_OK, 0 };
+}
+
+int32_t GeneralStoreMock::UnLockCloudDB()
+{
+    return E_OK;
+}
+
+void GeneralStoreMock::SetExecutor(std::shared_ptr<Executor> executor)
+{
+    return;
+}
+int32_t GeneralStoreMock::OnChange(const GeneralWatcher::Origin &origin, const GeneralWatcher::PRIFields &primaries,
+    GeneralWatcher::ChangeInfo &&changeInfo)
+{
+    return 0;
+}
 GeneralStoreMock::GeneralStoreMock() {}
 } // namespace DistributedData
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.h b/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.h
index 45773e34638f6a3e831fa51bba3b5e641ab553f1..bf16a2c8f1724d46e91ff0d6df3c08f01f7e7d4e 100644
--- a/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.h
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/general_store_mock.h
@@ -47,22 +47,26 @@ public:
         Values &&conditions) override;
     int32_t Replace(const std::string &table, VBucket &&value) override;
     int32_t Delete(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, const std::string &sql, Values &&args) override;
-    std::shared_ptr<Cursor> Query(const std::string &table, GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, const std::string &sql,
+        Values &&args) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> Query(const std::string &table, GenQuery &query) override;
     int32_t Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm) override;
-    std::shared_ptr<Cursor> PreSharing(GenQuery &query) override;
+    std::pair<int32_t, std::shared_ptr<Cursor>> PreSharing(GenQuery &query) override;
     int32_t Clean(const std::vector<std::string> &devices, int32_t mode, const std::string &tableName) override;
     int32_t Watch(int32_t origin, Watcher &watcher) override;
     int32_t Unwatch(int32_t origin, Watcher &watcher) override;
     int32_t RegisterDetailProgressObserver(DetailAsync async) override;
     int32_t UnregisterDetailProgressObserver() override;
-    int32_t Close() override;
+    int32_t Close(bool isForce) override;
     int32_t AddRef() override;
     int32_t Release() override;
     int32_t BindSnapshots(std::shared_ptr<std::map<std::string, std::shared_ptr<Snapshot>>> bindAssets) override;
     int32_t MergeMigratedData(const std::string &tableName, VBuckets &&values) override;
     std::vector<std::string> GetWaterVersion(const std::string &deviceId) override;
+    void SetExecutor(std::shared_ptr<Executor> executor) override;
     void MakeCursor(const std::map<std::string, Value> &entry);
+    std::pair<int32_t, uint32_t> LockCloudDB() override;
+    int32_t UnLockCloudDB() override;
     int32_t OnChange(const GeneralWatcher::Origin &origin, const GeneralWatcher::PRIFields &primaries,
         GeneralWatcher::ChangeInfo &&changeInfo);
 
@@ -70,7 +74,7 @@ public:
 
 private:
     std::shared_ptr<Cursor> cursor_ = nullptr;
-   Watcher* watcher_ = nullptr;
+    Watcher* watcher_ = nullptr;
 };
 } // namespace DistributedData
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.cpp b/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e4ec970be4f9a7c68604566ab31385f642e57bc0
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.cpp
@@ -0,0 +1,37 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "general_watcher_mock.h"
+
+namespace OHOS::DistributedData {
+bool MockQuery::IsEqual(uint64_t tid)
+{
+    return (tid == TYPE_ID) && lastResult;
+}
+
+std::vector<std::string> MockQuery::GetTables()
+{
+    return tables_;
+}
+
+int32_t MockGeneralWatcher::OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values)
+{
+    return GeneralError::E_OK;
+}
+
+int32_t MockGeneralWatcher::OnChange(const Origin &origin, const Fields &fields, ChangeData &&datas)
+{
+    return GeneralError::E_OK;
+}
+} // OHOS::DistributedData
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.h b/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..27748455653f095d071d3761fc4cf5106516e079
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/general_watcher_mock.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef OHOS_DISTRIBUTEDDATA_SERVICE_TEST_GENERAL_WATCH_MOCK_H
+#define OHOS_DISTRIBUTEDDATA_SERVICE_TEST_GENERAL_WATCH_MOCK_H
+
+#include "store/general_value.h"
+#include "store/general_watcher.h"
+
+namespace OHOS::DistributedData {
+class MockQuery : public GenQuery {
+public:
+    ~MockQuery() = default;
+    static constexpr uint64_t TYPE_ID = 0x20000001;
+    std::vector<std::string> tables_;
+    bool lastResult = false;
+    bool IsEqual(uint64_t tid) override;
+
+    std::vector<std::string> GetTables() override;
+};
+
+class MockGeneralWatcher : public DistributedData::GeneralWatcher {
+public:
+    int32_t OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values) override;
+
+    int32_t OnChange(const Origin &origin, const Fields &fields, ChangeData &&datas) override;
+};
+} // OHOS::DistributedData
+#endif
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.cpp b/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c402f961d30586660275353a1a088c02ec8e1b8
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.cpp
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "kv_store_nb_delegate_mock.h"
+#include "store_types.h"
+namespace DistributedDB {
+DBStatus KvStoreNbDelegateMock::Get(const Key &key, Value &value) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetEntries(const Key &keyPrefix, std::vector<Entry> &entries) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetEntries(const Key &keyPrefix, KvStoreResultSet *&resultSet) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetEntries(const Query &query, std::vector<Entry> &entries) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetEntries(const Query &query, KvStoreResultSet *&resultSet) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetCount(const Query &query, int &count) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::CloseResultSet(KvStoreResultSet *&resultSet)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Put(const Key &key, const Value &value)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::PutBatch(const std::vector<Entry> &entries)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::DeleteBatch(const std::vector<Key> &keys)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Delete(const Key &key)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetLocal(const Key &key, Value &value) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetLocalEntries(const Key &keyPrefix, std::vector<Entry> &entries) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::PutLocal(const Key &key, const Value &value)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::DeleteLocal(const Key &key)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::PublishLocal(const Key &key, bool deleteLocal, bool updateTimestamp,
+    const KvStoreNbPublishOnConflict &onConflict)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::UnpublishToLocal(const Key &key, bool deletePublic, bool updateTimestamp)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::RegisterObserver(const Key &key, unsigned int mode,
+    KvStoreObserver *observer)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::UnRegisterObserver(const KvStoreObserver *observer)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::RemoveDeviceData(const std::string &device)
+{
+    return DBStatus::OK;
+}
+
+std::string KvStoreNbDelegateMock::GetStoreId() const
+{
+    return "ok";
+}
+
+DBStatus KvStoreNbDelegateMock::Sync(const std::vector<std::string> &devices, SyncMode mode,
+    const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+    bool wait)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Pragma(PragmaCmd cmd, PragmaData &paramData)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetConflictNotifier(int conflictType,
+    const KvStoreNbConflictNotifier &notifier)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Rekey(const CipherPassword &password)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Export(const std::string &filePath,
+    const CipherPassword &passwd, bool force)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Import(const std::string &filePath, const CipherPassword &passwd)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::StartTransaction()
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Commit()
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Rollback()
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::PutLocalBatch(const std::vector<Entry> &entries)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::DeleteLocalBatch(const std::vector<Key> &keys)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetSecurityOption(SecurityOption &option) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetRemotePushFinishedNotify(const RemotePushFinishedNotifier &notifier)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Sync(const std::vector<std::string> &devices, SyncMode mode,
+    const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+    const Query &query, bool wait)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::CheckIntegrity() const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetEqualIdentifier(const std::string &identifier,
+    const std::vector<std::string> &targets)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetPushDataInterceptor(const PushDataInterceptor &interceptor)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SubscribeRemoteQuery(const std::vector<std::string> &devices,
+    const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+    const Query &query, bool wait)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::UnSubscribeRemoteQuery(const std::vector<std::string> &devices,
+    const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+    const Query &query, bool wait)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::RemoveDeviceData()
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetKeys(const Key &keyPrefix, std::vector<Key> &keys) const
+{
+    return DBStatus::OK;
+}
+
+size_t KvStoreNbDelegateMock::GetSyncDataSize(const std::string &device) const
+{
+    size_t size = 0;
+    return size;
+}
+
+DBStatus KvStoreNbDelegateMock::UpdateKey(const UpdateKeyCallback &callback)
+{
+    return DBStatus::OK;
+}
+
+std::pair<DBStatus, WatermarkInfo> KvStoreNbDelegateMock::GetWatermarkInfo(const std::string &device)
+{
+    std::pair<DBStatus, WatermarkInfo> ret;
+    return ret;
+}
+
+DBStatus KvStoreNbDelegateMock::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetCloudDB(const std::map<std::string, std::shared_ptr<ICloudDb>> &cloudDBs)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetCloudDbSchema(const std::map<std::string, DataBaseSchema> &schema)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::RemoveDeviceData(const std::string &device, ClearMode mode)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::RemoveDeviceData(const std::string &device, const std::string &user, ClearMode mode)
+{
+    return DBStatus::OK;
+}
+
+int32_t KvStoreNbDelegateMock::GetTaskCount()
+{
+    int32_t taskCount = taskCountMock_;
+    return taskCount;
+}
+
+void KvStoreNbDelegateMock::SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback)
+{
+    auto callback_ = callback;
+}
+
+std::pair<DBStatus, std::map<std::string, std::string>> KvStoreNbDelegateMock::GetCloudVersion(
+    const std::string &device)
+{
+    if (device.empty()) {
+        return { DBStatus::OK, {} };
+    } else if (device == "test") {
+        return { DBStatus::DB_ERROR, {} };
+    } else if (device == "device") {
+        return { DBStatus::DB_ERROR, {{device, device}} };
+    } else {
+        return { DBStatus::OK, {{device, device}} };
+    }
+}
+
+DBStatus KvStoreNbDelegateMock::SetReceiveDataInterceptor(const DataInterceptor &interceptor)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::SetCloudSyncConfig(const CloudSyncConfig &config)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::GetDeviceEntries(const std::string &device, std::vector<Entry> &entries) const
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess)
+{
+    return DBStatus::OK;
+}
+
+DBStatus KvStoreNbDelegateMock::CancelSync(uint32_t syncId)
+{
+    return DBStatus::OK;
+}
+} // namespace DistributedDB
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.h b/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..83d935fbf26be9904f7c7301f2343ded34541ccd
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/mock/kv_store_nb_delegate_mock.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KV_STORE_NB_DELEGATE_H_MOCK
+#define KV_STORE_NB_DELEGATE_H_MOCK
+
+#include <functional>
+#include <map>
+#include <string>
+
+#include "cloud/cloud_store_types.h"
+#include "cloud/icloud_db.h"
+#include "intercepted_data.h"
+#include "iprocess_system_api_adapter.h"
+#include "kv_store_nb_delegate.h"
+#include "kv_store_nb_conflict_data.h"
+#include "kv_store_observer.h"
+#include "kv_store_result_set.h"
+#include "query.h"
+#include "store_types.h"
+
+namespace DistributedDB {
+class KvStoreNbDelegateMock : public DistributedDB::KvStoreNbDelegate {
+public:
+    int32_t taskCountMock_ = 0;
+    ~KvStoreNbDelegateMock() = default;
+    DBStatus Get(const Key &key, Value &value) const;
+    DBStatus GetEntries(const Key &keyPrefix, std::vector<Entry> &entries) const;
+    DBStatus GetEntries(const Key &keyPrefix, KvStoreResultSet *&resultSet) const;
+    DBStatus GetEntries(const Query &query, std::vector<Entry> &entries) const;
+    DBStatus GetEntries(const Query &query, KvStoreResultSet *&resultSet) const;
+    DBStatus GetCount(const Query &query, int &count) const;
+    DBStatus CloseResultSet(KvStoreResultSet *&resultSet);
+    DBStatus Put(const Key &key, const Value &value);
+    DBStatus PutBatch(const std::vector<Entry> &entries);
+    DBStatus DeleteBatch(const std::vector<Key> &keys);
+    DBStatus Delete(const Key &key);
+    DBStatus GetLocal(const Key &key, Value &value) const;
+    DBStatus GetLocalEntries(const Key &keyPrefix, std::vector<Entry> &entries) const;
+    DBStatus PutLocal(const Key &key, const Value &value);
+    DBStatus DeleteLocal(const Key &key);
+    DBStatus PublishLocal(const Key &key, bool deleteLocal, bool updateTimestamp,
+        const KvStoreNbPublishOnConflict &onConflict);
+    DBStatus UnpublishToLocal(const Key &key, bool deletePublic, bool updateTimestamp);
+    DBStatus RegisterObserver(const Key &key, unsigned int mode, KvStoreObserver *observer);
+    DBStatus UnRegisterObserver(const KvStoreObserver *observer);
+    DBStatus RemoveDeviceData(const std::string &device);
+    std::string GetStoreId() const;
+    DBStatus Sync(const std::vector<std::string> &devices, SyncMode mode,
+        const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+        bool wait = false);
+    DBStatus Pragma(PragmaCmd cmd, PragmaData &paramData);
+    DBStatus SetConflictNotifier(int conflictType,
+        const KvStoreNbConflictNotifier &notifier);
+    DBStatus Rekey(const CipherPassword &password);
+    DBStatus Export(const std::string &filePath, const CipherPassword &passwd, bool force = false);
+    DBStatus Import(const std::string &filePath, const CipherPassword &passwd);
+    DBStatus StartTransaction();
+    DBStatus Commit();
+    DBStatus Rollback();
+    DBStatus PutLocalBatch(const std::vector<Entry> &entries);
+    DBStatus DeleteLocalBatch(const std::vector<Key> &keys);
+    DBStatus GetSecurityOption(SecurityOption &option) const;
+    DBStatus SetRemotePushFinishedNotify(const RemotePushFinishedNotifier &notifier);
+    DBStatus Sync(const std::vector<std::string> &devices, SyncMode mode,
+        const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+        const Query &query, bool wait);
+    DBStatus CheckIntegrity() const;
+    DBStatus SetEqualIdentifier(const std::string &identifier,
+        const std::vector<std::string> &targets);
+    DBStatus SetPushDataInterceptor(const PushDataInterceptor &interceptor);
+    DBStatus SubscribeRemoteQuery(const std::vector<std::string> &devices,
+        const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+        const Query &query, bool wait);
+    DBStatus UnSubscribeRemoteQuery(const std::vector<std::string> &devices,
+        const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
+        const Query &query, bool wait);
+    DBStatus RemoveDeviceData();
+    DBStatus GetKeys(const Key &keyPrefix, std::vector<Key> &keys) const;
+    size_t GetSyncDataSize(const std::string &device) const;
+    DBStatus UpdateKey(const UpdateKeyCallback &callback);
+    std::pair<DBStatus, WatermarkInfo> GetWatermarkInfo(const std::string &device);
+    DBStatus Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess);
+    DBStatus SetCloudDB(const std::map<std::string, std::shared_ptr<ICloudDb>> &cloudDBs);
+    DBStatus SetCloudDbSchema(const std::map<std::string, DataBaseSchema> &schema);
+    DBStatus RemoveDeviceData(const std::string &device, ClearMode mode);
+    DBStatus RemoveDeviceData(const std::string &device, const std::string &user, ClearMode mode);
+    int32_t GetTaskCount();
+    void SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback);
+    std::pair<DBStatus, std::map<std::string, std::string>> GetCloudVersion(
+        const std::string &device);
+    DBStatus SetReceiveDataInterceptor(const DataInterceptor &interceptor);
+    DBStatus SetCloudSyncConfig(const CloudSyncConfig &config);
+    DBStatus GetDeviceEntries(const std::string &device, std::vector<Entry> &entries) const;
+    DBStatus Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess);
+    DBStatus CancelSync(uint32_t syncId);
+};
+} // namespace DistributedDB
+#endif // KV_STORE_NB_DELEGATE_H_MOCK
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/object_asset_loader_test.cpp b/datamgr_service/services/distributeddataservice/service/test/object_asset_loader_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab44449262ffef3f7615f91296eddeae55b9c6b1
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/object_asset_loader_test.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "ObjectAssetLoaderTest"
+
+#include "object_asset_loader.h"
+#include <gtest/gtest.h>
+#include "snapshot/machine_status.h"
+#include "executor_pool.h"
+
+using namespace testing::ext;
+using namespace OHOS::DistributedObject;
+using namespace OHOS::DistributedData;
+namespace OHOS::Test {
+
+class ObjectAssetLoaderTest : public testing::Test {
+public:
+    void SetUp();
+    void TearDown();
+
+protected:
+    Asset asset_;
+    std::string uri_;
+    int32_t userId_ = 1;
+    std::string bundleName_ = "test_bundleName_1";
+    std::string deviceId_ = "test_deviceId__1";
+};
+
+void ObjectAssetLoaderTest::SetUp()
+{
+    uri_ = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset1.jpg";
+    Asset asset{
+        .name = "test_name",
+        .uri = uri_,
+        .modifyTime = "modifyTime",
+        .size = "size",
+        .hash = "modifyTime_size",
+    };
+    asset_ = asset;
+}
+
+void ObjectAssetLoaderTest::TearDown() {}
+
+/**
+* @tc.name: UploadTest001
+* @tc.desc: Transfer test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, UploadTest001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    auto result = assetLoader->Transfer(userId_, bundleName_, deviceId_, asset_);
+    ASSERT_EQ(result, false);
+}
+
+/**
+* @tc.name: TransferAssetsAsync001
+* @tc.desc: TransferAssetsAsync test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, TransferAssetsAsync001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    std::function<void(bool)> lambdaFunc = [](bool success) {
+        if (success) {}
+    };
+    std::vector<Asset> assets{ asset_ };
+    ASSERT_EQ(assetLoader->executors_, nullptr);
+    assetLoader->TransferAssetsAsync(userId_, bundleName_, deviceId_, assets, lambdaFunc);
+}
+
+/**
+* @tc.name: TransferAssetsAsync002
+* @tc.desc: TransferAssetsAsync test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, TransferAssetsAsync002, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    std::function<void(bool)> lambdaFunc = [](bool success) {
+        if (success) {}
+    };
+    std::vector<Asset> assets{ asset_ };
+    std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(5, 3);
+    ASSERT_NE(executors, nullptr);
+    assetLoader->SetThreadPool(executors);
+    ASSERT_NE(assetLoader->executors_, nullptr);
+    assetLoader->TransferAssetsAsync(userId_, bundleName_, deviceId_, assets, lambdaFunc);
+}
+
+/**
+* @tc.name: FinishTask001
+* @tc.desc: FinishTask test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, FinishTask001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    ASSERT_NE(assetLoader, nullptr);
+    TransferTask task;
+    task.downloadAssets.insert(uri_);
+    assetLoader->FinishTask(asset_.uri, true);
+    ASSERT_TRUE(assetLoader->tasks_.Empty());
+    assetLoader->FinishTask(asset_.uri, false);
+    ASSERT_TRUE(assetLoader->tasks_.Empty());
+}
+
+/**
+* @tc.name: IsDownloading001
+* @tc.desc: IsDownloading test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, IsDownloading001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    assetLoader->downloading_.InsertOrAssign(asset_.uri, asset_.hash);
+    auto result = assetLoader->IsDownloading(asset_);
+    ASSERT_EQ(result, true);
+    assetLoader->downloading_.Erase(asset_.uri);
+    result = assetLoader->IsDownloading(asset_);
+    ASSERT_EQ(result, false);
+}
+
+/**
+* @tc.name: IsDownloaded001
+* @tc.desc: IsDownloaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, IsDownloaded001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    auto result = assetLoader->IsDownloaded(asset_);
+    ASSERT_EQ(result, false);
+    assetLoader->downloaded_.Insert(asset_.uri, "modifyTime_size");
+    result = assetLoader->IsDownloaded(asset_);
+    ASSERT_EQ(result, true);
+}
+
+/**
+* @tc.name: UpdateDownloaded001
+* @tc.desc: UpdateDownloaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, UpdateDownloaded001, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    ASSERT_NE(assetLoader, nullptr);
+    while (!assetLoader->assetQueue_.empty()) {
+        assetLoader->assetQueue_.pop();
+    }
+    assetLoader->UpdateDownloaded(asset_);
+    auto [success, hash] = assetLoader->downloaded_.Find(asset_.uri);
+    ASSERT_TRUE(success);
+    EXPECT_EQ(hash, asset_.hash);
+}
+
+/**
+* @tc.name: UpdateDownloaded002
+* @tc.desc: UpdateDownloaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectAssetLoaderTest, UpdateDownloaded002, TestSize.Level0)
+{
+    auto assetLoader = ObjectAssetLoader::GetInstance();
+    ASSERT_NE(assetLoader, nullptr);
+    while (!assetLoader->assetQueue_.empty()) {
+        assetLoader->assetQueue_.pop();
+    }
+    for (int i = 0; i <= assetLoader->LAST_DOWNLOAD_ASSET_SIZE; i++) {
+        assetLoader->assetQueue_.push(asset_.uri);
+    }
+    assetLoader->UpdateDownloaded(asset_);
+    EXPECT_NE(assetLoader->assetQueue_.size(), ObjectAssetLoader::LAST_DOWNLOAD_ASSET_SIZE);
+    EXPECT_EQ(assetLoader->assetQueue_.size(), ObjectAssetLoader::LAST_DOWNLOAD_ASSET_SIZE + 1);
+    auto [success, hash] = assetLoader->downloaded_.Find(asset_.uri);
+    EXPECT_EQ(success, false);
+    EXPECT_EQ(hash, "");
+}
+} // namespace OHOS::Test
diff --git a/datamgr_service/services/distributeddataservice/service/test/object_asset_machine_test.cpp b/datamgr_service/services/distributeddataservice/service/test/object_asset_machine_test.cpp
index 969122494400b1729b915e82fd879ad839cefe48..c6e34358179beee37619d8a457254b96c197c77c 100644
--- a/datamgr_service/services/distributeddataservice/service/test/object_asset_machine_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/object_asset_machine_test.cpp
@@ -82,37 +82,12 @@ void ObjectAssetMachineTest::TearDown() {}
 
 /**
 * @tc.name: StatusTransfer001
-* @tc.desc: Transfer event.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: whj
-*/
-HWTEST_F(ObjectAssetMachineTest, StatusTransfer001, TestSize.Level0)
-{
-    auto machine = std::make_shared<ObjectAssetMachine>();
-    Asset asset{
-        .name = "test_name",
-        .uri = uri_,
-        .modifyTime = "modifyTime1",
-        .size = "size1",
-        .hash = "modifyTime1_size1",
-    };
-    std::pair<std::string, Asset> changedAsset{ "device_1", asset };
-    changedAssets_[uri_].status = STATUS_STABLE;
-    machine->DFAPostEvent(REMOTE_CHANGED, changedAssets_[uri_], asset, changedAsset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_TRANSFERRING);
-    ASSERT_EQ(changedAssets_[uri_].deviceId, changedAsset.first);
-    ASSERT_EQ(changedAssets_[uri_].asset.hash, asset.hash);
-}
-
-/**
-* @tc.name: StatusTransfer002
 * @tc.desc: Remote changed when transferring.
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: whj
 */
-HWTEST_F(ObjectAssetMachineTest, StatusTransfer002, TestSize.Level0)
+HWTEST_F(ObjectAssetMachineTest, StatusTransfer001, TestSize.Level0)
 {
     auto machine = std::make_shared<ObjectAssetMachine>();
     Asset asset{
@@ -131,40 +106,13 @@ HWTEST_F(ObjectAssetMachineTest, StatusTransfer002, TestSize.Level0)
 }
 
 /**
-* @tc.name: StatusTransfer003
-* @tc.desc: Compensate transfer in conflict scenario.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: whj
-*/
-HWTEST_F(ObjectAssetMachineTest, StatusTransfer003, TestSize.Level0)
-{
-    auto machine = std::make_shared<ObjectAssetMachine>();
-    Asset asset{
-        .name = "test_name",
-        .uri = uri_,
-        .modifyTime = "modifyTime1",
-        .size = "size1",
-        .hash = "modifyTime1_size1",
-    };
-    std::pair<std::string, Asset> changedAsset{ "device_1", asset };
-    changedAssets_[uri_].status = STATUS_WAIT_TRANSFER;
-    changedAssets_[uri_].deviceId = "device_2";
-    changedAssets_[uri_].asset.hash = "modifyTime2_size2";
-    machine->DFAPostEvent(TRANSFER_FINISHED, changedAssets_[uri_], asset, changedAsset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_TRANSFERRING);
-    ASSERT_EQ(changedAssets_[uri_].deviceId, "device_2");
-    ASSERT_EQ(changedAssets_[uri_].asset.hash, "modifyTime2_size2");
-}
-
-/**
-* @tc.name: StatusTransfer004
+* @tc.name: StatusTransfer002
 * @tc.desc: Transfer finished.
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: whj
 */
-HWTEST_F(ObjectAssetMachineTest, StatusTransfer004, TestSize.Level0)
+HWTEST_F(ObjectAssetMachineTest, StatusTransfer002, TestSize.Level0)
 {
     auto machine = std::make_shared<ObjectAssetMachine>();
     Asset asset{
@@ -181,13 +129,13 @@ HWTEST_F(ObjectAssetMachineTest, StatusTransfer004, TestSize.Level0)
 }
 
 /**
-* @tc.name: StatusTransfer005
+* @tc.name: StatusTransfer003
 * @tc.desc: Transfer event
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: nhj
 */
-HWTEST_F(ObjectAssetMachineTest, StatusTransfer005, TestSize.Level0)
+HWTEST_F(ObjectAssetMachineTest, StatusTransfer003, TestSize.Level0)
 {
     auto machine = std::make_shared<ObjectAssetMachine>();
     Asset asset{
@@ -270,46 +218,33 @@ HWTEST_F(ObjectAssetMachineTest, StatusDownload001, TestSize.Level0)
 {
     auto machine = std::make_shared<ObjectAssetMachine>();
     Asset asset{
-        .name = "test_name",
-        .uri = uri_,
-        .modifyTime = "modifyTime1",
-        .size = "size1",
-        .hash = "modifyTime1_size1",
+        .name = "name_006",
+        .uri = "uri_006",
+        .modifyTime = "modifyTime_006",
+        .size = "size_006",
+        .hash = "modifyTime_006_size_006",
     };
-    std::pair<std::string, Asset> changedAsset{ "device_1", asset };
-    machine->DFAPostEvent(DOWNLOAD, changedAssets_[uri_], asset, changedAsset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_DOWNLOADING);
-
-    machine->DFAPostEvent(DOWNLOAD_FINISHED, changedAssets_[uri_], asset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_STABLE);
-}
-
-/**
-* @tc.name: StatusDownload002
-* @tc.desc: Conflict scenario: Download before transfer.
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: nhj
-*/
-HWTEST_F(ObjectAssetMachineTest, StatusDownload002, TestSize.Level0)
-{
-    auto machine = std::make_shared<ObjectAssetMachine>();
-    Asset asset{
-        .name = "test_name",
-        .uri = uri_,
-        .modifyTime = "modifyTime1",
-        .size = "size1",
-        .hash = "modifyTime1_size1",
+    AssetBindInfo AssetBindInfo{
+        .storeName = "store_006",
+        .tableName = "table_006",
+        .primaryKey = {{ "006", "006" }},
+        .field = "attachment_006",
+        .assetName = "asset_006.jpg",
     };
-    std::pair<std::string, Asset> changedAsset{ "device_1", asset };
-    machine->DFAPostEvent(DOWNLOAD, changedAssets_[uri_], asset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_DOWNLOADING);
+    StoreInfo storeInfo {
+        .tokenId = 600,
+        .bundleName = "bundleName_006",
+        .storeName = "store_006",
+        .instanceId = 600,
+        .user = 600,
+    };
+    ChangedAssetInfo changedAssetInfo(asset, AssetBindInfo, storeInfo);
+    std::pair<std::string, Asset> changedAsset{ "device_006", asset };
 
-    machine->DFAPostEvent(REMOTE_CHANGED, changedAssets_[uri_], asset, changedAsset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_WAIT_TRANSFER);
-    ASSERT_EQ(changedAssets_[uri_].asset.hash, asset.hash);
+    machine->DFAPostEvent(DOWNLOAD, changedAssetInfo, asset, changedAsset);
+    ASSERT_EQ(changedAssetInfo.status, STATUS_DOWNLOADING);
 
-    machine->DFAPostEvent(DOWNLOAD_FINISHED, changedAssets_[uri_], asset);
-    ASSERT_EQ(changedAssets_[uri_].status, STATUS_TRANSFERRING);
+    machine->DFAPostEvent(DOWNLOAD_FINISHED, changedAssetInfo, asset);
+    ASSERT_EQ(changedAssetInfo.status, STATUS_STABLE);
 }
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/object_manager_test.cpp b/datamgr_service/services/distributeddataservice/service/test/object_manager_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bccbc22e28dddaa98d1d2f07f9261a49b8261297
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/object_manager_test.cpp
@@ -0,0 +1,893 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "ObjectManagerTest"
+
+#include "object_manager.h"
+#include <gtest/gtest.h>
+#include "snapshot/machine_status.h"
+#include "executor_pool.h"
+#include "object_types.h"
+#include "kv_store_nb_delegate_mock.h"
+#include <ipc_skeleton.h>
+
+using namespace testing::ext;
+using namespace OHOS::DistributedObject;
+using AssetValue = OHOS::CommonType::AssetValue;
+using RestoreStatus = OHOS::DistributedObject::ObjectStoreManager::RestoreStatus;
+namespace OHOS::Test {
+
+class ObjectManagerTest : public testing::Test {
+public:
+    void SetUp();
+    void TearDown();
+
+protected:
+    Asset asset_;
+    std::string uri_;
+    std::string appId_ = "objectManagerTest_appid_1";
+    std::string sessionId_ = "123";
+    std::vector<uint8_t> data_;
+    std::string deviceId_ = "7001005458323933328a258f413b3900";
+    uint64_t sequenceId_ = 10;
+    uint64_t sequenceId_2 = 20;
+    uint64_t sequenceId_3 = 30;
+    std::string userId_ = "100";
+    std::string bundleName_ = "com.examples.hmos.notepad";
+    OHOS::ObjectStore::AssetBindInfo assetBindInfo_;
+    pid_t pid_ = 10;
+    uint32_t tokenId_ = 100;
+    AssetValue assetValue_;
+};
+
+void ObjectManagerTest::SetUp()
+{
+    uri_ = "file:://com.examples.hmos.notepad/data/storage/el2/distributedfiles/dir/asset1.jpg";
+    Asset asset{
+        .name = "test_name",
+        .uri = uri_,
+        .modifyTime = "modifyTime",
+        .size = "size",
+        .hash = "modifyTime_size",
+    };
+    asset_ = asset;
+
+    AssetValue assetValue{
+        .id = "test_name",
+        .name = uri_,
+        .uri = uri_,
+        .createTime = "2024.07.23",
+        .modifyTime = "modifyTime",
+        .size = "size",
+        .hash = "modifyTime_size",
+        .path = "/data/storage/el2",
+    };
+    assetValue_ = assetValue;
+
+    data_.push_back(10); // 10 is for testing
+    data_.push_back(20); // 20 is for testing
+    data_.push_back(30); // 30 is for testing
+
+    OHOS::ObjectStore::AssetBindInfo AssetBindInfo{
+        .storeName = "store_test",
+        .tableName = "table_test",
+        .field = "attachment",
+        .assetName = "asset1.jpg",
+    };
+    assetBindInfo_ = AssetBindInfo;
+}
+
+void ObjectManagerTest::TearDown() {}
+
+/**
+* @tc.name: DeleteNotifier001
+* @tc.desc: DeleteNotifier test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, DeleteNotifier001, TestSize.Level0)
+{
+    auto syncManager = SequenceSyncManager::GetInstance();
+    auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
+}
+
+/**
+* @tc.name: Process001
+* @tc.desc: Process test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, Process001, TestSize.Level0)
+{
+    auto syncManager = SequenceSyncManager::GetInstance();
+    std::map<std::string, DistributedDB::DBStatus> results;
+    results = {{ "test_cloud", DistributedDB::DBStatus::OK }};
+
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    auto result = syncManager->Process(sequenceId_, results, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
+    syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
+    result = syncManager->Process(sequenceId_, results, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
+}
+
+/**
+* @tc.name: DeleteNotifierNoLock001
+* @tc.desc: DeleteNotifierNoLock test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, DeleteNotifierNoLock001, TestSize.Level0)
+{
+    auto syncManager = SequenceSyncManager::GetInstance();
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
+    std::vector<uint64_t> seqIds = {sequenceId_, sequenceId_2, sequenceId_3};
+    std::string userId = "user_1";
+    auto result = syncManager->DeleteNotifierNoLock(sequenceId_, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
+    syncManager->userIdSeqIdRelations_[userId] = seqIds;
+    result = syncManager->DeleteNotifierNoLock(sequenceId_, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_IN_USE);
+}
+
+/**
+* @tc.name: Clear001
+* @tc.desc: Clear test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, Clear001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    auto result = manager->Clear();
+    ASSERT_EQ(result, OHOS::DistributedObject::OBJECT_STORE_NOT_FOUND);
+}
+
+/**
+* @tc.name: registerAndUnregisterRemoteCallback001
+* @tc.desc: test RegisterRemoteCallback and UnregisterRemoteCallback.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, registerAndUnregisterRemoteCallback001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    sptr<IRemoteObject> callback;
+    manager->RegisterRemoteCallback(bundleName_, sessionId_, pid_, tokenId_, callback);
+    ObjectStoreManager::CallbackInfo callbackInfo = manager->callbacks_.Find(tokenId_).second;
+    std::string prefix = bundleName_ + sessionId_;
+    ASSERT_NE(callbackInfo.observers_.find(prefix), callbackInfo.observers_.end());
+    manager->UnregisterRemoteCallback(bundleName_, pid_, tokenId_, sessionId_);
+    callbackInfo = manager->callbacks_.Find(tokenId_).second;
+    ASSERT_EQ(callbackInfo.observers_.find(prefix), callbackInfo.observers_.end());
+}
+
+/**
+* @tc.name: registerAndUnregisterRemoteCallback002
+* @tc.desc: abnormal use cases.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, registerAndUnregisterRemoteCallback002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    sptr<IRemoteObject> callback;
+    uint32_t tokenId = 101;
+    manager->RegisterRemoteCallback("", sessionId_, pid_, tokenId, callback);
+    manager->RegisterRemoteCallback(bundleName_, "", pid_, tokenId, callback);
+    manager->RegisterRemoteCallback("", "", pid_, tokenId, callback);
+    ASSERT_EQ(manager->callbacks_.Find(tokenId).first, false);
+    manager->UnregisterRemoteCallback("", pid_, tokenId, sessionId_);
+}
+
+/**
+* @tc.name: NotifyDataChanged001
+* @tc.desc: NotifyDataChanged test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, NotifyDataChanged001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string bundleName1_ = "com.examples.ophm.notepad";
+    std::string objectKey = bundleName1_ + sessionId_;
+    std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data;
+    std::map<std::string, std::vector<uint8_t>> data1;
+    std::vector<uint8_t> data1_;
+    data1_.push_back(RestoreStatus::DATA_READY);
+    data1_.push_back(RestoreStatus::ASSETS_READY);
+    data1_.push_back(RestoreStatus::ALL_READY);
+    data1 = {{ "objectKey", data1_ }};
+    data = {{ objectKey, data1 }};
+    std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(5, 3); // executor pool
+    manager->SetThreadPool(executors);
+    ASSERT_EQ(manager->restoreStatus_.Find(objectKey).first, false);
+    manager->NotifyDataChanged(data, {});
+    ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::DATA_READY);
+}
+
+/**
+* @tc.name: NotifyAssetsReady001
+* @tc.desc: NotifyAssetsReady test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, NotifyAssetsReady001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string objectKey = bundleName_ + sessionId_;
+    std::string srcNetworkId = "1";
+    ASSERT_EQ(manager->restoreStatus_.Find(objectKey).first, false);
+    manager->NotifyAssetsReady(objectKey, srcNetworkId);
+    ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::ASSETS_READY);
+    manager->restoreStatus_.Clear();
+    manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_READY);
+    manager->NotifyAssetsReady(objectKey, srcNetworkId);
+    ASSERT_EQ(manager->restoreStatus_.Find(objectKey).second, RestoreStatus::ALL_READY);
+}
+
+/**
+ * @tc.name: NotifyAssetsReady002
+ * @tc.desc: NotifyAssetsReady test.
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerTest, NotifyAssetsReady002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string objectKey="com.example.myapplicaiton123456";
+    std::string srcNetworkId = "654321";
+
+    manager->restoreStatus_.Clear();
+    manager->NotifyAssetsStart(objectKey, srcNetworkId);
+    auto [has0, value0] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has0);
+    EXPECT_EQ(value0, RestoreStatus::NONE);
+
+    manager->restoreStatus_.Clear();
+    manager->NotifyAssetsReady(objectKey, srcNetworkId);
+    auto [has1, value1] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has1);
+    EXPECT_EQ(value1, RestoreStatus::ASSETS_READY);
+
+    manager->restoreStatus_.Clear();
+    manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_NOTIFIED);
+    manager->NotifyAssetsReady(objectKey, srcNetworkId);
+    auto [has2, value2] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has2);
+    EXPECT_EQ(value2, RestoreStatus::ALL_READY);
+
+    manager->restoreStatus_.Clear();
+    manager->restoreStatus_.Insert(objectKey, RestoreStatus::DATA_READY);
+    manager->NotifyAssetsReady(objectKey, srcNetworkId);
+    auto [has3, value3] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has3);
+    EXPECT_EQ(value3, RestoreStatus::ALL_READY);
+    manager->restoreStatus_.Clear();
+}
+
+/**
+* @tc.name: NotifyChange001
+* @tc.desc: NotifyChange test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, NotifyChange001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, std::vector<uint8_t>> data;
+    std::map<std::string, std::vector<uint8_t>> data1;
+    std::vector<uint8_t> data1_;
+    data1_.push_back(RestoreStatus::DATA_READY);
+    data_.push_back(RestoreStatus::ALL_READY);
+    data = {{ "test_cloud", data_ }};
+    data1 = {{ "p_###SAVEINFO###001", data1_ }};
+    manager->NotifyChange(data1);
+    manager->NotifyChange(data);
+}
+
+/**
+ * @tc.name: NotifyChange002
+ * @tc.desc: NotifyChange test.
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerTest, NotifyChange002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(1, 0);
+    manager->SetThreadPool(executor);
+    std::map<std::string, std::vector<uint8_t>> data{};
+    std::vector<uint8_t> value{0};
+    std::string bundleName = "com.example.myapplication";
+    std::string sessionId = "123456";
+    std::string source = "source";
+    std::string target = "target";
+    std::string timestamp = "1234567890";
+    ObjectStoreManager::SaveInfo saveInfo(bundleName, sessionId, source, target, timestamp);
+    std::string saveInfoStr = DistributedData::Serializable::Marshall(saveInfo);
+    auto saveInfoValue = std::vector<uint8_t>(saveInfoStr.begin(), saveInfoStr.end());
+    std::string prefix = saveInfo.ToPropertyPrefix();
+    std::string assetPrefix = prefix + "p_asset";
+    data.insert_or_assign(prefix + "p_###SAVEINFO###", saveInfoValue);
+    data.insert_or_assign(prefix + "p_data", value);
+    data.insert_or_assign(assetPrefix + ObjectStore::NAME_SUFFIX, value);
+    data.insert_or_assign(assetPrefix + ObjectStore::URI_SUFFIX, value);
+    data.insert_or_assign(assetPrefix + ObjectStore::PATH_SUFFIX, value);
+    data.insert_or_assign(assetPrefix + ObjectStore::CREATE_TIME_SUFFIX, value);
+    data.insert_or_assign(assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, value);
+    data.insert_or_assign(assetPrefix + ObjectStore::SIZE_SUFFIX, value);
+    data.insert_or_assign("testkey", value);
+    manager->NotifyChange(data);
+    EXPECT_TRUE(manager->restoreStatus_.Contains(bundleName+sessionId));
+    auto [has, taskId] = manager->objectTimer_.Find(bundleName+sessionId);
+    EXPECT_TRUE(has);
+    manager->restoreStatus_.Clear();
+    manager->executors_->Remove(taskId);
+    manager->objectTimer_.Clear();
+}
+
+/**
+ * @tc.name: ComputeStatus001
+ * @tc.desc: ComputeStatus.test
+ * @tc.type: FUNC
+ */
+HWTEST_F(ObjectManagerTest, ComputeStatus001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(1, 0);
+    manager->SetThreadPool(executor);
+    std::string objectKey="com.example.myapplicaiton123456";
+    std::map<std::string, std::map<std::string, std::vector<uint8_t>>> data{};
+    manager->restoreStatus_.Clear();
+    manager->ComputeStatus(objectKey, {}, data);
+    auto [has0, value0] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has0);
+    EXPECT_EQ(value0, RestoreStatus::DATA_READY);
+    auto [has1, taskId1] = manager->objectTimer_.Find(objectKey);
+    EXPECT_TRUE(has1);
+    manager->executors_->Remove(taskId1);
+    manager->objectTimer_.Clear();
+    manager->restoreStatus_.Clear();
+
+    manager->restoreStatus_.Insert(objectKey, RestoreStatus::ASSETS_READY);
+    manager->ComputeStatus(objectKey, {}, data);
+    auto [has2, value2] = manager->restoreStatus_.Find(objectKey);
+    EXPECT_TRUE(has2);
+    EXPECT_EQ(value2, RestoreStatus::ALL_READY);
+    auto [has3, taskId3] = manager->objectTimer_.Find(objectKey);
+    EXPECT_FALSE(has3);
+    manager->restoreStatus_.Clear();
+}
+
+/**
+* @tc.name: Open001
+* @tc.desc: Open test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, Open001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->kvStoreDelegateManager_ = nullptr;
+    auto result = manager->Open();
+    ASSERT_EQ(result, DistributedObject::OBJECT_INNER_ERROR);
+    std::string dataDir = "/data/app/el2/100/database";
+    manager->SetData(dataDir, userId_);
+    manager->delegate_ = nullptr;
+    result = manager->Open();
+    ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
+    manager->delegate_ = manager->OpenObjectKvStore();
+    result = manager->Open();
+    ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
+}
+
+/**
+* @tc.name: OnAssetChanged001
+* @tc.desc: OnAssetChanged test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, OnAssetChanged001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::shared_ptr<Snapshot> snapshot = std::make_shared<ObjectSnapshot>();
+    auto snapshotKey = appId_ + "_" + sessionId_;
+    auto result = manager->OnAssetChanged(tokenId_, appId_, sessionId_, deviceId_, assetValue_);
+    ASSERT_EQ(result, DistributedObject::OBJECT_INNER_ERROR);
+    manager->snapshots_.Insert(snapshotKey, snapshot);
+    result = manager->OnAssetChanged(tokenId_, appId_, sessionId_, deviceId_, assetValue_);
+    ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
+}
+
+/**
+* @tc.name: DeleteSnapshot001
+* @tc.desc: DeleteSnapshot test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, DeleteSnapshot001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::shared_ptr<Snapshot> snapshot = std::make_shared<ObjectSnapshot>();
+    auto snapshotKey = bundleName_ + "_" + sessionId_;
+    auto snapshots = manager->snapshots_.Find(snapshotKey).second;
+    ASSERT_EQ(snapshots, nullptr);
+    manager->DeleteSnapshot(bundleName_, sessionId_);
+
+    manager->snapshots_.Insert(snapshotKey, snapshot);
+    snapshots = manager->snapshots_.Find(snapshotKey).second;
+    ASSERT_NE(snapshots, nullptr);
+    manager->DeleteSnapshot(bundleName_, sessionId_);
+}
+
+/**
+* @tc.name: OpenObjectKvStore001
+* @tc.desc: OpenObjectKvStore test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, OpenObjectKvStore001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->objectDataListener_ = nullptr;
+    ASSERT_EQ(manager->objectDataListener_, nullptr);
+    manager->OpenObjectKvStore();
+    ASSERT_NE(manager->objectDataListener_, nullptr);
+    manager->OpenObjectKvStore();
+}
+
+/**
+* @tc.name: FlushClosedStore001
+* @tc.desc: FlushClosedStore test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, FlushClosedStore001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->isSyncing_ = true;
+    manager->syncCount_ = 10; // test syncCount_
+    manager->delegate_ = nullptr;
+    manager->FlushClosedStore();
+    manager->isSyncing_ = false;
+    manager->FlushClosedStore();
+    manager->syncCount_ = 0; // test syncCount_
+    manager->FlushClosedStore();
+    manager->delegate_ = manager->OpenObjectKvStore();
+    manager->FlushClosedStore();
+}
+
+/**
+* @tc.name: Close001
+* @tc.desc: Close test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, Close001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->syncCount_ = 1; // test syncCount_
+    manager->Close();
+    ASSERT_EQ(manager->syncCount_, 1); // 1 is for testing
+    manager->delegate_ = manager->OpenObjectKvStore();
+    manager->Close();
+    ASSERT_EQ(manager->syncCount_, 0); // 0 is for testing
+}
+
+/**
+* @tc.name: SyncOnStore001
+* @tc.desc: SyncOnStore test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, SyncOnStore001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    std::string prefix = "ObjectManagerTest";
+    std::vector<std::string> deviceList;
+    deviceList.push_back("local");
+    deviceList.push_back("local1");
+    auto result = manager->SyncOnStore(prefix, deviceList, func);
+    ASSERT_EQ(result, OBJECT_SUCCESS);
+}
+
+/**
+* @tc.name: RevokeSaveToStore001
+* @tc.desc: RetrieveFromStore test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, RevokeSaveToStore001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    DistributedDB::KvStoreNbDelegateMock mockDelegate;
+    manager->delegate_ = &mockDelegate;
+    std::vector<uint8_t> id;
+    id.push_back(1);  // for testing
+    id.push_back(2);  // for testing
+    std::map<std::string, std::vector<uint8_t>> results;
+    results = {{ "test_cloud", id }};
+    auto result = manager->RetrieveFromStore(appId_, sessionId_, results);
+    ASSERT_EQ(result, OBJECT_SUCCESS);
+}
+
+/**
+* @tc.name: SyncCompleted001
+* @tc.desc: SyncCompleted test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, SyncCompleted001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    auto syncManager = SequenceSyncManager::GetInstance();
+    std::map<std::string, DistributedDB::DBStatus> results;
+    results = {{ "test_cloud", DistributedDB::DBStatus::OK }};
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    manager->userId_ = "99";
+    std::vector<uint64_t> userId;
+    userId.push_back(99);
+    userId.push_back(100);
+    manager->SyncCompleted(results, sequenceId_);
+    syncManager->userIdSeqIdRelations_ = {{ "test_cloud", userId }};
+    manager->SyncCompleted(results, sequenceId_);
+    userId.clear();
+    syncManager->seqIdCallbackRelations_.emplace(sequenceId_, func);
+    manager->SyncCompleted(results, sequenceId_);
+    userId.push_back(99);
+    userId.push_back(100);
+    manager->SyncCompleted(results, sequenceId_);
+}
+
+/**
+* @tc.name: SplitEntryKey001
+* @tc.desc: SplitEntryKey test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, SplitEntryKey001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string key1 = "";
+    std::string key2 = "ObjectManagerTest";
+    auto result = manager->SplitEntryKey(key1);
+    ASSERT_EQ(result.empty(), true);
+    result = manager->SplitEntryKey(key2);
+    ASSERT_EQ(result.empty(), true);
+}
+
+/**
+* @tc.name: SplitEntryKey002
+* @tc.desc: SplitEntryKey test.
+* @tc.type: FUNC
+*/
+HWTEST_F(ObjectManagerTest, SplitEntryKey002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string key1 = "com.example.myapplication_sessionId_source_target_1234567890_p_propertyName";
+    auto res = manager->SplitEntryKey(key1);
+    EXPECT_EQ(res[0], "com.example.myapplication");
+    EXPECT_EQ(res[1], "sessionId");
+    EXPECT_EQ(res[2], "source");
+    EXPECT_EQ(res[3], "target");
+    EXPECT_EQ(res[4], "1234567890");
+    EXPECT_EQ(res[5], "p_propertyName");
+
+    std::string key2 = "com.example.myapplication_sessionId_source_target_000_p_propertyName";
+    res = manager->SplitEntryKey(key2);
+    EXPECT_TRUE(res.empty());
+
+    std::string key3 = "com.example.myapplicationsessionIdsourcetarget_1234567890_p_propertyName";
+    res = manager->SplitEntryKey(key3);
+    EXPECT_TRUE(res.empty());
+
+    std::string key4 = "com.example.myapplicationsessionIdsource_target_1234567890_p_propertyName";
+    res = manager->SplitEntryKey(key4);
+    EXPECT_TRUE(res.empty());
+
+    std::string key5 = "com.example.myapplicationsessionId_source_target_1234567890_p_propertyName";
+    res = manager->SplitEntryKey(key5);
+    EXPECT_TRUE(res.empty());
+}
+
+/**
+* @tc.name: ProcessOldEntry001
+* @tc.desc: ProcessOldEntry test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, ProcessOldEntry001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->delegate_ = manager->OpenObjectKvStore();
+    std::vector<DistributedDB::Entry> entries;
+    auto status = manager->delegate_->GetEntries(std::vector<uint8_t>(appId_.begin(), appId_.end()), entries);
+    ASSERT_EQ(status, DistributedDB::DBStatus::NOT_FOUND);
+    manager->ProcessOldEntry(appId_);
+
+    DistributedDB::KvStoreNbDelegateMock mockDelegate;
+    manager->delegate_ = &mockDelegate;
+    status = manager->delegate_->GetEntries(std::vector<uint8_t>(appId_.begin(), appId_.end()), entries);
+    ASSERT_EQ(status, DistributedDB::DBStatus::OK);
+    manager->ProcessOldEntry(appId_);
+}
+
+/**
+* @tc.name: ProcessSyncCallback001
+* @tc.desc: ProcessSyncCallback test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, ProcessSyncCallback001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, int32_t> results;
+    manager->ProcessSyncCallback(results, appId_, sessionId_, deviceId_);
+    results.insert({"local", 1}); // for testing
+    ASSERT_EQ(results.empty(), false);
+    ASSERT_NE(results.find("local"), results.end());
+    manager->ProcessSyncCallback(results, appId_, sessionId_, deviceId_);
+}
+
+/**
+* @tc.name: IsAssetComplete001
+* @tc.desc: IsAssetComplete test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, IsAssetComplete001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, std::vector<uint8_t>> results;
+    std::vector<uint8_t> completes;
+    completes.push_back(1); // for testing
+    completes.push_back(2); // for testing
+    std::string assetPrefix = "IsAssetComplete_test";
+    results.insert({assetPrefix, completes});
+    auto result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::NAME_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::URI_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::PATH_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::CREATE_TIME_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, false);
+    results.insert({assetPrefix + ObjectStore::SIZE_SUFFIX, completes});
+    result = manager->IsAssetComplete(results, assetPrefix);
+    ASSERT_EQ(result, true);
+}
+
+/**
+* @tc.name: GetAssetsFromDBRecords001
+* @tc.desc: GetAssetsFromDBRecords test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, GetAssetsFromDBRecords001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, std::vector<uint8_t>> results;
+    std::vector<uint8_t> completes;
+    completes.push_back(1); // for testing
+    completes.push_back(2); // for testing
+    std::string assetPrefix = "IsAssetComplete_test";
+    results.insert({assetPrefix, completes});
+    results.insert({assetPrefix + ObjectStore::NAME_SUFFIX, completes});
+    results.insert({assetPrefix + ObjectStore::URI_SUFFIX, completes});
+    results.insert({assetPrefix + ObjectStore::MODIFY_TIME_SUFFIX, completes});
+    results.insert({assetPrefix + ObjectStore::SIZE_SUFFIX, completes});
+    auto result = manager->GetAssetsFromDBRecords(results);
+    ASSERT_EQ(result.empty(), false);
+}
+
+/**
+* @tc.name: GetAssetsFromDBRecords002
+* @tc.desc: GetAssetsFromDBRecords test.
+* @tc.type: FUNC
+*/
+HWTEST_F(ObjectManagerTest, GetAssetsFromDBRecords002, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, std::vector<uint8_t>> result;
+
+    std::vector<uint8_t> value0{0};
+    std::string data0 = "[STRING]test";
+    value0.insert(value0.end(), data0.begin(), data0.end());
+
+    std::vector<uint8_t> value1{0};
+    std::string data1 = "(string)test";
+    value1.insert(value1.end(), data1.begin(), data1.end());
+
+    std::string prefix = "bundleName_sessionId_source_target_timestamp";
+    std::string dataKey = prefix + "_p_data";
+    std::string assetPrefix0 = prefix + "_p_asset0";
+    std::string assetPrefix1 = prefix + "_p_asset1";
+
+    result.insert({dataKey, value0});
+    auto assets = manager->GetAssetsFromDBRecords(result);
+    EXPECT_TRUE(assets.empty());
+    
+    result.clear();
+    result.insert({assetPrefix0 + ObjectStore::URI_SUFFIX, value0});
+    assets = manager->GetAssetsFromDBRecords(result);
+    EXPECT_TRUE(assets.empty());
+
+    result.clear();
+    result.insert({assetPrefix1 + ObjectStore::NAME_SUFFIX, value1});
+    assets = manager->GetAssetsFromDBRecords(result);
+    EXPECT_TRUE(assets.empty());
+
+    result.clear();
+    result.insert({assetPrefix0 + ObjectStore::NAME_SUFFIX, value0});
+    result.insert({assetPrefix0 + ObjectStore::URI_SUFFIX, value0});
+    result.insert({assetPrefix0 + ObjectStore::MODIFY_TIME_SUFFIX, value0});
+    result.insert({assetPrefix0 + ObjectStore::SIZE_SUFFIX, value0});
+    assets = manager->GetAssetsFromDBRecords(result);
+    ASSERT_EQ(assets.size(), 1);
+    EXPECT_EQ(assets[0].name, "test");
+    EXPECT_EQ(assets[0].uri, "test");
+    EXPECT_EQ(assets[0].modifyTime, "test");
+    EXPECT_EQ(assets[0].size, "test");
+    EXPECT_EQ(assets[0].hash, "test_test");
+
+    result.clear();
+    result.insert({assetPrefix1 + ObjectStore::NAME_SUFFIX, value1});
+    result.insert({assetPrefix1 + ObjectStore::URI_SUFFIX, value1});
+    result.insert({assetPrefix1 + ObjectStore::MODIFY_TIME_SUFFIX, value1});
+    result.insert({assetPrefix1 + ObjectStore::SIZE_SUFFIX, value1});
+    assets = manager->GetAssetsFromDBRecords(result);
+    ASSERT_EQ(assets.size(), 1);
+    EXPECT_EQ(assets[0].name, "(string)test");
+    EXPECT_EQ(assets[0].uri, "(string)test");
+    EXPECT_EQ(assets[0].modifyTime, "(string)test");
+    EXPECT_EQ(assets[0].size, "(string)test");
+    EXPECT_EQ(assets[0].hash, "(string)test_(string)test");
+}
+
+/**
+* @tc.name: RegisterAssetsLister001
+* @tc.desc: RegisterAssetsLister test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, RegisterAssetsLister001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    manager->objectAssetsSendListener_ = nullptr;
+    manager->objectAssetsRecvListener_ = nullptr;
+    auto result = manager->RegisterAssetsLister();
+    ASSERT_EQ(result, true);
+    manager->objectAssetsSendListener_ = new ObjectAssetsSendListener();
+    manager->objectAssetsRecvListener_ = new ObjectAssetsRecvListener();;
+    result = manager->RegisterAssetsLister();
+    ASSERT_EQ(result, true);
+}
+
+/**
+* @tc.name: RegisterAssetsLister001
+* @tc.desc: PushAssets test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectManagerTest, PushAssets001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::map<std::string, std::vector<uint8_t>> data;
+    std::string assetPrefix = "PushAssets_test";
+    std::vector<uint8_t> completes;
+    completes.push_back(1); // for testing
+    completes.push_back(2); // for testing
+    data.insert({assetPrefix, completes});
+    auto result = manager->PushAssets(100, appId_, sessionId_, data, deviceId_);
+    ASSERT_EQ(result, DistributedObject::OBJECT_SUCCESS);
+}
+
+/**
+* @tc.name: AddNotifier001
+* @tc.desc: AddNotifie and DeleteNotifier test.
+* @tc.type: FUNC
+*/
+HWTEST_F(ObjectManagerTest, AddNotifier001, TestSize.Level0)
+{
+    auto syncManager = SequenceSyncManager::GetInstance();
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    auto sequenceId_ = syncManager->AddNotifier(userId_, func);
+    auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::SUCCESS_USER_HAS_FINISHED);
+}
+
+/**
+* @tc.name: AddNotifier002
+* @tc.desc: AddNotifie and DeleteNotifier test.
+* @tc.type: FUNC
+*/
+HWTEST_F(ObjectManagerTest, AddNotifier002, TestSize.Level0)
+{
+    auto syncManager = SequenceSyncManager::GetInstance();
+    std::function<void(const std::map<std::string, int32_t> &results)> func;
+    func = [](const std::map<std::string, int32_t> &results) {
+        return results;
+    };
+    auto sequenceId = syncManager->AddNotifier(userId_, func);
+    ASSERT_NE(sequenceId, sequenceId_);
+    auto result = syncManager->DeleteNotifier(sequenceId_, userId_);
+    ASSERT_EQ(result, SequenceSyncManager::ERR_SID_NOT_EXIST);
+}
+
+/**
+* @tc.name: BindAsset 001
+* @tc.desc: BindAsset test.
+* @tc.type: FUNC
+*/
+HWTEST_F(ObjectManagerTest, BindAsset001, TestSize.Level0)
+{
+    auto manager = ObjectStoreManager::GetInstance();
+    std::string bundleName = "BindAsset";
+    uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
+    auto result = manager->BindAsset(tokenId, bundleName, sessionId_, assetValue_, assetBindInfo_);
+    ASSERT_EQ(result, DistributedObject::OBJECT_DBSTATUS_ERROR);
+}
+} // namespace OHOS::Test
diff --git a/datamgr_service/services/distributeddataservice/service/test/object_snapshot_test.cpp b/datamgr_service/services/distributeddataservice/service/test/object_snapshot_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90cdc9daf4852c6f521e6104ec59eb004b0bc2b9
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/test/object_snapshot_test.cpp
@@ -0,0 +1,371 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "ObjectSnapshotTest"
+
+#include "object_snapshot.h"
+#include <gtest/gtest.h>
+#include "snapshot/machine_status.h"
+#include "executor_pool.h"
+
+using namespace testing::ext;
+using namespace OHOS::DistributedObject;
+using namespace OHOS::DistributedData;
+namespace OHOS::Test {
+
+class ObjectSnapshotTest : public testing::Test {
+public:
+    void SetUp();
+    void TearDown();
+
+protected:
+    AssetBindInfo AssetBindInfo_;
+    Asset asset_;
+    std::string uri_;
+    StoreInfo storeInfo_;
+};
+
+void ObjectSnapshotTest::SetUp()
+{
+    uri_ = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset1.jpg";
+    Asset asset{
+        .name = "test_name",
+        .uri = uri_,
+        .modifyTime = "modifyTime",
+        .size = "size",
+        .hash = "modifyTime_size",
+    };
+    asset_ = asset;
+
+    VBucket vBucket{ { "11", 111 } };
+    AssetBindInfo AssetBindInfo{
+        .storeName = "store_test",
+        .tableName = "table_test",
+        .primaryKey = vBucket,
+        .field = "attachment",
+        .assetName = "asset1.jpg",
+    };
+    AssetBindInfo_ = AssetBindInfo;
+    StoreInfo storeInfo {
+        .tokenId = 0,
+        .bundleName = "bundleName_test",
+        .storeName = "store_test",
+        .instanceId = 1,
+        .user = 100,
+    };
+    storeInfo_ = storeInfo;
+    ChangedAssetInfo changedAssetInfo(asset, AssetBindInfo, storeInfo);
+}
+
+void ObjectSnapshotTest::TearDown() {}
+
+/**
+* @tc.name: UploadTest001
+* @tc.desc: Upload test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, UploadTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->Upload(asset);
+    ASSERT_EQ(upload, 0);
+}
+
+/**
+* @tc.name: UploadTest002
+* @tc.desc: Upload test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, UploadTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->Upload(asset_);
+    ASSERT_EQ(upload, 0);
+}
+
+/**
+* @tc.name: DownloadTest001
+* @tc.desc: Download test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, DownloadTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->Download(asset);
+    ASSERT_EQ(upload, 0);
+}
+
+/**
+* @tc.name: DownloadTest002
+* @tc.desc: Download test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, DownloadTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->Download(asset_);
+    ASSERT_EQ(upload, 0);
+}
+
+/**
+* @tc.name: GetAssetStatusTest001
+* @tc.desc: GetAssetStatus test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, GetAssetStatusTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->GetAssetStatus(asset);
+    ASSERT_EQ(upload, STATUS_BUTT);
+}
+
+/**
+* @tc.name: GetAssetStatusTest002
+* @tc.desc: GetAssetStatus test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, GetAssetStatusTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->GetAssetStatus(asset_);
+    ASSERT_EQ(upload, STATUS_STABLE);
+}
+
+/**
+* @tc.name: UploadedTest001
+* @tc.desc: Uploaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, UploadedTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->Uploaded(asset);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: UploadedTest002
+* @tc.desc: Uploaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, UploadedTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->Uploaded(asset_);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: DownloadedTest001
+* @tc.desc: Downloaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, DownloadedTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->Downloaded(asset);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: DownloadedTest002
+* @tc.desc: Downloaded test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, DownloadedTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->Downloaded(asset_);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: TransferredTest001
+* @tc.desc: Transferred test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, TransferredTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->Transferred(asset);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: TransferredTest002
+* @tc.desc: Transferred test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, TransferredTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->Transferred(asset_);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: OnDataChangedTest001
+* @tc.desc: OnDataChanged test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, OnDataChangedTest001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    std::string deviceId = "object_snapshot_test_1";
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    auto upload = snapshot->OnDataChanged(asset, deviceId);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: OnDataChangedTest002
+* @tc.desc: OnDataChanged test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, OnDataChangedTest002, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    std::string deviceId = "object_snapshot_test_1";
+    snapshot->BindAsset(asset_, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset_), true);
+    auto upload = snapshot->OnDataChanged(asset_, deviceId);
+    ASSERT_EQ(upload, E_OK);
+}
+
+/**
+* @tc.name: BindAsset001
+* @tc.desc: BindAsset test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: wangbin
+*/
+HWTEST_F(ObjectSnapshotTest, BindAsset001, TestSize.Level0)
+{
+    auto snapshot = std::make_shared<ObjectSnapshot>();
+    Asset asset{
+        .name = "test_name",
+        .uri = "file:://com.example.hmos.notepad/data/storage/el2/distributedfiles/dir/asset2.jpg",
+        .modifyTime = "modifyTime1",
+        .size = "size1",
+        .hash = "modifyTime1_size1",
+    };
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), false);
+    snapshot->BindAsset(asset, AssetBindInfo_, storeInfo_);
+    ASSERT_EQ(snapshot->IsBoundAsset(asset), true);
+    snapshot->BindAsset(asset, AssetBindInfo_, storeInfo_);
+}
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/rdb_asset_loader_test.cpp b/datamgr_service/services/distributeddataservice/service/test/rdb_asset_loader_test.cpp
index 9ab9c95ef80dab137089088ea62bd128c771adf4..91b54fb417965db1fc7bac83474ee52434e78c08 100644
--- a/datamgr_service/services/distributeddataservice/service/test/rdb_asset_loader_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/rdb_asset_loader_test.cpp
@@ -17,8 +17,11 @@
 #include "gtest/gtest.h"
 #include "log_print.h"
 #include "rdb_asset_loader.h"
+#include "rdb_notifier_proxy.h"
+#include "rdb_watcher.h"
 #include "store/cursor.h"
-
+#include "store/general_value.h"
+#include "store/general_watcher.h"
 using namespace OHOS;
 using namespace testing;
 using namespace testing::ext;
@@ -61,6 +64,14 @@ public:
     }
 };
 
+class RdbWatcherTest : public testing::Test {
+public:
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
+};
+
 /**
 * @tc.name: Download
 * @tc.desc: RdbAssetLoader download test.
@@ -121,5 +132,25 @@ HWTEST_F(RdbAssetLoaderTest, PostEvent, TestSize.Level0)
     auto result = rdbAssetLoader.Download(tableName, groupId, prefix, assets);
     EXPECT_EQ(result, DistributedDB::DBStatus::CLOUD_ERROR);
 }
+
+/**
+* @tc.name: RdbWatcher
+* @tc.desc: RdbWatcher function test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(RdbWatcherTest, RdbWatcher, TestSize.Level0)
+{
+    GeneralWatcher::Origin origin;
+    GeneralWatcher::PRIFields primaryFields = {{"primaryFields1", "primaryFields2"}};
+    GeneralWatcher::ChangeInfo values;
+    std::shared_ptr<RdbWatcher> watcher = std::make_shared<RdbWatcher>();
+    sptr<RdbNotifierProxy> notifier;
+    watcher->SetNotifier(notifier);
+    EXPECT_EQ(watcher->notifier_, nullptr);
+    auto result = watcher->OnChange(origin, primaryFields, std::move(values));
+    EXPECT_EQ(result, GeneralError::E_NOT_INIT);
+}
 } // namespace DistributedRDBTest
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/rdb_cloud_test.cpp b/datamgr_service/services/distributeddataservice/service/test/rdb_cloud_test.cpp
index 3be6d2d0f7dbad3436a5a41a02bed3b159b6f964..0646e6ff9a77baa0ecd474bd5533cdebec549f57 100644
--- a/datamgr_service/services/distributeddataservice/service/test/rdb_cloud_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/rdb_cloud_test.cpp
@@ -14,9 +14,10 @@
  */
 #define LOG_TAG "RdbCloudTest"
 
+#include "rdb_cloud.h"
+
 #include "gtest/gtest.h"
 #include "log_print.h"
-#include "rdb_cloud.h"
 #include "rdb_cloud_data_translate.h"
 
 using namespace testing::ext;
@@ -56,7 +57,7 @@ HWTEST_F(RdbCloudTest, RdbCloudTest001, TestSize.Level1)
 {
     BindAssets bindAssets;
     Bytes bytes;
-    std::shared_ptr<CloudDB> cloudDB  = std::make_shared<CloudDB>();
+    std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>();
     RdbCloud rdbCloud(cloudDB, &bindAssets);
     std::string tableName = "testTable";
     auto result = rdbCloud.BatchInsert(tableName, std::move(g_DBVBucket), g_DBVBucket);
@@ -77,7 +78,7 @@ HWTEST_F(RdbCloudTest, RdbCloudTest001, TestSize.Level1)
 HWTEST_F(RdbCloudTest, RdbCloudTest002, TestSize.Level1)
 {
     BindAssets bindAssets;
-    std::shared_ptr<CloudDB> cloudDB  = std::make_shared<CloudDB>();
+    std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>();
     RdbCloud rdbCloud(cloudDB, &bindAssets);
     std::string tableName = "testTable";
     rdbCloud.Lock();
@@ -113,7 +114,7 @@ HWTEST_F(RdbCloudTest, RdbCloudTest003, TestSize.Level1)
 {
     BindAssets bindAssets;
     bindAssets.bindAssets = nullptr;
-    std::shared_ptr<CloudDB> cloudDB  = std::make_shared<CloudDB>();
+    std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>();
     RdbCloud rdbCloud(cloudDB, &bindAssets);
     std::string tableName = "testTable";
     DBVBucket extends = {
@@ -151,7 +152,7 @@ HWTEST_F(RdbCloudTest, RdbCloudTest003, TestSize.Level1)
 HWTEST_F(RdbCloudTest, ConvertStatus, TestSize.Level1)
 {
     BindAssets bindAssets;
-    std::shared_ptr<CloudDB> cloudDB  = std::make_shared<CloudDB>();
+    std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>();
     RdbCloud rdbCloud(cloudDB, &bindAssets);
     auto result = rdbCloud.ConvertStatus(GeneralError::E_OK);
     EXPECT_EQ(result, DBStatus::OK);
diff --git a/datamgr_service/services/distributeddataservice/service/test/rdb_cursor_test.cpp b/datamgr_service/services/distributeddataservice/service/test/rdb_cursor_test.cpp
index d8aa4815288ff55cbfadb138c55d7fb6bc2f7807..02f36f3ca6dc9cbd553e2b12f5f5610b871f3fbf 100644
--- a/datamgr_service/services/distributeddataservice/service/test/rdb_cursor_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/rdb_cursor_test.cpp
@@ -16,7 +16,6 @@
 
 #include "gtest/gtest.h"
 #include "log_print.h"
-#define private public
 #include "rdb_cursor.h"
 #include "result_set.h"
 #include "store/general_value.h"
diff --git a/datamgr_service/services/distributeddataservice/service/test/rdb_general_store_test.cpp b/datamgr_service/services/distributeddataservice/service/test/rdb_general_store_test.cpp
index a0a1794ca435a51ab29f9716b0d56a46a7f1a708..6697dae26ee74c0766a53abce35375daba9938c1 100644
--- a/datamgr_service/services/distributeddataservice/service/test/rdb_general_store_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/rdb_general_store_test.cpp
@@ -14,19 +14,20 @@
 */
 #define LOG_TAG "RdbGeneralStoreTest"
 
+#include "rdb_general_store.h"
 
 #include <random>
+#include <thread>
 
 #include "bootstrap.h"
 #include "cloud/schema_meta.h"
 #include "gtest/gtest.h"
-#define private public
-#include "rdb_general_store.h"
 #include "log_print.h"
 #include "metadata/meta_data_manager.h"
 #include "metadata/secret_key_meta_data.h"
 #include "metadata/store_meta_data.h"
 #include "metadata/store_meta_data_local.h"
+#include "mock/general_watcher_mock.h"
 #include "rdb_query.h"
 #include "store/general_store.h"
 #include "types.h"
@@ -230,42 +231,13 @@ protected:
     }
 };
 
-class MockQuery : public GenQuery {
-public:
-    ~MockQuery() = default;
-    static constexpr uint64_t TYPE_ID = 0x20000001;
-    std::vector<std::string> tables_;
-    bool lastResult = false;
-    bool IsEqual(uint64_t tid) override
-    {
-        return (tid == TYPE_ID) && lastResult;
-    }
-
-    std::vector<std::string> GetTables() override
-    {
-        return tables_;
-    }
-};
-
-class MockGeneralWatcher : public DistributedData::GeneralWatcher {
-public:
-    int32_t OnChange(const Origin &origin, const PRIFields &primaryFields, ChangeInfo &&values) override
-    {
-        return GeneralError::E_OK;
-    }
-
-    int32_t OnChange(const Origin &origin, const Fields &fields, ChangeData &&datas) override
-    {
-        return GeneralError::E_OK;
-    }
-};
-
 class MockStoreChangedData : public DistributedDB::StoreChangedData {
 public:
     std::string GetDataChangeDevice() const override
     {
         return "DataChangeDevice";
     }
+
     void GetStoreProperty(DistributedDB::StoreProperty &storeProperty) const override
     {
         return;
@@ -433,6 +405,29 @@ HWTEST_F(RdbGeneralStoreTest, Close, TestSize.Level1)
     EXPECT_EQ(ret, GeneralError::E_BUSY);
 }
 
+/**
+* @tc.name: Close
+* @tc.desc: RdbGeneralStore Close test
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: shaoyuanzhao
+*/
+HWTEST_F(RdbGeneralStoreTest, BusyClose, TestSize.Level1)
+{
+    auto store = std::make_shared<RdbGeneralStore>(metaData_);
+    ASSERT_NE(store, nullptr);
+    std::thread thread([store]() {
+        std::unique_lock<decltype(store->rwMutex_)> lock(store->rwMutex_);
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    });
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    auto ret = store->Close();
+    EXPECT_EQ(ret, GeneralError::E_BUSY);
+    thread.join();
+    ret = store->Close();
+    EXPECT_EQ(ret, GeneralError::E_OK);
+}
+
 /**
 * @tc.name: Execute
 * @tc.desc: RdbGeneralStore Execute function test
@@ -658,13 +653,15 @@ HWTEST_F(RdbGeneralStoreTest, Query001, TestSize.Level1)
     ASSERT_NE(store, nullptr);
     std::string table = "table";
     std::string sql = "sql";
-    auto result = store->Query(table, sql, std::move(g_RdbValues));
-    EXPECT_EQ(result, nullptr);
+    auto [err1, result1] = store->Query(table, sql, std::move(g_RdbValues));
+    EXPECT_EQ(err1, GeneralError::E_ALREADY_CLOSED);
+    EXPECT_EQ(result1, nullptr);
 
     MockRelationalStoreDelegate mockDelegate;
     store->delegate_ = &mockDelegate;
-    result = store->Query(table, sql, std::move(g_RdbValues));
-    EXPECT_NE(result, nullptr);
+    auto [err2, result2] = store->Query(table, sql, std::move(g_RdbValues));
+    EXPECT_EQ(err2, GeneralError::E_OK);
+    EXPECT_NE(result2, nullptr);
 }
 
 /**
@@ -681,12 +678,14 @@ HWTEST_F(RdbGeneralStoreTest, Query002, TestSize.Level1)
     std::string table = "table";
     std::string sql = "sql";
     MockQuery query;
-    auto result = store->Query(table, query);
-    EXPECT_EQ(result, nullptr);
+    auto [err1, result1] = store->Query(table, query);
+    EXPECT_EQ(err1, GeneralError::E_INVALID_ARGS);
+    EXPECT_EQ(result1, nullptr);
 
     query.lastResult = true;
-    result = store->Query(table, query);
-    EXPECT_EQ(result, nullptr);
+    auto [err2, result2] = store->Query(table, query);
+    EXPECT_EQ(err2, GeneralError::E_ALREADY_CLOSED);
+    EXPECT_EQ(result2, nullptr);
 }
 
 /**
@@ -747,7 +746,8 @@ HWTEST_F(RdbGeneralStoreTest, PreSharing, TestSize.Level1)
     auto store = new (std::nothrow) RdbGeneralStore(metaData_);
     ASSERT_NE(store, nullptr);
     MockQuery query;
-    auto result = store->PreSharing(query);
+    auto [errCode, result] = store->PreSharing(query);
+    EXPECT_NE(errCode, GeneralError::E_OK);
     EXPECT_EQ(result, nullptr);
 }
 
@@ -867,7 +867,7 @@ HWTEST_F(RdbGeneralStoreTest, OnChange, TestSize.Level1)
 
 /**
 * @tc.name: Release
-* @tc.desc: RdbGeneralStore Release function test
+* @tc.desc: RdbGeneralStore Release and AddRef function test
 * @tc.type: FUNC
 * @tc.require:
 * @tc.author: SQL
@@ -878,6 +878,8 @@ HWTEST_F(RdbGeneralStoreTest, Release, TestSize.Level1)
     ASSERT_NE(store, nullptr);
     auto result = store->Release();
     EXPECT_EQ(result, 0);
+    store = new (std::nothrow) RdbGeneralStore(metaData_);
+    store->ref_ = 0;
     result = store->Release();
     EXPECT_EQ(result, 0);
     store->ref_ = 2;
@@ -1009,10 +1011,13 @@ HWTEST_F(RdbGeneralStoreTest, QuerySql, TestSize.Level1)
     ASSERT_NE(store, nullptr);
     MockRelationalStoreDelegate mockDelegate;
     store->delegate_ = &mockDelegate;
-    auto result = store->QuerySql("", std::move(g_RdbValues));
-    EXPECT_TRUE(result.empty());
-    result = store->QuerySql("sql", std::move(g_RdbValues));
-    EXPECT_TRUE(result.empty());
+    auto [err1, result1] = store->QuerySql("", std::move(g_RdbValues));
+    EXPECT_EQ(err1, GeneralError::E_ERROR);
+    EXPECT_TRUE(result1.empty());
+
+    auto [err2, result2] = store->QuerySql("sql", std::move(g_RdbValues));
+    EXPECT_EQ(err1, GeneralError::E_ERROR);
+    EXPECT_TRUE(result2.empty());
 }
 } // namespace DistributedRDBTest
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/test/value_proxy_test.cpp b/datamgr_service/services/distributeddataservice/service/test/value_proxy_test.cpp
index dba39e9d06b6f297c97ce893a2a21a77d2a6f913..327e2e4905cc6a3faf68ca7c16087ac5fe91eb4c 100644
--- a/datamgr_service/services/distributeddataservice/service/test/value_proxy_test.cpp
+++ b/datamgr_service/services/distributeddataservice/service/test/value_proxy_test.cpp
@@ -13,14 +13,14 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "CloudDataTest"
+#define LOG_TAG "ValueProxyServiceTest"
 #include <gtest/gtest.h>
 #include "log_print.h"
 #include "value_proxy.h"
-namespace Test {
+namespace OHOS::Test {
 using namespace testing::ext;
 using namespace OHOS::DistributedData;
-class ValueProxyTest  : public testing::Test {
+class ValueProxyServiceTest : public testing::Test {
 };
 
 /**
@@ -30,7 +30,7 @@ class ValueProxyTest  : public testing::Test {
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, VBucketsNormal2GaussDB, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, VBucketsNormal2GaussDB, TestSize.Level0)
 {
     std::vector<DistributedDB::VBucket> dbVBuckets;
     OHOS::DistributedData::VBuckets extends = {
@@ -48,7 +48,7 @@ HWTEST_F(ValueProxyTest, VBucketsNormal2GaussDB, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, VBucketsGaussDB2Normal, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, VBucketsGaussDB2Normal, TestSize.Level0)
 {
     std::vector<DistributedDB::VBucket> dbVBuckets = {
         {{"#gid", {"0000000"}}, {"#flag", {true }}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}},
@@ -66,7 +66,7 @@ HWTEST_F(ValueProxyTest, VBucketsGaussDB2Normal, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, VBucketsNormal2Rdb, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, VBucketsNormal2Rdb, TestSize.Level0)
 {
     using RdbBucket = OHOS::NativeRdb::ValuesBucket;
     std::vector<RdbBucket> rdbVBuckets;
@@ -85,7 +85,7 @@ HWTEST_F(ValueProxyTest, VBucketsNormal2Rdb, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, VBucketsRdb2Normal, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, VBucketsRdb2Normal, TestSize.Level0)
 {
     using RdbBucket = OHOS::NativeRdb::ValuesBucket;
     using RdbValue = OHOS::NativeRdb::ValueObject;
@@ -112,7 +112,7 @@ HWTEST_F(ValueProxyTest, VBucketsRdb2Normal, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, ConvertIntMapTest, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, ConvertIntMapTest, TestSize.Level0)
 {
     std::map<std::string, int64_t> testMap = { { "name", 1 }, { "school", 2 }, { "address", 3 } };
     auto res = ValueProxy::Convert<int64_t>(testMap);
@@ -130,7 +130,7 @@ HWTEST_F(ValueProxyTest, ConvertIntMapTest, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, ConvertAssetMapGaussDB2NormalTest, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, ConvertAssetMapGaussDB2NormalTest, TestSize.Level0)
 {
     DistributedDB::Asset dbAsset0 { .name = "dbname", .uri = "dburi" };
     DistributedDB::Asset dbAsset1 { .name = "dbname", .uri = "dburi" };
@@ -157,7 +157,7 @@ HWTEST_F(ValueProxyTest, ConvertAssetMapGaussDB2NormalTest, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, ConvertAssetMapNormal2GaussDBTest, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, ConvertAssetMapNormal2GaussDBTest, TestSize.Level0)
 {
     using NormalAsset = OHOS::DistributedData::Asset;
     using NormalAssets = OHOS::DistributedData::Assets;
@@ -186,7 +186,7 @@ HWTEST_F(ValueProxyTest, ConvertAssetMapNormal2GaussDBTest, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, ConvertAssetMapRdb2NormalTest, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, ConvertAssetMapRdb2NormalTest, TestSize.Level0)
 {
     using RdbAsset = OHOS::NativeRdb::AssetValue;
     using RdbAssets = std::vector<RdbAsset>;
@@ -215,7 +215,7 @@ HWTEST_F(ValueProxyTest, ConvertAssetMapRdb2NormalTest, TestSize.Level0)
 * @tc.require:
 * @tc.author: ht
 */
-HWTEST_F(ValueProxyTest, ConvertAssetMapNormal2RdbTest, TestSize.Level0)
+HWTEST_F(ValueProxyServiceTest, ConvertAssetMapNormal2RdbTest, TestSize.Level0)
 {
     using RdbAsset = OHOS::NativeRdb::AssetValue;
     using RdbAssets = std::vector<RdbAsset>;
@@ -244,4 +244,121 @@ HWTEST_F(ValueProxyTest, ConvertAssetMapNormal2RdbTest, TestSize.Level0)
     auto dataAsset = rdbAssets.begin();
     ASSERT_EQ(dataAsset->name, "name");
 }
-} // namespace Test
+
+/**
+* @tc.name: AssetConvertToDataStatus
+* @tc.desc: Asset::ConvertToDataStatus function test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(ValueProxyServiceTest, AssetConvertToDataStatus, TestSize.Level0)
+{
+    DistributedDB::Asset asset;
+    asset.status = static_cast<uint32_t>(DistributedDB::AssetStatus::DOWNLOADING);
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::DELETE);
+    auto result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_DELETE);
+
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::NO_CHANGE);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_DOWNLOADING);
+
+    asset.status = static_cast<uint32_t>(DistributedDB::AssetStatus::ABNORMAL);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_ABNORMAL);
+
+    asset.status = static_cast<uint32_t>(DistributedDB::AssetStatus::NORMAL);
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::INSERT);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_INSERT);
+
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::UPDATE);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_UPDATE);
+
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::DELETE);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_DELETE);
+
+    asset.flag = static_cast<uint32_t>(DistributedDB::AssetOpType::NO_CHANGE);
+    result = ValueProxy::Asset::ConvertToDataStatus(asset);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_NORMAL);
+}
+
+/**
+* @tc.name: AssetConvertToDBStatus
+* @tc.desc: Asset::ConvertToDBStatus function test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(ValueProxyServiceTest, AssetConvertToDBStatus, TestSize.Level0)
+{
+    uint32_t status = static_cast<uint32_t>(DistributedData::Asset::STATUS_NORMAL);
+    auto result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::NORMAL);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_ABNORMAL);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::ABNORMAL);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_INSERT);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::INSERT);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_UPDATE);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::UPDATE);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_DELETE);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::DELETE);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_DOWNLOADING);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::DOWNLOADING);
+
+    status = static_cast<uint32_t>(DistributedData::Asset::STATUS_UNKNOWN);
+    result = ValueProxy::Asset::ConvertToDBStatus(status);
+    EXPECT_EQ(result, DistributedDB::AssetStatus::NORMAL);
+}
+
+/**
+* @tc.name: TempAssetConvertToDataStatus
+* @tc.desc: TempAsset::ConvertToDataStatus function test.
+* @tc.type: FUNC
+* @tc.require:
+* @tc.author: SQL
+*/
+HWTEST_F(ValueProxyServiceTest, TempAssetConvertToDataStatus, TestSize.Level0)
+{
+    uint32_t status = static_cast<uint32_t>(DistributedDB::AssetStatus::NORMAL);
+    auto result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_NORMAL);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::ABNORMAL);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_ABNORMAL);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::INSERT);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_INSERT);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::UPDATE);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_UPDATE);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::DELETE);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_DELETE);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::DOWNLOADING);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_EQ(result, DistributedData::Asset::STATUS_DOWNLOADING);
+
+    status = static_cast<uint32_t>(DistributedDB::AssetStatus::DOWNLOAD_WITH_NULL);
+    result = ValueProxy::TempAsset::ConvertToDataStatus(status);
+    EXPECT_NE(result, DistributedData::Asset::STATUS_NORMAL);
+}
+} // namespace OHOS::Test
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/BUILD.gn b/datamgr_service/services/distributeddataservice/service/udmf/BUILD.gn
index e64eb69f73cf5a5f4215dbc56d16fcbbf49a8f27..65d462e1d34b85819a1a08e5d43303e3275ec41f 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/BUILD.gn
+++ b/datamgr_service/services/distributeddataservice/service/udmf/BUILD.gn
@@ -19,6 +19,7 @@ config("module_public_config") {
   include_dirs = [
     "${data_service_path}/framework/include",
     "${data_service_path}/adapter/include/communicator",
+    "${data_service_path}/adapter/include/account",
     "${data_service_path}/adapter/include/dfx",
     "${data_service_path}/service/udmf/lifecycle",
     "${data_service_path}/service/udmf/permission",
@@ -55,6 +56,7 @@ ohos_shared_library("udmf_server") {
     "permission/uri_permission_manager.cpp",
     "preprocess/preprocess_utils.cpp",
     "store/runtime_store.cpp",
+    "store/store_account_observer.cpp",
     "store/store_cache.cpp",
     "udmf_service_impl.cpp",
     "udmf_service_stub.cpp",
@@ -80,12 +82,12 @@ ohos_shared_library("udmf_server") {
     "c_utils:utils",
     "hilog:libhilog",
     "hisysevent:libhisysevent",
-    "image_framework:image",
     "ipc:ipc_core",
     "kv_store:distributeddb",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
     "udmf:udmf_client",
+    "udmf:utd_client",
   ]
   cflags_cc = [ "-fvisibility=hidden" ]
   subsystem_name = "distributeddatamgr"
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/lifecycle/lifecycle_manager.cpp b/datamgr_service/services/distributeddataservice/service/udmf/lifecycle/lifecycle_manager.cpp
index f628847d943db71eb27b24794ed3b7cedc386a9d..c756012227678f60ae14f2055f142174bb5f862f 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/lifecycle/lifecycle_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/lifecycle/lifecycle_manager.cpp
@@ -26,6 +26,7 @@ namespace UDMF {
 using CleanAfterGet = LifeCyclePolicy;
 std::unordered_map<std::string, std::shared_ptr<LifeCyclePolicy>> LifeCycleManager::intentionPolicy_ = {
     { UD_INTENTION_MAP.at(UD_INTENTION_DRAG), std::make_shared<CleanAfterGet>() },
+    { UD_INTENTION_MAP.at(UD_INTENTION_DATA_HUB), std::make_shared<CleanAfterGet>() }
 };
 
 LifeCycleManager &LifeCycleManager::GetInstance()
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.cpp b/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.cpp
index c6215277df20f2ff8b9b68ee440e515ea8833965..4d5281432ce22f5092e3f407cea15bd258bb707e 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.cpp
@@ -31,7 +31,7 @@ UriPermissionManager &UriPermissionManager::GetInstance()
 }
 
 Status UriPermissionManager::GrantUriPermission(
-    const std::vector<Uri> &allUri, uint32_t tokenId, const std::string &queryKey)
+    const std::vector<Uri> &allUri, uint32_t tokenId, const std::string &queryKey, uint32_t &completeCount)
 {
     std::string bundleName;
     if (!PreProcessUtils::GetHapBundleNameByToken(tokenId, bundleName)) {
@@ -57,9 +57,11 @@ Status UriPermissionManager::GrantUriPermission(
                 status, queryKey.c_str(), instIndex);
             return E_NO_PERMISSION;
         }
+        completeCount = std::min(allUri.size(), index + GRANT_URI_PERMISSION_MAX_SIZE);
         auto time = std::chrono::steady_clock::now() + std::chrono::minutes(INTERVAL);
         std::for_each(uriLst.begin(), uriLst.end(), [&](const Uri &uri) {
-            uriTimeout_[std::make_pair(uri.ToString(), tokenId)] = time;
+            auto times = std::make_pair(uri.ToString(), tokenId);
+            uriTimeout_.Insert(times, time);
         });
     }
     ZLOGI("GrantUriPermission end, url size:%{public}zu, queryKey:%{public}s.", allUri.size(), queryKey.c_str());
@@ -75,7 +77,7 @@ Status UriPermissionManager::GrantUriPermission(
 void UriPermissionManager::RevokeUriPermission()
 {
     auto current = std::chrono::steady_clock::now();
-    uriTimeout_.EraseIf([&](auto &key, Time &time) {
+    uriTimeout_.EraseIf([&](const auto &key, const Time &time) {
         if (time > current) {
             return false;
         }
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.h b/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.h
index 87be83cdd3c6ac837403caa8b3f5d8aa8505c2b5..61dacb660422ff31d93c855324ef6ead79151ec2 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/permission/uri_permission_manager.h
@@ -30,7 +30,8 @@ class UriPermissionManager {
 public:
     using Time = std::chrono::steady_clock::time_point;
     static UriPermissionManager &GetInstance();
-    Status GrantUriPermission(const std::vector<Uri> &allUri, uint32_t tokenId, const std::string &queryKey);
+    Status GrantUriPermission(const std::vector<Uri> &allUri, uint32_t tokenId,
+        const std::string &queryKey, uint32_t &completeCount);
     void SetThreadPool(std::shared_ptr<ExecutorPool> executors);
 
 private:
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp b/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp
index 64885ff06ddc9136bf26806a34028a47fb007c59..b89ab80fbdc40469b5789f5d5145390047ce9714 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.cpp
@@ -37,7 +37,8 @@ namespace UDMF {
 static constexpr int ID_LEN = 32;
 static constexpr int MINIMUM = 48;
 static constexpr int MAXIMUM = 121;
-const char SPECIAL = '^';
+constexpr char SPECIAL = '^';
+constexpr const char *FILE_SCHEME = "file";
 static constexpr uint32_t VERIFY_URI_PERMISSION_MAX_SIZE = 500;
 using namespace Security::AccessToken;
 using namespace OHOS::AppFileService::ModuleRemoteFileShare;
@@ -170,8 +171,10 @@ int32_t PreProcessUtils::SetRemoteUri(uint32_t tokenId, UnifiedData &data)
                 continue;
             }
             Uri uri(file->GetUri());
-            if (uri.GetAuthority().empty()) {
-                ZLOGW("Get uri authority empty.");
+            std::string scheme = uri.GetScheme();
+            std::transform(scheme.begin(), scheme.end(), scheme.begin(), ::tolower);
+            if (uri.GetAuthority().empty() || scheme != FILE_SCHEME) {
+                ZLOGW("Get uri authority empty or uri scheme not equals to file.");
                 continue;
             }
             uris.push_back(file->GetUri());
@@ -181,14 +184,17 @@ int32_t PreProcessUtils::SetRemoteUri(uint32_t tokenId, UnifiedData &data)
         if (!CheckUriAuthorization(uris, tokenId)) {
             ZLOGE("CheckUriAuthorization failed, bundleName:%{public}s, tokenId: %{public}d, uris size:%{public}zu.",
                   data.GetRuntime()->createPackage.c_str(), tokenId, uris.size());
-            RADAR_REPORT(BizScene::SET_DATA, SetDataStage::VERIFY_SHARE_PERMISSIONS, StageRes::FAILED,
-                         ERROR_CODE, E_NO_PERMISSION);
+            RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+                BizScene::SET_DATA, SetDataStage::VERIFY_SHARE_PERMISSIONS, StageRes::FAILED, E_NO_PERMISSION);
             return E_NO_PERMISSION;
         }
+        if (!IsNetworkingEnabled()) {
+            return E_OK;
+        }
         int ret = GetDfsUrisFromLocal(uris, userId, data);
         if (ret != E_OK) {
-            RADAR_REPORT(BizScene::SET_DATA, SetDataStage::GERERATE_DFS_URI, StageRes::FAILED,
-                         ERROR_CODE, E_FS_ERROR);
+            RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+                BizScene::SET_DATA, SetDataStage::GERERATE_DFS_URI, StageRes::FAILED, E_FS_ERROR);
             ZLOGE("Get remoteUri failed, ret = %{public}d, userId: %{public}d, uri size:%{public}zu.",
                   ret, userId, uris.size());
             return E_FS_ERROR;
@@ -248,5 +254,16 @@ bool PreProcessUtils::GetInstIndex(uint32_t tokenId, int32_t &instIndex)
     instIndex = tokenInfo.instIndex;
     return true;
 }
+
+bool PreProcessUtils::IsNetworkingEnabled()
+{
+    std::vector<AppDistributedKv::DeviceInfo> devInfos =
+        DistributedData::DeviceManagerAdapter::GetInstance().GetRemoteDevices();
+    ZLOGI("DM remote devices count is %{public}u.", static_cast<uint32_t>(devInfos.size()));
+    if (devInfos.empty()) {
+        return false;
+    }
+    return true;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h b/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h
index 70e9c6ee07775d7a20ae6e23e2ef385111e0c6fe..11ecccbb6660ee89c1965148cba8846d85aa24b3 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/preprocess/preprocess_utils.h
@@ -38,6 +38,7 @@ public:
     static bool IsFileType(UDType udType);
     static int32_t SetRemoteUri(uint32_t tokenId, UnifiedData &data);
     static bool GetInstIndex(uint32_t tokenId, int32_t &instIndex);
+    static bool IsNetworkingEnabled();
 private:
     static bool CheckUriAuthorization(const std::vector<std::string>& uris, uint32_t tokenId);
     static int32_t GetDfsUrisFromLocal(const std::vector<std::string> &uris, int32_t userId, UnifiedData &data);
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.cpp b/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.cpp
index d6dd6a0de5178555aff8d67aac0c20f7a6e981f9..e75733dfe1de5c789fa3db46fff111bc34104992 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.cpp
@@ -40,7 +40,7 @@ using namespace DistributedDB;
 using Anonymous = OHOS::DistributedData::Anonymous;
 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 
-const std::string TEMP_UNIFIED_DATA_FLAG = "temp_udmf_file_flag";
+constexpr const char *TEMP_UNIFIED_DATA_FLAG = "temp_udmf_file_flag";
 static constexpr size_t TEMP_UDATA_RECORD_SIZE = 1;
 
 RuntimeStore::RuntimeStore(const std::string &storeId) : storeId_(storeId)
@@ -277,23 +277,82 @@ Status RuntimeStore::Sync(const std::vector<std::string> &devices)
             }
         }
         if (dbStatus != DBStatus::OK) {
-            RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, ERROR_CODE, dbStatus);
+            RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+                BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, dbStatus);
         } else {
-            RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::SUCCESS,
-                         BIZ_STATE, BizState::DFX_NORMAL_END);
+            RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+                BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
         }
 
         ZLOGI("sync complete, %{public}s, status:%{public}d.", Anonymous::Change(storeId_).c_str(), dbStatus);
     };
     DBStatus status = kvStore_->Sync(syncDevices, SyncMode::SYNC_MODE_PULL_ONLY, onComplete);
     if (status != DBStatus::OK) {
-        RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, ERROR_CODE, status);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, status);
         ZLOGE("Sync kvStore failed, status: %{public}d.", status);
         return E_DB_ERROR;
     }
     return E_OK;
 }
 
+Status RuntimeStore::Sync(const std::vector<std::string> &devices, ProcessCallback callback)
+{
+    UpdateTime();
+    if (devices.empty()) {
+        ZLOGE("devices empty, no need sync.");
+        return E_INVALID_PARAMETERS;
+    }
+    std::vector<std::string> syncDevices = DmAdapter::ToUUID(devices);
+    DevNameMap deviceNameMap;
+    for (const auto &device : devices) {
+        std::string deviceUuid = DmAdapter::GetInstance().ToUUID(device);
+        std::string deviceName = DmAdapter::GetInstance().GetDeviceInfo(device).deviceName;
+        deviceNameMap.emplace(deviceUuid, deviceName);
+    }
+    auto progressCallback = [this, callback, deviceNameMap](const DevSyncProcessMap &processMap) {
+        this->NotifySyncProcss(processMap, callback, deviceNameMap);
+    };
+
+    DistributedDB::DeviceSyncOption option;
+    option.devices = syncDevices;
+    option.isWait = false;
+    DBStatus status = kvStore_->Sync(option, progressCallback);
+    if (status != DBStatus::OK) {
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, status);
+        ZLOGE("Sync kvStore failed, status: %{public}d.", status);
+        return E_DB_ERROR;
+    }
+    return E_OK;
+}
+
+void RuntimeStore::NotifySyncProcss(const DevSyncProcessMap &processMap, ProcessCallback callback,
+    const DevNameMap &deviceNameMap)
+{
+    AsyncProcessInfo processInfo{ASYNC_IDLE, ASYNC_IDLE, "", 0, 0, 0, 0, 0};
+    for (const auto &[originDeviceId, syncProcess] : processMap) { // only one device
+        processInfo.srcDevName = deviceNameMap.at(originDeviceId);
+        processInfo.syncId = syncProcess.syncId;
+        processInfo.syncFinished = syncProcess.pullInfo.finishedCount;
+        processInfo.syncTotal = syncProcess.pullInfo.total;
+        if (syncProcess.process != DistributedDB::ProcessStatus::FINISHED) {
+            processInfo.syncStatus = ASYNC_RUNNING;
+            continue;
+        }
+        if (syncProcess.errCode == DBStatus::OK) {
+            processInfo.syncStatus = ASYNC_SUCCESS;
+            RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+                BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
+        } else {
+            processInfo.syncStatus = ASYNC_FAILURE;
+            RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+                BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, syncProcess.errCode);
+        }
+    }
+    callback(processInfo);
+}
+
 Status RuntimeStore::Clear()
 {
     UpdateTime();
@@ -415,7 +474,12 @@ bool RuntimeStore::SaveMetaData()
     }
 
     int foregroundUserId = 0;
-    DistributedKv::AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+    bool ret = DistributedKv::AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+    if (!ret) {
+        ZLOGE("QueryForegroundUserId failed.");
+        return false;
+    }
+
     saveMeta.dataDir.append("/").append(std::to_string(foregroundUserId));
     if (!DistributedData::DirectoryManager::GetInstance().CreateDirectory(saveMeta.dataDir)) {
         ZLOGE("Create directory error");
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.h b/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.h
index 303b4b084e785ce7cab7eced67de233e30154465..e01d6e2dfd505d5ebbbf945975cb5e46c12f15b8 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/runtime_store.h
@@ -23,6 +23,8 @@
 
 namespace OHOS {
 namespace UDMF {
+using DevNameMap = std::map<std::string, std::string>;
+using DevSyncProcessMap = std::map<std::string, DistributedDB::DeviceSyncProcess>;
 class API_EXPORT RuntimeStore final : public Store {
 public:
     explicit RuntimeStore(const std::string &storeId);
@@ -34,6 +36,7 @@ public:
     Status Delete(const std::string &key) override;
     Status DeleteBatch(const std::vector<std::string> &unifiedKeys) override;
     Status Sync(const std::vector<std::string> &devices) override;
+    Status Sync(const std::vector<std::string> &devices, ProcessCallback callback) override;
     Status Clear() override;
     Status GetBatchData(const std::string &dataPrefix, std::vector<UnifiedData> &unifiedDataSet) override;
     Status PutLocal(const std::string &key, const std::string &value) override;
@@ -60,6 +63,8 @@ private:
     bool GetDetailsFromUData(UnifiedData &data, UDDetails &details);
     Status GetSummaryFromDetails(const UDDetails &details, Summary &summary);
     bool BuildMetaDataParam(DistributedData::StoreMetaData &metaData);
+    void NotifySyncProcss(const DevSyncProcessMap &processMap, ProcessCallback callback,
+        const DevNameMap &deviceNameMap);
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/store.h b/datamgr_service/services/distributeddataservice/service/udmf/store/store.h
index 11a41da59878492753bd23dd41a81cb2d7f835a0..76471ef51c2c50d1a07c49b345e87d830421507f 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/store/store.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/store.h
@@ -27,6 +27,7 @@
 
 namespace OHOS {
 namespace UDMF {
+using ProcessCallback = std::function<void(AsyncProcessInfo &syncInfo)>;
 class Store {
 public:
     using Time = std::chrono::steady_clock::time_point;
@@ -37,6 +38,7 @@ public:
     virtual Status Delete(const std::string &key) = 0;
     virtual Status DeleteBatch(const std::vector<std::string> &unifiedKeys) = 0;
     virtual Status Sync(const std::vector<std::string> &devices) = 0;
+    virtual Status Sync(const std::vector<std::string> &devices, ProcessCallback callback) = 0;
     virtual Status Clear() = 0;
     virtual Status GetBatchData(const std::string &dataPrefix, std::vector<UnifiedData> &unifiedDataSet) = 0;
     virtual Status PutLocal(const std::string &key, const std::string &value) = 0;
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.cpp b/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1fa4c362410a14589eddb05d4c76a82c254631cb
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "RuntimeStoreAccountObserver"
+
+#include "store_account_observer.h"
+#include "runtime_store.h"
+#include "log_print.h"
+#include "directory/directory_manager.h"
+#include "account/account_delegate.h"
+#include "bootstrap.h"
+#include "ipc_skeleton.h"
+
+namespace OHOS {
+namespace UDMF {
+using namespace DistributedKv;
+using namespace DistributedData;
+void RuntimeStoreAccountObserver::OnAccountChanged(const DistributedKv::AccountEventInfo &eventInfo)
+{
+    ZLOGI("account event begin. status is %{public}d.", eventInfo.status);
+    if (eventInfo.status == DistributedKv::AccountStatus::DEVICE_ACCOUNT_DELETE) {
+        DistributedData::StoreMetaData metaData;
+        uint32_t token = IPCSkeleton::GetSelfTokenID();
+        metaData.bundleName = DistributedData::Bootstrap::GetInstance().GetProcessLabel();
+        metaData.appId = DistributedData::Bootstrap::GetInstance().GetProcessLabel();
+        metaData.user = eventInfo.userId;
+        metaData.tokenId = token;
+        metaData.securityLevel = DistributedKv::SecurityLevel::S1;
+        metaData.area = DistributedKv::Area::EL1;
+        metaData.storeType = DistributedKv::KvStoreType::SINGLE_VERSION;
+        metaData.dataDir = DistributedData::DirectoryManager::GetInstance().GetStorePath(metaData);
+        std::string userPath = metaData.dataDir.append("/").append(eventInfo.userId);
+        DistributedData::DirectoryManager::GetInstance().DeleteDirectory(userPath.c_str());
+    }
+}
+
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.h b/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c352fd9cd66c1d403c8e7d4f25202b6554ad777f
--- /dev/null
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/store_account_observer.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef STORE_ACCOUNT_OBSERVER_H
+#define STORE_ACCOUNT_OBSERVER_H
+
+#include "account_delegate.h"
+namespace OHOS {
+namespace UDMF {
+class RuntimeStoreAccountObserver : public DistributedKv::AccountDelegate::Observer {
+    void OnAccountChanged(const DistributedKv::AccountEventInfo &eventInfo) override;
+    // must specify unique name for observer
+    std::string Name() override
+    {
+        return "UdmfRuntimeStore";
+    }
+    
+    LevelType GetLevel() override
+    {
+        return LevelType::LOW;
+    }
+};
+
+} // namespace UDMF
+} // namespace OHOS
+
+#endif // STORE_ACCOUNT_OBSERVER_H
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/store/store_cache.cpp b/datamgr_service/services/distributeddataservice/service/udmf/store/store_cache.cpp
index 9d4d9014b413b37168e190bea839377904c94bc7..f4c11ac569e6c87e217c1c297d3783ac3689f267 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/store/store_cache.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/store/store_cache.cpp
@@ -34,7 +34,11 @@ std::shared_ptr<Store> StoreCache::GetStore(std::string intention)
 {
     std::shared_ptr<Store> store;
     int foregroundUserId = 0;
-    DistributedKv::AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+    bool ret = DistributedKv::AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+    if (!ret) {
+        ZLOGE("QueryForegroundUserId failed.");
+        return nullptr;
+    }
     std::string key = intention;
     key.append(std::to_string(foregroundUserId));
 
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.cpp b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.cpp
index ec9febfc70530a3c387cc67a4b18ffab0cab251d..2a6356b765753b6743de6eb062fb814759b69cf3 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.cpp
@@ -33,6 +33,11 @@
 #include "uri.h"
 #include "utd/custom_utd_installer.h"
 #include "udmf_radar_reporter.h"
+#include "securec.h"
+#include "unified_types.h"
+#include "device_manager_adapter.h"
+#include "store_account_observer.h"
+
 
 namespace OHOS {
 namespace UDMF {
@@ -41,8 +46,10 @@ using FeatureSystem = DistributedData::FeatureSystem;
 using UdmfBehaviourMsg = OHOS::DistributedDataDfx::UdmfBehaviourMsg;
 using Reporter = OHOS::DistributedDataDfx::Reporter;
 using namespace RadarReporter;
+using namespace DistributedKv;
 constexpr const char *DRAG_AUTHORIZED_PROCESSES[] = {"msdp_sa", "collaboration_service"};
 constexpr const char *DATA_PREFIX = "udmf://";
+constexpr const char *FILE_SCHEME = "file";
 constexpr const char *PRIVILEGE_READ_AND_KEEP = "readAndKeep";
 __attribute__((used)) UdmfServiceImpl::Factory UdmfServiceImpl::factory_;
 UdmfServiceImpl::Factory::Factory()
@@ -56,6 +63,8 @@ UdmfServiceImpl::Factory::Factory()
     }, FeatureSystem::BIND_NOW);
     staticActs_ = std::make_shared<UdmfStatic>();
     FeatureSystem::GetInstance().RegisterStaticActs("udmf", staticActs_);
+    auto observer = std::make_shared<RuntimeStoreAccountObserver>();
+    DistributedKv::AccountDelegate::GetInstance()->Subscribe(observer);
 }
 
 UdmfServiceImpl::Factory::~Factory()
@@ -198,8 +207,8 @@ int32_t UdmfServiceImpl::RetrieveData(const QueryOption &query, UnifiedData &uni
         return E_DB_ERROR;
     }
     if (!CheckerManager::GetInstance().IsValid(runtime->privileges, info) && !IsPermissionInCache(query)) {
-        RADAR_REPORT(BizScene::GET_DATA, GetDataStage::VERIFY_PRIVILEGE, StageRes::FAILED,
-                     ERROR_CODE, E_NO_PERMISSION);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::GET_DATA, GetDataStage::VERIFY_PRIVILEGE, StageRes::FAILED, E_NO_PERMISSION);
         return E_NO_PERMISSION;
     }
 
@@ -277,16 +286,21 @@ int32_t UdmfServiceImpl::ProcessUri(const QueryOption &query, UnifiedData &unifi
                 continue;
             }
             Uri uri(file->GetUri());
-            if (uri.GetAuthority().empty()) {
-                ZLOGW("Get authority is empty, key=%{public}s.", query.key.c_str());
+            std::string scheme = uri.GetScheme();
+            std::transform(scheme.begin(), scheme.end(), scheme.begin(), ::tolower);
+            if (uri.GetAuthority().empty() || scheme != FILE_SCHEME) {
+                ZLOGW("Get authority is empty or uri scheme not equals to file, key=%{public}s.", query.key.c_str());
                 continue;
             }
             allUri.push_back(uri);
         }
     }
-    if (UriPermissionManager::GetInstance().GrantUriPermission(allUri, query.tokenId, query.key) != E_OK) {
-        RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GRANT_URI_PERMISSION, StageRes::FAILED,
-                     ERROR_CODE, E_NO_PERMISSION);
+    asyncProcessInfo_.permStatus = ASYNC_RUNNING;
+    asyncProcessInfo_.permTotal = allUri.size();
+    if (UriPermissionManager::GetInstance().GrantUriPermission(allUri, query.tokenId, query.key,
+        asyncProcessInfo_.permFnished) != E_OK) {
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::GET_DATA, GetDataStage::GRANT_URI_PERMISSION, StageRes::FAILED, E_NO_PERMISSION);
         ZLOGE("GrantUriPermission fail, bundleName=%{public}s, key=%{public}s.",
               bundleName.c_str(), query.key.c_str());
         return E_NO_PERMISSION;
@@ -332,23 +346,26 @@ int32_t UdmfServiceImpl::GetBatchData(const QueryOption &query, std::vector<Unif
 
 int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifiedData)
 {
-    ZLOGD("start");
     if (!unifiedData.IsValid()) {
         ZLOGE("UnifiedData is invalid.");
         return E_INVALID_PARAMETERS;
     }
-
     UnifiedKey key(query.key);
     if (!key.IsValid()) {
         ZLOGE("Unified key: %{public}s is invalid.", query.key.c_str());
         return E_INVALID_PARAMETERS;
     }
+    std::string bundleName;
+    PreProcessUtils::GetHapBundleNameByToken(query.tokenId, bundleName);
+    if (key.bundleName != bundleName) {
+        ZLOGE("update data failed by %{public}s, key: %{public}s.", bundleName.c_str(), query.key.c_str());
+        return E_INVALID_PARAMETERS;
+    }
     auto store = StoreCache::GetInstance().GetStore(key.intention);
     if (store == nullptr) {
         ZLOGE("Get store failed, intention: %{public}s.", key.intention.c_str());
         return E_DB_ERROR;
     }
-
     UnifiedData data;
     int32_t res = store->Get(query.key, data);
     if (res != E_OK) {
@@ -363,6 +380,10 @@ int32_t UdmfServiceImpl::UpdateData(const QueryOption &query, UnifiedData &unifi
     if (runtime == nullptr) {
         return E_DB_ERROR;
     }
+    if (runtime->tokenId != query.tokenId) {
+        ZLOGE("update data failed, query option tokenId not equals data's tokenId");
+        return E_INVALID_PARAMETERS;
+    }
     runtime->lastModifiedTime = PreProcessUtils::GetTimestamp();
     unifiedData.SetRuntime(*runtime);
     for (auto &record : unifiedData.GetRecords()) {
@@ -396,9 +417,16 @@ int32_t UdmfServiceImpl::DeleteData(const QueryOption &query, std::vector<Unifie
         if (runtime == nullptr) {
             return E_DB_ERROR;
         }
-        unifiedDataSet.push_back(data);
-        deleteKeys.push_back(runtime->key.key);
+        if (runtime->tokenId == query.tokenId) {
+            unifiedDataSet.push_back(data);
+            deleteKeys.push_back(runtime->key.key);
+        }
+    }
+    if (deleteKeys.empty()) {
+        ZLOGE("Delete nothing. There is no data belonging to this application");
+        return E_OK;
     }
+    ZLOGI("Delete data start. size: %{public}zu.", deleteKeys.size());
     if (store->DeleteBatch(deleteKeys) != E_OK) {
         ZLOGE("Remove data failed.");
         return E_DB_ERROR;
@@ -484,7 +512,8 @@ int32_t UdmfServiceImpl::AddPrivilege(const QueryOption &query, Privilege &privi
 int32_t UdmfServiceImpl::Sync(const QueryOption &query, const std::vector<std::string> &devices)
 {
     ZLOGD("start");
-    RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_BEGIN, StageRes::IDLE, BIZ_STATE, BizState::DFX_BEGIN);
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::SYNC_DATA, SyncDataStage::SYNC_BEGIN, StageRes::IDLE, BizState::DFX_BEGIN);
     UnifiedKey key(query.key);
     if (!key.IsValid()) {
         ZLOGE("Unified key: %{public}s is invalid.", query.key.c_str());
@@ -496,14 +525,32 @@ int32_t UdmfServiceImpl::Sync(const QueryOption &query, const std::vector<std::s
         ZLOGE("Get store failed, intention: %{public}s.", key.intention.c_str());
         return E_DB_ERROR;
     }
-
-    if (store->Sync(devices) != E_OK) {
+    syncingData_ = true;
+    if (devices.size() > 0) {
+        syncingDevName_ = DistributedData::DeviceManagerAdapter::GetInstance().GetDeviceInfo(devices[0]).deviceName;
+    }
+    auto callback = [this](AsyncProcessInfo &syncInfo) {
+        asyncProcessInfo_.syncId = syncInfo.syncId;
+        asyncProcessInfo_.syncStatus = syncInfo.syncStatus;
+        asyncProcessInfo_.syncTotal = syncInfo.syncTotal;
+        asyncProcessInfo_.syncFinished = syncInfo.syncFinished;
+        asyncProcessInfo_.srcDevName = syncInfo.srcDevName;
+        if (asyncProcessInfo_.syncStatus != ASYNC_RUNNING) {
+            syncingData_ = false;
+        }
+        ZLOGD("store.Sync: name=%{public}s, id=%{public}u, status=%{public}u, total=%{public}u, finish=%{public}u",
+            syncInfo.srcDevName.c_str(), syncInfo.syncId, syncInfo.syncStatus,
+            syncInfo.syncTotal, syncInfo.syncFinished);
+    };
+    if (store->Sync(devices, callback) != E_OK) {
+        syncingData_ = false;
         ZLOGE("Store sync failed, intention: %{public}s.", key.intention.c_str());
-        RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, ERROR_CODE, E_DB_ERROR,
-                     BIZ_STATE, BizState::DFX_ABNORMAL_END);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::FAILED, E_DB_ERROR, BizState::DFX_ABNORMAL_END);
         return E_DB_ERROR;
     }
-    RADAR_REPORT(BizScene::SYNC_DATA, SyncDataStage::SYNC_BEGIN, StageRes::SUCCESS);
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::SYNC_DATA, SyncDataStage::SYNC_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
     return E_OK;
 }
 
@@ -711,5 +758,21 @@ int32_t UdmfServiceImpl::UdmfStatic::OnAppUninstall(const std::string &bundleNam
     }
     return status;
 }
+
+int32_t UdmfServiceImpl::ObtainAsynProcess(AsyncProcessInfo &processInfo)
+{
+    processInfo = asyncProcessInfo_;
+    if (syncingData_ && processInfo.syncStatus != ASYNC_RUNNING) {
+        processInfo.syncStatus = ASYNC_RUNNING;
+        processInfo.srcDevName = syncingDevName_;
+    }
+    return E_OK;
+}
+
+int32_t UdmfServiceImpl::ClearAsynProcess()
+{
+    (void)memset_s(&asyncProcessInfo_, sizeof(asyncProcessInfo_), 0, sizeof(asyncProcessInfo_));
+    return E_OK;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.h b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.h
index e172fe22e55c5b3bf411a765aa7f13112f6b1c69..ca9a11071ccb4267a7509b965c43c77510ab6d62 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_impl.h
@@ -51,6 +51,8 @@ public:
     int32_t RemoveAppShareOption(const std::string &intention) override;
     int32_t OnInitialize() override;
     int32_t OnBind(const BindInfo &bindInfo) override;
+    int32_t ObtainAsynProcess(AsyncProcessInfo &processInfo) override;
+    int32_t ClearAsynProcess() override;
 
 private:
     int32_t SaveData(CustomOption &option, UnifiedData &unifiedData, std::string &key);
@@ -81,6 +83,10 @@ private:
     static Factory factory_;
     std::map<std::string, Privilege> privilegeCache_;
     std::shared_ptr<ExecutorPool> executors_;
+
+    AsyncProcessInfo asyncProcessInfo_{};
+    bool syncingData_{false};
+    std::string syncingDevName_;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.cpp b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.cpp
index c71b3572c0854d5f9ce1929933b64240cc053c2d..2523b196844908bac1e50eee85e36f0784026c14 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.cpp
+++ b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.cpp
@@ -263,5 +263,29 @@ int32_t UdmfServiceStub::OnRemoveAppShareOption(MessageParcel &data, MessageParc
     }
     return E_OK;
 }
+
+int32_t UdmfServiceStub::OnObtainAsynProcess(MessageParcel &data, MessageParcel &reply)
+{
+    ZLOGD("start");
+    AsyncProcessInfo processInfo;
+    int32_t status = ObtainAsynProcess(processInfo);
+    if (!ITypesUtil::Marshal(reply, status, processInfo)) {
+        ZLOGE("Marshal status or processInfo failed, status: %{public}d", status);
+        return E_WRITE_PARCEL_ERROR;
+    }
+    return E_OK;
+}
+
+int32_t UdmfServiceStub::OnClearAsynProcess(MessageParcel &data, MessageParcel &reply)
+{
+    ZLOGD("start");
+    int32_t status = ClearAsynProcess();
+    if (!ITypesUtil::Marshal(reply, status)) {
+        ZLOGE("Marshal status failed, status: %{public}d", status);
+        return E_WRITE_PARCEL_ERROR;
+    }
+    return E_OK;
+}
+
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.h b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.h
index 0cd2879f72d4c48927c70e0e74ebd0fbdef855f7..e3a66a588f875d877c951f4681b68f746827aca8 100644
--- a/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.h
+++ b/datamgr_service/services/distributeddataservice/service/udmf/udmf_service_stub.h
@@ -48,6 +48,8 @@ private:
     int32_t OnSetAppShareOption(MessageParcel &data, MessageParcel &reply);
     int32_t OnGetAppShareOption(MessageParcel &data, MessageParcel &reply);
     int32_t OnRemoveAppShareOption(MessageParcel &data, MessageParcel &reply);
+    int32_t OnObtainAsynProcess(MessageParcel &data, MessageParcel &reply);
+    int32_t OnClearAsynProcess(MessageParcel &data, MessageParcel &reply);
 
     using Handler = int32_t (UdmfServiceStub::*)(MessageParcel &data, MessageParcel &reply);
     static constexpr Handler HANDLERS[static_cast<uint32_t>(UdmfServiceInterfaceCode::CODE_BUTT)] = {
@@ -62,7 +64,9 @@ private:
         &UdmfServiceStub::OnIsRemoteData,
         &UdmfServiceStub::OnSetAppShareOption,
         &UdmfServiceStub::OnGetAppShareOption,
-        &UdmfServiceStub::OnRemoveAppShareOption
+        &UdmfServiceStub::OnRemoveAppShareOption,
+        &UdmfServiceStub::OnObtainAsynProcess,
+        &UdmfServiceStub::OnClearAsynProcess
     };
 };
 } // namespace UDMF
diff --git a/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.cpp
index 3a41a383dda087bdadd1b07b8380508a5830414f..4101a168ffeadef294eaf7bc4ae3a885fc9f0550 100644
--- a/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.cpp
+++ b/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.cpp
@@ -17,14 +17,14 @@
 
 #include "checker/checker_manager.h"
 #include "cloud/cloud_sync_finished_event.h"
-#include "device_matrix.h"
-#include "store/auto_cache.h"
 #include "device_manager_adapter.h"
+#include "device_matrix.h"
 #include "eventcenter/event_center.h"
 #include "log_print.h"
 #include "metadata/matrix_meta_data.h"
 #include "metadata/meta_data_manager.h"
 #include "metadata/store_meta_data.h"
+#include "store/auto_cache.h"
 #include "utils/anonymous.h"
 #include "utils/constant.h"
 
@@ -39,7 +39,7 @@ WaterVersionManager &WaterVersionManager::GetInstance()
 }
 WaterVersionManager::WaterVersionManager() : waterVersions_(BUTT)
 {
-    for (int i = 0; i < BUTT; ++i) {
+    for (int i = 0; i < static_cast<int>(BUTT); ++i) {
         waterVersions_[i].SetType(static_cast<Type>(i));
     }
 }
@@ -58,7 +58,7 @@ void WaterVersionManager::Init()
     }
     MetaDataManager::GetInstance().LoadMeta(WaterVersionMetaData::GetPrefix(), metas, true);
     for (auto &meta : metas) {
-        if (meta.type < 0 || meta.type > BUTT) {
+        if (meta.type < BEGIN || meta.type > BUTT) {
             ZLOGW("error meta:%{public}s", meta.ToAnonymousString().c_str());
             continue;
         }
@@ -90,7 +90,7 @@ std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleN
     if (CheckerManager::GetInstance().IsStatic(info)) {
         type = STATIC;
     }
-    if (type < 0 || type >= BUTT || bundleName.empty() || storeName.empty()) {
+    if (type < BEGIN || type >= BUTT || bundleName.empty() || storeName.empty()) {
         ZLOGE("invalid args. bundleName:%{public}s, storeName:%{public}s, type:%{public}d", bundleName.c_str(),
             Anonymous::Change(storeName).c_str(), type);
         return "";
@@ -111,7 +111,7 @@ std::string WaterVersionManager::GetWaterVersion(const std::string &bundleName,
     if (CheckerManager::GetInstance().IsStatic(info)) {
         type = STATIC;
     }
-    if (type < 0 || type >= BUTT || bundleName.empty() || storeName.empty()) {
+    if (type < BEGIN || type >= BUTT || bundleName.empty() || storeName.empty()) {
         ZLOGE("invalid args. bundleName:%{public}s, storeName:%{public}s, type:%{public}d", bundleName.c_str(),
             Anonymous::Change(storeName).c_str(), type);
         return "";
@@ -137,7 +137,7 @@ std::string WaterVersionManager::GetWaterVersion(const std::string &bundleName,
 std::pair<bool, uint64_t> WaterVersionManager::GetVersion(const std::string &deviceId,
     WaterVersionManager::Type type)
 {
-    if (type < 0 || type >= BUTT || deviceId.empty()) {
+    if (type < BEGIN || type >= BUTT || deviceId.empty()) {
         ZLOGE("invalid args, type:%{public}d", type);
         return { false, 0 };
     }
@@ -147,7 +147,7 @@ std::pair<bool, uint64_t> WaterVersionManager::GetVersion(const std::string &dev
 
 std::string WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type)
 {
-    if (type < 0 || type >= BUTT || deviceId.empty()) {
+    if (type < BEGIN || type >= BUTT || deviceId.empty()) {
         ZLOGE("invalid args, type:%{public}d", type);
         return { false, 0 };
     }
@@ -181,7 +181,7 @@ bool WaterVersionManager::DelWaterVersion(const std::string &deviceId)
 
 bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData)
 {
-    metaData.waterVersion = 0;
+    metaData.waterVersion = WaterVersionMetaData::DEFAULT_VERSION;
     std::string uuid = DMAdapter::GetInstance().GetLocalDevice().uuid;
     for (size_t i = 0; i < metaData.keys.size(); ++i) {
         auto key = metaData.keys[i];
@@ -326,7 +326,7 @@ bool WaterVersionMetaData::Unmarshal(const Serializable::json &node)
     GetValue(node, GET_NAME(waterVersion), waterVersion);
     int32_t tmp = -1;
     GetValue(node, GET_NAME(type), tmp);
-    if (tmp < 0 || tmp >= BUTT) {
+    if (tmp < BEGIN || tmp >= BUTT) {
         return false;
     }
     type = static_cast<Type>(tmp);
@@ -360,7 +360,7 @@ std::string WaterVersionMetaData::GetPrefix()
 
 bool WaterVersionMetaData::IsValid()
 {
-    if (type < 0 || type >= BUTT) {
+    if (type < BEGIN || type >= BUTT) {
         return false;
     }
     if (keys.size() != infos.size()) {
diff --git a/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.h b/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.h
index bdf83e9fdc99973ca65607c9fa51c57a3b36907d..7e77513fa9978e529372d4a589fa32a880b7a201 100644
--- a/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.h
+++ b/datamgr_service/services/distributeddataservice/service/waterversion/water_version_manager.h
@@ -25,7 +25,8 @@ namespace DistributedData {
 class WaterVersionManager {
 public:
     enum Type {
-        DYNAMIC,
+        BEGIN,
+        DYNAMIC = BEGIN,
         STATIC,
         BUTT
     };
diff --git a/googletest/BUILD.bazel b/googletest/BUILD.bazel
index 965c518d7a7c4e2a4f642706e8fc57a9542ca14f..ac62251e10172614d93b385777e52defc187cac4 100644
--- a/googletest/BUILD.bazel
+++ b/googletest/BUILD.bazel
@@ -30,19 +30,32 @@
 #
 #   Bazel Build for Google C++ Testing Framework(Google Test)
 
-load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
-
 package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])
 
 exports_files(["LICENSE"])
 
+config_setting(
+    name = "qnx",
+    constraint_values = ["@platforms//os:qnx"],
+)
+
 config_setting(
     name = "windows",
     constraint_values = ["@platforms//os:windows"],
 )
 
+config_setting(
+    name = "freebsd",
+    constraint_values = ["@platforms//os:freebsd"],
+)
+
+config_setting(
+    name = "openbsd",
+    constraint_values = ["@platforms//os:openbsd"],
+)
+
 config_setting(
     name = "msvc_compiler",
     flag_values = {
@@ -86,6 +99,7 @@ cc_library(
         "googlemock/include/gmock/*.h",
     ]),
     copts = select({
+        ":qnx": [],
         ":windows": [],
         "//conditions:default": ["-pthread"],
     }),
@@ -104,7 +118,16 @@ cc_library(
         "googletest/include",
     ],
     linkopts = select({
+        ":qnx": ["-lregex"],
         ":windows": [],
+        ":freebsd": [
+            "-lm",
+            "-pthread",
+        ],
+        ":openbsd": [
+            "-lm",
+            "-pthread",
+        ],
         "//conditions:default": ["-pthread"],
     }),
     deps = select({
@@ -112,10 +135,15 @@ cc_library(
             "@com_google_absl//absl/debugging:failure_signal_handler",
             "@com_google_absl//absl/debugging:stacktrace",
             "@com_google_absl//absl/debugging:symbolize",
+            "@com_google_absl//absl/flags:flag",
+            "@com_google_absl//absl/flags:parse",
+            "@com_google_absl//absl/flags:reflection",
+            "@com_google_absl//absl/flags:usage",
             "@com_google_absl//absl/strings",
             "@com_google_absl//absl/types:any",
             "@com_google_absl//absl/types:optional",
             "@com_google_absl//absl/types:variant",
+            "@com_googlesource_code_re2//:re2",
         ],
         "//conditions:default": [],
     }),
diff --git a/googletest/BUILD.gn b/googletest/BUILD.gn
index f890da313f08df81408399e7c6388c94a640c8f6..ec835ee7af80c60e564adb4051b7529280e96ab4 100644
--- a/googletest/BUILD.gn
+++ b/googletest/BUILD.gn
@@ -7,68 +7,100 @@ config("gtest_private_config") {
   include_dirs = [ "googletest" ]
 }
 
+config("gtest_private_config_rtti") {
+  visibility = [ ":*" ]
+  include_dirs = [ "googletest" ]
+  cflags = [ "-frtti" ]
+  cflags_objcc = [ "-frtti" ]
+  cflags_cc = [ "-frtti" ]
+}
+
 config("gtest_config") {
   include_dirs = [ "googletest/include" ]
+  cflags_cc = [
+    "-std=c++17",
+    "-Wno-float-equal",
+    "-Wno-sign-compare",
+    "-Wno-reorder-init-list",
+  ]
   if (is_mingw) {
-    cflags_cc = [
+    cflags_cc += [
       "-Wno-unused-const-variable",
       "-Wno-unused-private-field",
     ]
   }
 }
 
+sources_files = [
+  "googletest/include/gtest/gtest-death-test.h",
+  "googletest/include/gtest/gtest-matchers.h",
+  "googletest/include/gtest/gtest-message.h",
+  "googletest/include/gtest/gtest-param-test.h",
+  "googletest/include/gtest/gtest-printers.h",
+  "googletest/include/gtest/gtest-test-part.h",
+  "googletest/include/gtest/gtest-typed-test.h",
+  "googletest/include/gtest/gtest_pred_impl.h",
+  "googletest/include/gtest/gtest_prod.h",
+  "googletest/include/gtest/hwext/gtest-ext.h",
+  "googletest/include/gtest/hwext/gtest-filter.h",
+  "googletest/include/gtest/hwext/gtest-multithread.h",
+  "googletest/include/gtest/hwext/gtest-tag.h",
+  "googletest/include/gtest/hwext/utils.h",
+  "googletest/include/gtest/internal/custom/gtest-port.h",
+  "googletest/include/gtest/internal/custom/gtest-printers.h",
+  "googletest/include/gtest/internal/custom/gtest.h",
+  "googletest/include/gtest/internal/gtest-death-test-internal.h",
+  "googletest/include/gtest/internal/gtest-filepath.h",
+  "googletest/include/gtest/internal/gtest-internal.h",
+  "googletest/include/gtest/internal/gtest-param-util.h",
+  "googletest/include/gtest/internal/gtest-port-arch.h",
+  "googletest/include/gtest/internal/gtest-port.h",
+  "googletest/include/gtest/internal/gtest-string.h",
+  "googletest/include/gtest/internal/gtest-type-util.h",
+  "googletest/src/gtest-all.cc",
+  "googletest/src/gtest-assertion-result.cc",
+  "googletest/src/gtest-death-test.cc",
+  "googletest/src/gtest-filepath.cc",
+  "googletest/src/gtest-internal-inl.h",
+  "googletest/src/gtest-matchers.cc",
+  "googletest/src/gtest-port.cc",
+  "googletest/src/gtest-printers.cc",
+  "googletest/src/gtest-test-part.cc",
+  "googletest/src/gtest-typed-test.cc",
+  "googletest/src/gtest.cc",
+  "googletest/src/hwext/gtest-ext.cc",
+  "googletest/src/hwext/gtest-filter.cc",
+  "googletest/src/hwext/gtest-multithread.cpp",
+  "googletest/src/hwext/gtest-tag.cc",
+  "googletest/src/hwext/gtest-utils.cc",
+]
+
 static_library("gtest") {
   testonly = true
   public = [
     "googletest/include/gtest/gtest-spi.h",
     "googletest/include/gtest/gtest.h",
   ]
-  sources = [
-    "googletest/include/gtest/gtest-death-test.h",
-    "googletest/include/gtest/gtest-matchers.h",
-    "googletest/include/gtest/gtest-message.h",
-    "googletest/include/gtest/gtest-param-test.h",
-    "googletest/include/gtest/gtest-printers.h",
-    "googletest/include/gtest/gtest-test-part.h",
-    "googletest/include/gtest/gtest-typed-test.h",
-    "googletest/include/gtest/gtest_pred_impl.h",
-    "googletest/include/gtest/gtest_prod.h",
-    "googletest/include/gtest/hwext/gtest-ext.h",
-    "googletest/include/gtest/hwext/gtest-filter.h",
-    "googletest/include/gtest/hwext/gtest-tag.h",
-    "googletest/include/gtest/hwext/utils.h",
-    "googletest/include/gtest/internal/custom/gtest-port.h",
-    "googletest/include/gtest/internal/custom/gtest-printers.h",
-    "googletest/include/gtest/internal/custom/gtest.h",
-    "googletest/include/gtest/internal/gtest-death-test-internal.h",
-    "googletest/include/gtest/internal/gtest-filepath.h",
-    "googletest/include/gtest/internal/gtest-internal.h",
-    "googletest/include/gtest/internal/gtest-param-util.h",
-    "googletest/include/gtest/internal/gtest-port-arch.h",
-    "googletest/include/gtest/internal/gtest-port.h",
-    "googletest/include/gtest/internal/gtest-string.h",
-    "googletest/include/gtest/internal/gtest-type-util.h",
-    "googletest/src/gtest-all.cc",
-    "googletest/src/gtest-death-test.cc",
-    "googletest/src/gtest-filepath.cc",
-    "googletest/src/gtest-internal-inl.h",
-    "googletest/src/gtest-matchers.cc",
-    "googletest/src/gtest-port.cc",
-    "googletest/src/gtest-printers.cc",
-    "googletest/src/gtest-test-part.cc",
-    "googletest/src/gtest-typed-test.cc",
-    "googletest/src/gtest.cc",
-    "googletest/src/hwext/gtest-ext.cc",
-    "googletest/src/hwext/gtest-filter.cc",
-    "googletest/src/hwext/gtest-tag.cc",
-    "googletest/src/hwext/gtest-utils.cc",
-  ]
+  sources = sources_files
   sources -= [ "googletest/src/gtest-all.cc" ]
   public_configs = [ ":gtest_config" ]
   configs += [ ":gtest_private_config" ]
   configs -= [ "//build/config/coverage:default_coverage" ]
 }
 
+static_library("gtest_rtti") {
+  testonly = true
+  public = [
+    "googletest/include/gtest/gtest-spi.h",
+    "googletest/include/gtest/gtest.h",
+  ]
+  sources = sources_files
+  sources -= [ "googletest/src/gtest-all.cc" ]
+  public_configs = [ ":gtest_config" ]
+  configs += [ ":gtest_private_config_rtti" ]
+  configs -= [ "//build/config/coverage:default_coverage" ]
+}
+
 static_library("gtest_main") {
   testonly = true
   sources = [ "googletest/src/gtest_main.cc" ]
@@ -81,6 +113,14 @@ config("gmock_private_config") {
   include_dirs = [ "googlemock" ]
 }
 
+config("gmock_private_config_rtti") {
+  visibility = [ ":*" ]
+  include_dirs = [ "googlemock/include" ]
+  cflags = [ "-frtti" ]
+  cflags_objcc = [ "-frtti" ]
+  cflags_cc = [ "-frtti" ]
+}
+
 config("gmock_config") {
   include_dirs = [ "googlemock/include" ]
 
@@ -94,31 +134,33 @@ config("gmock_config") {
   ]
 }
 
+gmock_sources_files = [
+  "googlemock/include/gmock/gmock-actions.h",
+  "googlemock/include/gmock/gmock-cardinalities.h",
+  "googlemock/include/gmock/gmock-function-mocker.h",
+  "googlemock/include/gmock/gmock-matchers.h",
+  "googlemock/include/gmock/gmock-more-actions.h",
+  "googlemock/include/gmock/gmock-more-matchers.h",
+  "googlemock/include/gmock/gmock-nice-strict.h",
+  "googlemock/include/gmock/gmock-spec-builders.h",
+  "googlemock/include/gmock/internal/custom/gmock-generated-actions.h",
+  "googlemock/include/gmock/internal/custom/gmock-matchers.h",
+  "googlemock/include/gmock/internal/custom/gmock-port.h",
+  "googlemock/include/gmock/internal/gmock-internal-utils.h",
+  "googlemock/include/gmock/internal/gmock-port.h",
+  "googlemock/include/gmock/internal/gmock-pp.h",
+  "googlemock/src/gmock-all.cc",
+  "googlemock/src/gmock-cardinalities.cc",
+  "googlemock/src/gmock-internal-utils.cc",
+  "googlemock/src/gmock-matchers.cc",
+  "googlemock/src/gmock-spec-builders.cc",
+  "googlemock/src/gmock.cc",
+]
+
 static_library("gmock") {
   testonly = true
   public = [ "googlemock/include/gmock/gmock.h" ]
-  sources = [
-    "googlemock/include/gmock/gmock-actions.h",
-    "googlemock/include/gmock/gmock-cardinalities.h",
-    "googlemock/include/gmock/gmock-function-mocker.h",
-    "googlemock/include/gmock/gmock-matchers.h",
-    "googlemock/include/gmock/gmock-more-actions.h",
-    "googlemock/include/gmock/gmock-more-matchers.h",
-    "googlemock/include/gmock/gmock-nice-strict.h",
-    "googlemock/include/gmock/gmock-spec-builders.h",
-    "googlemock/include/gmock/internal/custom/gmock-generated-actions.h",
-    "googlemock/include/gmock/internal/custom/gmock-matchers.h",
-    "googlemock/include/gmock/internal/custom/gmock-port.h",
-    "googlemock/include/gmock/internal/gmock-internal-utils.h",
-    "googlemock/include/gmock/internal/gmock-port.h",
-    "googlemock/include/gmock/internal/gmock-pp.h",
-    "googlemock/src/gmock-all.cc",
-    "googlemock/src/gmock-cardinalities.cc",
-    "googlemock/src/gmock-internal-utils.cc",
-    "googlemock/src/gmock-matchers.cc",
-    "googlemock/src/gmock-spec-builders.cc",
-    "googlemock/src/gmock.cc",
-  ]
+  sources = gmock_sources_files
   sources -= [ "googlemock/src/gmock-all.cc" ]
   public_configs = [ ":gmock_config" ]
   configs += [ ":gmock_private_config" ]
@@ -126,6 +168,17 @@ static_library("gmock") {
   deps = [ ":gtest" ]
 }
 
+static_library("gmock_rtti") {
+  testonly = true
+  public = [ "googlemock/include/gmock/gmock.h" ]
+  sources = gmock_sources_files
+  sources -= [ "googlemock/src/gmock-all.cc" ]
+  public_configs = [ ":gmock_config" ]
+  configs += [ ":gmock_private_config_rtti" ]
+  configs -= [ "//build/config/coverage:default_coverage" ]
+  deps = [ ":gtest_rtti" ]
+}
+
 static_library("gmock_main") {
   testonly = true
   sources = [ "googlemock/src/gmock_main.cc" ]
diff --git a/googletest/CMakeLists.txt b/googletest/CMakeLists.txt
index ea81ab1292d0b9099ac389b6c71885b0e6a1d034..6af414371f7a1c038d5834dc8707a6ac34bed7b5 100644
--- a/googletest/CMakeLists.txt
+++ b/googletest/CMakeLists.txt
@@ -1,19 +1,25 @@
 # Note: CMake support is community-based. The maintainers do not use CMake
 # internally.
 
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
 
 if (POLICY CMP0048)
   cmake_policy(SET CMP0048 NEW)
 endif (POLICY CMP0048)
 
+if (POLICY CMP0069)
+  cmake_policy(SET CMP0069 NEW)
+endif (POLICY CMP0069)
+
+if (POLICY CMP0077)
+  cmake_policy(SET CMP0077 NEW)
+endif (POLICY CMP0077)
+
 project(googletest-distribution)
-set(GOOGLETEST_VERSION 1.11.0)
+set(GOOGLETEST_VERSION 1.13.0)
 
-if (CMAKE_VERSION VERSION_GREATER "3.0.2")
-  if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-  endif()
+if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
+  set(CMAKE_CXX_EXTENSIONS OFF)
 endif()
 
 enable_testing()
@@ -24,6 +30,7 @@ include(GNUInstallDirs)
 #Note that googlemock target already builds googletest
 option(BUILD_GMOCK "Builds the googlemock subproject" ON)
 option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON)
+option(GTEST_HAS_ABSL "Use Abseil and RE2. Requires Abseil and RE2 to be separately added to the build." OFF)
 
 if(BUILD_GMOCK)
   add_subdirectory( googlemock )
diff --git a/googletest/CONTRIBUTING.md b/googletest/CONTRIBUTING.md
index da45e4450ce7f155f809f058b6f8a9d05d7642ce..de14c8159b17e367dd0098c7202e13439a06ff89 100644
--- a/googletest/CONTRIBUTING.md
+++ b/googletest/CONTRIBUTING.md
@@ -21,8 +21,8 @@ accept your pull requests.
 
 ## Are you a Googler?
 
-If you are a Googler, please make an attempt to submit an internal change rather
-than a GitHub Pull Request. If you are not able to submit an internal change a
+If you are a Googler, please make an attempt to submit an internal contribution
+rather than a GitHub Pull Request. If you are not able to submit internally, a
 PR is acceptable as an alternative.
 
 ## Contributing A Patch
@@ -36,7 +36,8 @@ PR is acceptable as an alternative.
     This ensures that work isn't being duplicated and communicating your plan
     early also generally leads to better patches.
 4.  If your proposed change is accepted, and you haven't already done so, sign a
-    Contributor License Agreement (see details above).
+    Contributor License Agreement
+    ([see details above](#contributor-license-agreements)).
 5.  Fork the desired repo, develop and test your code changes.
 6.  Ensure that your code adheres to the existing style in the sample to which
     you are contributing.
@@ -79,8 +80,8 @@ fairly rigid coding style, as defined by the
 [google-styleguide](https://github.com/google/styleguide) project. All patches
 will be expected to conform to the style outlined
 [here](https://google.github.io/styleguide/cppguide.html). Use
-[.clang-format](https://github.com/google/googletest/blob/master/.clang-format)
-to check your formatting.
+[.clang-format](https://github.com/google/googletest/blob/main/.clang-format) to
+check your formatting.
 
 ## Requirements for Contributors
 
diff --git a/googletest/CONTRIBUTORS b/googletest/CONTRIBUTORS
index 76db0b40ffb3fe70d5f321d78eade1d1e226fc43..77397a5b53fea5352f8af38bdb1c4a0ce0e30d66 100644
--- a/googletest/CONTRIBUTORS
+++ b/googletest/CONTRIBUTORS
@@ -34,6 +34,7 @@ Manuel Klimek <klimek@google.com>
 Mario Tanev <radix@google.com>
 Mark Paskin
 Markus Heule <markus.heule@gmail.com>
+Martijn Vels <mvels@google.com>
 Matthew Simmons <simmonmt@acm.org>
 Mika Raento <mikie@iki.fi>
 Mike Bland <mbland@google.com>
@@ -55,6 +56,7 @@ Russ Rufer <russ@pentad.com>
 Sean Mcafee <eefacm@gmail.com>
 Sigurður Ásgeirsson <siggi@google.com>
 Sverre Sundsdal <sundsdal@gmail.com>
+Szymon Sobik <sobik.szymon@gmail.com>
 Takeshi Yoshino <tyoshino@google.com>
 Tracy Bialik <tracy@pentad.com>
 Vadim Berman <vadimb@google.com>
diff --git a/googletest/OAT.xml b/googletest/OAT.xml
index 79905db41139117bf9c6e76cc3557747e7b42163..c876d65fb8e91a0de3a3a20afe3890f97fc778ef 100644
--- a/googletest/OAT.xml
+++ b/googletest/OAT.xml
@@ -64,12 +64,9 @@ Note:If the text contains special characters, please escape them according to th
 				<filteritem type="filepath" name="googletest/googlemock/configure.ac " desc="Non-licensing declaration file."/>
 				<filteritem type="filepath" name="googletest/googlemock/Makefile.am " desc="Non-licensing declaration file."/>
 			</filefilter>
-			<filefilter name="defaultPolicyFilter" desc="Filters for compatibility，license header policies">
-                <filteritem type="filename" name=".*" desc="not used in ohos"/>
-            </filefilter>
-            <filefilter name="binaryFileTypePolicyFilter" desc="Filters for binaryFile" >
-                <filteritem type="filename" name=".*" desc="not used in ohos"/>
-            </filefilter>
+			<filefilter name="binaryFileTypePolicyFilter" desc="Filters for binary file policies">
+				<filteritem type="filepath" name="googletest/src/hwext/gtest-filter.cc " desc="Non-licensing declaration file."/>
+			</filefilter>
 		</filefilterlist>
 	</oatconfig>
 </configuration>
\ No newline at end of file
diff --git a/googletest/README.OpenSource b/googletest/README.OpenSource
index b7b7997fbd79b7af2c19d8428b4e8999613cc9cc..625a7c0218d489558691447758b7d7bdda8abc5d 100644
--- a/googletest/README.OpenSource
+++ b/googletest/README.OpenSource
@@ -3,9 +3,9 @@
     "Name": "googletest",
     "License": "BSD 3-Clause License",
     "License File": "LICENSE",
-    "Version Number": "1.11.0",
-    "Owner": "zhangchunbao@huawei.com",
-    "Upstream URL": "https://github.com/google/googletest/releases/tag/release-1.11.0",
-    "Description": "The 1.11.x is the last release supporting pre-C++11 compilers. The 1.11.x will not accept any requests for any new features and any bugfix requests will only be accepted if proven critical"
+    "Version Number": "1.13.0",
+    "Owner": "",
+    "Upstream URL": "https://github.com/google/googletest/archive/refs/tags/v1.13.0.tar.gz",
+    "Description": "The 1.13.x only supports compilers above C++14. The 1.13.x will not accept any requests for any new features and any bugfix requests will only be accepted if proven critical"
   }
-]
+]
\ No newline at end of file
diff --git a/googletest/README.md b/googletest/README.md
index 7d872a57ed456934329d0872d42fb5e6c30def7e..cd89abb2d2daea7d0feef40f2496106a9bfd31f4 100644
--- a/googletest/README.md
+++ b/googletest/README.md
@@ -6,7 +6,8 @@
 
 GoogleTest now follows the
 [Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support).
-We recommend using the latest commit in the `master` branch in your projects.
+We recommend
+[updating to the latest commit in the `main` branch as often as possible](https://github.com/abseil/abseil-cpp/blob/master/FAQ.md#what-is-live-at-head-and-how-do-i-do-it).
 
 #### Documentation Updates
 
@@ -14,11 +15,14 @@ Our documentation is now live on GitHub Pages at
 https://google.github.io/googletest/. We recommend browsing the documentation on
 GitHub Pages rather than directly in the repository.
 
-#### Release 1.10.x
+#### Release 1.12.1
 
-[Release 1.10.x](https://github.com/google/googletest/releases/tag/release-1.10.0)
+[Release 1.12.1](https://github.com/google/googletest/releases/tag/release-1.12.1)
 is now available.
 
+The 1.12.x branch will be the last to support C++11. Future releases will
+require at least C++14.
+
 #### Coming Soon
 
 *   We are planning to take a dependency on
@@ -55,39 +59,12 @@ More information about building GoogleTest can be found at
 
 ## Supported Platforms
 
-GoogleTest requires a codebase and compiler compliant with the C++11 standard or
-newer.
-
-The GoogleTest code is officially supported on the following platforms.
-Operating systems or tools not listed below are community-supported. For
-community-supported platforms, patches that do not complicate the code may be
-considered.
-
-If you notice any problems on your platform, please file an issue on the
-[GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues).
-Pull requests containing fixes are welcome!
-
-### Operating Systems
-
-*   Linux
-*   macOS
-*   Windows
-
-### Compilers
-
-*   gcc 5.0+
-*   clang 5.0+
-*   MSVC 2015+
-
-**macOS users:** Xcode 9.3+ provides clang 5.0+.
-
-### Build Systems
-
-*   [Bazel](https://bazel.build/)
-*   [CMake](https://cmake.org/)
-
-**Note:** Bazel is the build system used by the team internally and in tests.
-CMake is supported on a best-effort basis and by the community.
+GoogleTest follows Google's
+[Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support).
+See
+[this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md)
+for a list of currently supported versions compilers, platforms, and build
+tools.
 
 ## Who Is Using GoogleTest?
 
@@ -109,8 +86,8 @@ Windows and Linux platforms.
 
 [GoogleTest UI](https://github.com/ospector/gtest-gbar) is a test runner that
 runs your test binary, allows you to track its progress via a progress bar, and
-displays a list of test failures. Clicking on one shows failure text. Google
-Test UI is written in C#.
+displays a list of test failures. Clicking on one shows failure text. GoogleTest
+UI is written in C#.
 
 [GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event
 listener for GoogleTest that implements the
@@ -121,11 +98,11 @@ result output. If your test runner understands TAP, you may find it useful.
 runs tests from your binary in parallel to provide significant speed-up.
 
 [GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter)
-is a VS Code extension allowing to view GoogleTest in a tree view, and run/debug
+is a VS Code extension allowing to view GoogleTest in a tree view and run/debug
 your tests.
 
 [C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS
-Code extension allowing to view GoogleTest in a tree view, and run/debug your
+Code extension allowing to view GoogleTest in a tree view and run/debug your
 tests.
 
 [Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser
@@ -134,7 +111,7 @@ that generates stub code for GoogleTest.
 ## Contributing Changes
 
 Please read
-[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/master/CONTRIBUTING.md)
+[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/main/CONTRIBUTING.md)
 for details on how to contribute to this project.
 
 Happy testing!
diff --git a/googletest/WORKSPACE b/googletest/WORKSPACE
index 614f55778e6e1f33235300fe60cbe167c2c34845..0f10a6a9a8691036391e8acd814e500a33f5a7bf 100644
--- a/googletest/WORKSPACE
+++ b/googletest/WORKSPACE
@@ -3,22 +3,38 @@ workspace(name = "com_google_googletest")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
-    name = "com_google_absl",
-    urls = ["https://github.com/abseil/abseil-cpp/archive/7971fb358ae376e016d2d4fc9327aad95659b25e.zip"],  # 2021-05-20T02:59:16Z
-    strip_prefix = "abseil-cpp-7971fb358ae376e016d2d4fc9327aad95659b25e",
-    sha256 = "aeba534f7307e36fe084b452299e49b97420667a8d28102cf9a0daeed340b859",
+    name = "com_google_absl",  # 2023-01-10T21:08:25Z
+    sha256 = "f9a4e749f42c386a32a90fddf0e2913ed408d10c42f7f33ccf4c59ac4f0d1d05",
+    strip_prefix = "abseil-cpp-52835439ca90d86b27bf8cd1708296e95604d724",
+    urls = ["https://github.com/abseil/abseil-cpp/archive/52835439ca90d86b27bf8cd1708296e95604d724.zip"],
 )
 
+# Note this must use a commit from the `abseil` branch of the RE2 project.
+# https://github.com/google/re2/tree/abseil
 http_archive(
-  name = "rules_cc",
-  urls = ["https://github.com/bazelbuild/rules_cc/archive/68cb652a71e7e7e2858c50593e5a9e3b94e5b9a9.zip"],  # 2021-05-14T14:51:14Z
-  strip_prefix = "rules_cc-68cb652a71e7e7e2858c50593e5a9e3b94e5b9a9",
-  sha256 = "1e19e9a3bc3d4ee91d7fcad00653485ee6c798efbbf9588d40b34cbfbded143d",
+    name = "com_googlesource_code_re2",  # 2022-12-21T14:29:10Z
+    sha256 = "b9ce3a51beebb38534d11d40f8928d40509b9e18a735f6a4a97ad3d014c87cb5",
+    strip_prefix = "re2-d0b1f8f2ecc2ea74956c7608b6f915175314ff0e",
+    urls = ["https://github.com/google/re2/archive/d0b1f8f2ecc2ea74956c7608b6f915175314ff0e.zip"],
 )
 
 http_archive(
-  name = "rules_python",
-  urls = ["https://github.com/bazelbuild/rules_python/archive/ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2.zip"],  # 2021-05-17T00:24:16Z
-  strip_prefix = "rules_python-ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2",
-  sha256 = "98b3c592faea9636ac8444bfd9de7f3fb4c60590932d6e6ac5946e3f8dbd5ff6",
+    name = "rules_python",  # 2023-01-10T22:00:51Z
+    sha256 = "5de54486a60ad8948dabe49605bb1c08053e04001a431ab3e96745b4d97a4419",
+    strip_prefix = "rules_python-70cce26432187a60b4e950118791385e6fb3c26f",
+    urls = ["https://github.com/bazelbuild/rules_python/archive/70cce26432187a60b4e950118791385e6fb3c26f.zip"],
+)
+
+http_archive(
+    name = "bazel_skylib",  # 2022-11-16T18:29:32Z
+    sha256 = "a22290c26d29d3ecca286466f7f295ac6cbe32c0a9da3a91176a90e0725e3649",
+    strip_prefix = "bazel-skylib-5bfcb1a684550626ce138fe0fe8f5f702b3764c3",
+    urls = ["https://github.com/bazelbuild/bazel-skylib/archive/5bfcb1a684550626ce138fe0fe8f5f702b3764c3.zip"],
+)
+
+http_archive(
+    name = "platforms",  # 2022-11-09T19:18:22Z
+    sha256 = "b4a3b45dc4202e2b3e34e3bc49d2b5b37295fc23ea58d88fb9e01f3642ad9b55",
+    strip_prefix = "platforms-3fbc687756043fb58a407c2ea8c944bc2fe1d922",
+    urls = ["https://github.com/bazelbuild/platforms/archive/3fbc687756043fb58a407c2ea8c944bc2fe1d922.zip"],
 )
diff --git a/googletest/bundle.json b/googletest/bundle.json
index 002bd1d6bb09afb58f073424096e63f5464793d5..a82e37e2ff65da76441fec08af35f0274a69c059 100644
--- a/googletest/bundle.json
+++ b/googletest/bundle.json
@@ -10,11 +10,14 @@
     "dirs": {},
     "scripts": {},
     "component": {
-        "name": "thirdparty_googletest",
-        "subsystem": "",
+        "name": "googletest",
+        "subsystem": "thirdparty",
         "syscap": [],
         "features": [],
-        "adapted_system_type": [],
+        "adapted_system_type": [
+            "small",
+            "standard"
+        ],
         "rom": "",
         "ram": "",
         "deps": {
@@ -23,8 +26,24 @@
         },
         "build": {
             "sub_component": [],
-            "inner_kits": [],
+            "inner_kits": [
+                {
+                    "name": "//third_party/googletest:gtest"
+                },
+                {
+                    "name": "//third_party/googletest:gmock"
+                },
+                {
+                    "name": "//third_party/googletest:gtest_main"
+                },
+                {
+                    "name": "//third_party/googletest:gmock_main"
+                },
+                {
+                    "name": "//third_party/googletest:gtest_rtti"
+                }
+            ],
             "test": []
         }
     }
-}
\ No newline at end of file
+}
diff --git a/googletest/ci/linux-presubmit.sh b/googletest/ci/linux-presubmit.sh
index 6bea1cde26aff516d6b7a3780fcdecacb5376388..4eb5bbe4a1dac8923fc0aa2f2d49cc38f258ec4c 100644
--- a/googletest/ci/linux-presubmit.sh
+++ b/googletest/ci/linux-presubmit.sh
@@ -31,15 +31,15 @@
 
 set -euox pipefail
 
-readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20210525"
-readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20201015"
+readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20220217"
+readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20220621"
 
 if [[ -z ${GTEST_ROOT:-} ]]; then
   GTEST_ROOT="$(realpath $(dirname ${0})/..)"
 fi
 
 if [[ -z ${STD:-} ]]; then
-  STD="c++11 c++14 c++17 c++20"
+  STD="c++14 c++17 c++20"
 fi
 
 # Test the CMake build
@@ -55,7 +55,7 @@ for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do
       ${LINUX_LATEST_CONTAINER} \
       /bin/bash -c "
         cmake /src \
-          -DCMAKE_CXX_STANDARD=11 \
+          -DCMAKE_CXX_STANDARD=14 \
           -Dgtest_build_samples=ON \
           -Dgtest_build_tests=ON \
           -Dgmock_build_tests=ON \
@@ -72,11 +72,15 @@ time docker run \
   --workdir="/src" \
   --rm \
   --env="CC=/usr/local/bin/gcc" \
+  --env="BAZEL_CXXOPTS=-std=c++14" \
   ${LINUX_GCC_FLOOR_CONTAINER} \
     /usr/local/bin/bazel test ... \
       --copt="-Wall" \
       --copt="-Werror" \
+      --copt="-Wuninitialized" \
       --copt="-Wno-error=pragmas" \
+      --distdir="/bazel-distdir" \
+      --features=external_include_paths \
       --keep_going \
       --show_timestamps \
       --test_output=errors
@@ -94,8 +98,10 @@ for std in ${STD}; do
       /usr/local/bin/bazel test ... \
         --copt="-Wall" \
         --copt="-Werror" \
+        --copt="-Wuninitialized" \
         --define="absl=${absl}" \
         --distdir="/bazel-distdir" \
+        --features=external_include_paths \
         --keep_going \
         --show_timestamps \
         --test_output=errors
@@ -116,8 +122,10 @@ for std in ${STD}; do
         --copt="--gcc-toolchain=/usr/local" \
         --copt="-Wall" \
         --copt="-Werror" \
+        --copt="-Wuninitialized" \
         --define="absl=${absl}" \
         --distdir="/bazel-distdir" \
+        --features=external_include_paths \
         --keep_going \
         --linkopt="--gcc-toolchain=/usr/local" \
         --show_timestamps \
diff --git a/googletest/ci/macos-presubmit.sh b/googletest/ci/macos-presubmit.sh
index d6423faacc3f425dd083f5771b4a42db9f9fbd5e..8f35df58d2baa1b278f468608deb517d05150a3a 100644
--- a/googletest/ci/macos-presubmit.sh
+++ b/googletest/ci/macos-presubmit.sh
@@ -40,7 +40,7 @@ for cmake_off_on in OFF ON; do
   BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX)
   cd ${BUILD_DIR}
   time cmake ${GTEST_ROOT} \
-    -DCMAKE_CXX_STANDARD=11 \
+    -DCMAKE_CXX_STANDARD=14 \
     -Dgtest_build_samples=ON \
     -Dgtest_build_tests=ON \
     -Dgmock_build_tests=ON \
@@ -53,7 +53,7 @@ done
 # Test the Bazel build
 
 # If we are running on Kokoro, check for a versioned Bazel binary.
-KOKORO_GFILE_BAZEL_BIN="bazel-3.7.0-darwin-x86_64"
+KOKORO_GFILE_BAZEL_BIN="bazel-5.1.1-darwin-x86_64"
 if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then
   BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}"
   chmod +x ${BAZEL_BIN}
@@ -66,7 +66,9 @@ for absl in 0 1; do
   ${BAZEL_BIN} test ... \
     --copt="-Wall" \
     --copt="-Werror" \
+    --cxxopt="-std=c++14" \
     --define="absl=${absl}" \
+    --features=external_include_paths \
     --keep_going \
     --show_timestamps \
     --test_output=errors
diff --git a/googletest/ci/windows-presubmit.bat b/googletest/ci/windows-presubmit.bat
new file mode 100644
index 0000000000000000000000000000000000000000..0c822d5e519793bd46140723af97e42ea827afed
--- /dev/null
+++ b/googletest/ci/windows-presubmit.bat
@@ -0,0 +1,71 @@
+@echo off
+@rem Copyright 2024 googletest authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem     http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+
+SETLOCAL ENABLEDELAYEDEXPANSION
+
+SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe
+
+SET PATH=C:\Python37;%PATH%
+SET BAZEL_PYTHON=C:\python37\python.exe
+SET BAZEL_SH=C:\tools\msys64\usr\bin\bash.exe
+SET CMAKE_BIN="C:\Program Files\CMake\bin\cmake.exe"
+SET CTEST_BIN="C:\Program Files\CMake\bin\ctest.exe"
+SET CTEST_OUTPUT_ON_FAILURE=1
+
+IF EXIST git\googletest (
+  CD git\googletest
+) ELSE IF EXIST github\googletest (
+  CD github\googletest
+)
+
+IF %errorlevel% neq 0 EXIT /B 1
+
+:: ----------------------------------------------------------------------------
+:: CMake Visual Studio 15 2017 Win64
+MKDIR cmake_msvc2017
+CD cmake_msvc2017
+
+%CMAKE_BIN% .. ^
+  -G "Visual Studio 15 2017 Win64" ^
+  -DPYTHON_EXECUTABLE:FILEPATH=c:\python37\python.exe ^
+  -DPYTHON_INCLUDE_DIR:PATH=c:\python37\include ^
+  -DPYTHON_LIBRARY:FILEPATH=c:\python37\lib\site-packages\pip ^
+  -Dgtest_build_samples=ON ^
+  -Dgtest_build_tests=ON ^
+  -Dgmock_build_tests=ON
+IF %errorlevel% neq 0 EXIT /B 1
+
+%CMAKE_BIN% --build . --target ALL_BUILD --config Debug -- -maxcpucount
+IF %errorlevel% neq 0 EXIT /B 1
+
+%CTEST_BIN% -C Debug --timeout 600
+IF %errorlevel% neq 0 EXIT /B 1
+
+CD ..
+RMDIR /S /Q cmake_msvc2017
+
+:: ----------------------------------------------------------------------------
+:: Bazel Visual Studio 15 2017 Win64
+
+SET BAZEL_VC=C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC
+%BAZEL_EXE% test ... ^
+  --compilation_mode=dbg ^
+  --copt=/std:c++14 ^
+  --copt=/WX ^
+  --features=external_include_paths ^
+  --keep_going ^
+  --test_output=errors ^
+  --test_tag_filters=-no_test_msvc2017
+IF %errorlevel% neq 0 EXIT /B 1
diff --git a/googletest/docs/_layouts/default.html b/googletest/docs/_layouts/default.html
index dcb42d9191342a42429c197623b0f8df9faded91..c7f331b87d7ddd4102791fd4d5b4122bfb0dd4b3 100644
--- a/googletest/docs/_layouts/default.html
+++ b/googletest/docs/_layouts/default.html
@@ -48,7 +48,7 @@
       <div class="footer">
         GoogleTest &middot;
         <a href="https://github.com/google/googletest">GitHub Repository</a> &middot;
-        <a href="https://github.com/google/googletest/blob/master/LICENSE">License</a> &middot;
+        <a href="https://github.com/google/googletest/blob/main/LICENSE">License</a> &middot;
         <a href="https://policies.google.com/privacy">Privacy Policy</a>
       </div>
     </div>
diff --git a/googletest/docs/advanced.md b/googletest/docs/advanced.md
index 8dff5ba1508085ae5b26a2716985eb669a90ebd8..f16382fe04fcd6fe91edb48e7e2748d3963a45e4 100644
--- a/googletest/docs/advanced.md
+++ b/googletest/docs/advanced.md
@@ -157,8 +157,11 @@ that can be used in the predicate assertion macro
 example:
 
 ```c++
-EXPECT_PRED_FORMAT2(testing::FloatLE, val1, val2);
-EXPECT_PRED_FORMAT2(testing::DoubleLE, val1, val2);
+using ::testing::FloatLE;
+using ::testing::DoubleLE;
+...
+EXPECT_PRED_FORMAT2(FloatLE, val1, val2);
+EXPECT_PRED_FORMAT2(DoubleLE, val1, val2);
 ```
 
 The above code verifies that `val1` is less than, or approximately equal to,
@@ -202,10 +205,9 @@ You can call the function
 
 to assert that types `T1` and `T2` are the same. The function does nothing if
 the assertion is satisfied. If the types are different, the function call will
-fail to compile, the compiler error message will say that
-`T1 and T2 are not the same type` and most likely (depending on the compiler)
-show you the actual values of `T1` and `T2`. This is mainly useful inside
-template code.
+fail to compile, the compiler error message will say that `T1 and T2 are not the
+same type` and most likely (depending on the compiler) show you the actual
+values of `T1` and `T2`. This is mainly useful inside template code.
 
 **Caveat**: When used inside a member function of a class template or a function
 template, `StaticAssertTypeEq<T1, T2>()` is effective only if the function is
@@ -383,10 +385,10 @@ EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
 ## Death Tests
 
 In many applications, there are assertions that can cause application failure if
-a condition is not met. These sanity checks, which ensure that the program is in
-a known good state, are there to fail at the earliest possible time after some
-program state is corrupted. If the assertion checks the wrong condition, then
-the program may proceed in an erroneous state, which could lead to memory
+a condition is not met. These consistency checks, which ensure that the program
+is in a known good state, are there to fail at the earliest possible time after
+some program state is corrupted. If the assertion checks the wrong condition,
+then the program may proceed in an erroneous state, which could lead to memory
 corruption, security holes, or worse. Hence it is vitally important to test that
 such assertion statements work as expected.
 
@@ -480,10 +482,12 @@ TEST_F(FooDeathTest, DoesThat) {
 
 ### Regular Expression Syntax
 
-On POSIX systems (e.g. Linux, Cygwin, and Mac), googletest uses the
+When built with Bazel and using Abseil, googletest uses the
+[RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX
+systems (Linux, Cygwin, Mac), googletest uses the
 [POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
-syntax. To learn about this syntax, you may want to read this
-[Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
+syntax. To learn about POSIX syntax, you may want to read this
+[Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_extended).
 
 On Windows, googletest uses its own simple regular expression implementation. It
 lacks many features. For example, we don't support union (`"x|y"`), grouping
@@ -558,7 +562,7 @@ The automated testing framework does not set the style flag. You can choose a
 particular style of death tests by setting the flag programmatically:
 
 ```c++
-testing::FLAGS_gtest_death_test_style="threadsafe"
+GTEST_FLAG_SET(death_test_style, "threadsafe")
 ```
 
 You can do this in `main()` to set the style for all death tests in the binary,
@@ -568,12 +572,12 @@ restored afterwards, so you need not do that yourself. For example:
 ```c++
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  testing::FLAGS_gtest_death_test_style = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   return RUN_ALL_TESTS();
 }
 
 TEST(MyDeathTest, TestOne) {
-  testing::FLAGS_gtest_death_test_style = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   // This test is run in the "threadsafe" style:
   ASSERT_DEATH(ThisShouldDie(), "");
 }
@@ -610,15 +614,14 @@ Despite the improved thread safety afforded by the "threadsafe" style of death
 test, thread problems such as deadlock are still possible in the presence of
 handlers registered with `pthread_atfork(3)`.
 
-
 ## Using Assertions in Sub-routines
 
 {: .callout .note}
 Note: If you want to put a series of test assertions in a subroutine to check
 for a complex condition, consider using
-[a custom GMock matcher](gmock_cook_book.md#NewMatchers)
-instead. This lets you provide a more readable error message in case of failure
-and avoid all of the issues described below.
+[a custom GMock matcher](gmock_cook_book.md#NewMatchers) instead. This lets you
+provide a more readable error message in case of failure and avoid all of the
+issues described below.
 
 ### Adding Traces to Assertions
 
@@ -631,6 +634,7 @@ the `SCOPED_TRACE` macro or the `ScopedTrace` utility:
 ```c++
 SCOPED_TRACE(message);
 ```
+
 ```c++
 ScopedTrace trace("file_path", line_number, message);
 ```
@@ -837,7 +841,7 @@ will output XML like this:
 
 ```xml
   ...
-    <testcase name="MinAndMaxWidgets" status="run" time="0.006" classname="WidgetUsageTest" MaximumWidgets="12" MinimumWidgets="9" />
+    <testcase name="MinAndMaxWidgets" file="test.cpp" line="1" status="run" time="0.006" classname="WidgetUsageTest" MaximumWidgets="12" MinimumWidgets="9" />
   ...
 ```
 
@@ -888,6 +892,12 @@ preceding or following another. Also, the tests must either not modify the state
 of any shared resource, or, if they do modify the state, they must restore the
 state to its original value before passing control to the next test.
 
+Note that `SetUpTestSuite()` may be called multiple times for a test fixture
+class that has derived classes, so you should not expect code in the function
+body to be run only once. Also, derived classes still have access to shared
+resources defined as static members, so careful consideration is needed when
+managing shared resources to avoid memory leaks.
+
 Here's an example of per-test-suite set-up and tear-down:
 
 ```c++
@@ -897,7 +907,10 @@ class FooTest : public testing::Test {
   // Called before the first test in this test suite.
   // Can be omitted if not needed.
   static void SetUpTestSuite() {
-    shared_resource_ = new ...;
+    // Avoid reallocating static objects if called in subclasses of FooTest.
+    if (shared_resource_ == nullptr) {
+      shared_resource_ = new ...;
+    }
   }
 
   // Per-test-suite tear-down.
@@ -1082,6 +1095,11 @@ instantiation of the test suite. The next argument is the name of the test
 pattern, and the last is the
 [parameter generator](reference/testing.md#param-generators).
 
+The parameter generator expression is not evaluated until GoogleTest is
+initialized (via `InitGoogleTest()`). Any prior initialization done in the
+`main` function will be accessible from the parameter generator, for example,
+the results of flag parsing.
+
 You can instantiate a test pattern more than once, so to distinguish different
 instances of the pattern, the instantiation name is added as a prefix to the
 actual test suite name. Remember to pick unique prefixes for different
@@ -1129,8 +1147,8 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FooTest);
 
 You can see [sample7_unittest.cc] and [sample8_unittest.cc] for more examples.
 
-[sample7_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample7_unittest.cc "Parameterized Test example"
-[sample8_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample8_unittest.cc "Parameterized Test example with multiple parameters"
+[sample7_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample7_unittest.cc "Parameterized Test example"
+[sample8_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample8_unittest.cc "Parameterized Test example with multiple parameters"
 
 ### Creating Value-Parameterized Abstract Tests
 
@@ -1281,7 +1299,7 @@ TYPED_TEST(FooTest, HasPropertyA) { ... }
 
 You can see [sample6_unittest.cc] for a complete example.
 
-[sample6_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample6_unittest.cc "Typed Test example"
+[sample6_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample6_unittest.cc "Typed Test example"
 
 ## Type-Parameterized Tests
 
@@ -1302,6 +1320,7 @@ First, define a fixture class template, as we did with typed tests:
 ```c++
 template <typename T>
 class FooTest : public testing::Test {
+  void DoSomethingInteresting();
   ...
 };
 ```
@@ -1319,6 +1338,9 @@ this as many times as you want:
 TYPED_TEST_P(FooTest, DoesBlah) {
   // Inside a test, refer to TypeParam to get the type parameter.
   TypeParam n = 0;
+
+  // You will need to use `this` explicitly to refer to fixture members.
+  this->DoSomethingInteresting()
   ...
 }
 
@@ -1481,8 +1503,8 @@ In frameworks that report a failure by throwing an exception, you could catch
 the exception and assert on it. But googletest doesn't use exceptions, so how do
 we test that a piece of code generates an expected failure?
 
-`"gtest/gtest-spi.h"` contains some constructs to do this. After #including this header,
-you can use
+`"gtest/gtest-spi.h"` contains some constructs to do this.
+After #including this header, you can use
 
 ```c++
   EXPECT_FATAL_FAILURE(statement, substring);
@@ -1586,12 +1608,14 @@ void RegisterMyTests(const std::vector<int>& values) {
 }
 ...
 int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
   std::vector<int> values_to_test = LoadValuesFromConfig();
   RegisterMyTests(values_to_test);
   ...
   return RUN_ALL_TESTS();
 }
 ```
+
 ## Getting the Current Test's Name
 
 Sometimes a function may need to know the name of the currently running test.
@@ -1714,7 +1738,7 @@ You can do so by adding one line:
 Now, sit back and enjoy a completely different output from your tests. For more
 details, see [sample9_unittest.cc].
 
-[sample9_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample9_unittest.cc "Event listener example"
+[sample9_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample9_unittest.cc "Event listener example"
 
 You may append more than one listener to the list. When an `On*Start()` or
 `OnTestPartResult()` event is fired, the listeners will receive it in the order
@@ -1741,7 +1765,7 @@ by the former.
 
 See [sample10_unittest.cc] for an example of a failure-raising listener.
 
-[sample10_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample10_unittest.cc "Failure-raising listener example"
+[sample10_unittest.cc]: https://github.com/google/googletest/blob/main/googletest/samples/sample10_unittest.cc "Failure-raising listener example"
 
 ## Running Test Programs: Advanced Options
 
@@ -1816,8 +1840,7 @@ By default, a googletest program runs all tests the user has defined. In some
 cases (e.g. iterative test development & execution) it may be desirable stop
 test execution upon first failure (trading improved latency for completeness).
 If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set,
-the test runner will stop execution as soon as the first test failure is
-found.
+the test runner will stop execution as soon as the first test failure is found.
 
 #### Temporarily Disabling Tests
 
@@ -1890,8 +1913,12 @@ Repeat the tests whose name matches the filter 1000 times.
 
 If your test program contains
 [global set-up/tear-down](#global-set-up-and-tear-down) code, it will be
-repeated in each iteration as well, as the flakiness may be in it. You can also
-specify the repeat count by setting the `GTEST_REPEAT` environment variable.
+repeated in each iteration as well, as the flakiness may be in it. To avoid
+repeating global set-up/tear-down, specify
+`--gtest_recreate_environments_when_repeating=false`{.nowrap}.
+
+You can also specify the repeat count by setting the `GTEST_REPEAT` environment
+variable.
 
 ### Shuffling the Tests
 
@@ -1911,6 +1938,58 @@ time.
 If you combine this with `--gtest_repeat=N`, googletest will pick a different
 random seed and re-shuffle the tests in each iteration.
 
+### Distributing Test Functions to Multiple Machines
+
+If you have more than one machine you can use to run a test program, you might
+want to run the test functions in parallel and get the result faster. We call
+this technique *sharding*, where each machine is called a *shard*.
+
+GoogleTest is compatible with test sharding. To take advantage of this feature,
+your test runner (not part of GoogleTest) needs to do the following:
+
+1.  Allocate a number of machines (shards) to run the tests.
+1.  On each shard, set the `GTEST_TOTAL_SHARDS` environment variable to the total
+    number of shards. It must be the same for all shards.
+1.  On each shard, set the `GTEST_SHARD_INDEX` environment variable to the index
+    of the shard. Different shards must be assigned different indices, which
+    must be in the range `[0, GTEST_TOTAL_SHARDS - 1]`.
+1.  Run the same test program on all shards. When GoogleTest sees the above two
+    environment variables, it will select a subset of the test functions to run.
+    Across all shards, each test function in the program will be run exactly
+    once.
+1.  Wait for all shards to finish, then collect and report the results.
+
+Your project may have tests that were written without GoogleTest and thus don't
+understand this protocol. In order for your test runner to figure out which test
+supports sharding, it can set the environment variable `GTEST_SHARD_STATUS_FILE`
+to a non-existent file path. If a test program supports sharding, it will create
+this file to acknowledge that fact; otherwise it will not create it. The actual
+contents of the file are not important at this time, although we may put some
+useful information in it in the future.
+
+Here's an example to make it clear. Suppose you have a test program `foo_test`
+that contains the following 5 test functions:
+
+```
+TEST(A, V)
+TEST(A, W)
+TEST(B, X)
+TEST(B, Y)
+TEST(B, Z)
+```
+
+Suppose you have 3 machines at your disposal. To run the test functions in
+parallel, you would set `GTEST_TOTAL_SHARDS` to 3 on all machines, and set
+`GTEST_SHARD_INDEX` to 0, 1, and 2 on the machines respectively. Then you would
+run the same `foo_test` on each machine.
+
+GoogleTest reserves the right to change how the work is distributed across the
+shards, but here's one possible scenario:
+
+*   Machine #0 runs `A.V` and `B.X`.
+*   Machine #1 runs `A.W` and `B.Y`.
+*   Machine #2 runs `B.Z`.
+
 ### Controlling Test Output
 
 #### Colored Terminal Output
@@ -1965,8 +2044,6 @@ text because, for example, you don't have an UTF-8 compatible output medium, run
 the test program with `--gtest_print_utf8=0` or set the `GTEST_PRINT_UTF8`
 environment variable to `0`.
 
-
-
 #### Generating an XML Report
 
 googletest can emit a detailed XML report to a file in addition to its normal
@@ -2020,15 +2097,15 @@ could generate this report:
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="3" failures="1" errors="0" time="0.035" timestamp="2011-10-31T18:52:42" name="AllTests">
   <testsuite name="MathTest" tests="2" failures="1" errors="0" time="0.015">
-    <testcase name="Addition" status="run" time="0.007" classname="">
+    <testcase name="Addition" file="test.cpp" line="1" status="run" time="0.007" classname="">
       <failure message="Value of: add(1, 1)&#x0A;  Actual: 3&#x0A;Expected: 2" type="">...</failure>
       <failure message="Value of: add(1, -1)&#x0A;  Actual: 1&#x0A;Expected: 0" type="">...</failure>
     </testcase>
-    <testcase name="Subtraction" status="run" time="0.005" classname="">
+    <testcase name="Subtraction" file="test.cpp" line="2" status="run" time="0.005" classname="">
     </testcase>
   </testsuite>
   <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="0.005">
-    <testcase name="NonContradiction" status="run" time="0.005" classname="">
+    <testcase name="NonContradiction" file="test.cpp" line="3" status="run" time="0.005" classname="">
     </testcase>
   </testsuite>
 </testsuites>
@@ -2046,6 +2123,9 @@ Things to note:
 *   The `timestamp` attribute records the local date and time of the test
     execution.
 
+*   The `file` and `line` attributes record the source file location, where the
+    test was defined.
+
 *   Each `<failure>` element corresponds to a single failed googletest
     assertion.
 
@@ -2085,6 +2165,8 @@ The report format conforms to the following JSON Schema:
       "type": "object",
       "properties": {
         "name": { "type": "string" },
+        "file": { "type": "string" },
+        "line": { "type": "integer" },
         "status": {
           "type": "string",
           "enum": ["RUN", "NOTRUN"]
@@ -2162,6 +2244,8 @@ message TestCase {
 
 message TestInfo {
   string name = 1;
+  string file = 6;
+  int32 line = 7;
   enum Status {
     RUN = 0;
     NOTRUN = 1;
@@ -2205,6 +2289,8 @@ could generate this report:
       "testsuite": [
         {
           "name": "Addition",
+          "file": "test.cpp",
+          "line": 1,
           "status": "RUN",
           "time": "0.007s",
           "classname": "",
@@ -2221,6 +2307,8 @@ could generate this report:
         },
         {
           "name": "Subtraction",
+          "file": "test.cpp",
+          "line": 2,
           "status": "RUN",
           "time": "0.005s",
           "classname": ""
@@ -2236,6 +2324,8 @@ could generate this report:
       "testsuite": [
         {
           "name": "NonContradiction",
+          "file": "test.cpp",
+          "line": 3,
           "status": "RUN",
           "time": "0.005s",
           "classname": ""
@@ -2253,12 +2343,11 @@ IMPORTANT: The exact format of the JSON document is subject to change.
 
 #### Detecting Test Premature Exit
 
-Google Test implements the _premature-exit-file_ protocol for test runners
-to catch any kind of unexpected exits of test programs. Upon start,
-Google Test creates the file which will be automatically deleted after
-all work has been finished. Then, the test runner can check if this file
-exists. In case the file remains undeleted, the inspected test has exited
-prematurely.
+Google Test implements the _premature-exit-file_ protocol for test runners to
+catch any kind of unexpected exits of test programs. Upon start, Google Test
+creates the file which will be automatically deleted after all work has been
+finished. Then, the test runner can check if this file exists. In case the file
+remains undeleted, the inspected test has exited prematurely.
 
 This feature is enabled only if the `TEST_PREMATURE_EXIT_FILE` environment
 variable has been set.
diff --git a/googletest/docs/faq.md b/googletest/docs/faq.md
index 9042da1efb43a6bf0893275bb8c84e544c01c2a1..1928097292a238a81269a01c8e6bd16c96c61b9b 100644
--- a/googletest/docs/faq.md
+++ b/googletest/docs/faq.md
@@ -1,9 +1,9 @@
-# Googletest FAQ
+# GoogleTest FAQ
 
 ## Why should test suite names and test names not contain underscore?
 
 {: .callout .note}
-Note: Googletest reserves underscore (`_`) for special purpose keywords, such as
+Note: GoogleTest reserves underscore (`_`) for special purpose keywords, such as
 [the `DISABLED_` prefix](advanced.md#temporarily-disabling-tests), in addition
 to the following rationale.
 
@@ -50,15 +50,15 @@ Now, the two `TEST`s will both generate the same class
 
 So for simplicity, we just ask the users to avoid `_` in `TestSuiteName` and
 `TestName`. The rule is more constraining than necessary, but it's simple and
-easy to remember. It also gives googletest some wiggle room in case its
+easy to remember. It also gives GoogleTest some wiggle room in case its
 implementation needs to change in the future.
 
 If you violate the rule, there may not be immediate consequences, but your test
 may (just may) break with a new compiler (or a new version of the compiler you
-are using) or with a new version of googletest. Therefore it's best to follow
+are using) or with a new version of GoogleTest. Therefore it's best to follow
 the rule.
 
-## Why does googletest support `EXPECT_EQ(NULL, ptr)` and `ASSERT_EQ(NULL, ptr)` but not `EXPECT_NE(NULL, ptr)` and `ASSERT_NE(NULL, ptr)`?
+## Why does GoogleTest support `EXPECT_EQ(NULL, ptr)` and `ASSERT_EQ(NULL, ptr)` but not `EXPECT_NE(NULL, ptr)` and `ASSERT_NE(NULL, ptr)`?
 
 First of all, you can use `nullptr` with each of these macros, e.g.
 `EXPECT_EQ(ptr, nullptr)`, `EXPECT_NE(ptr, nullptr)`, `ASSERT_EQ(ptr, nullptr)`,
@@ -68,7 +68,7 @@ because `nullptr` does not have the type problems that `NULL` does.
 Due to some peculiarity of C++, it requires some non-trivial template meta
 programming tricks to support using `NULL` as an argument of the `EXPECT_XX()`
 and `ASSERT_XX()` macros. Therefore we only do it where it's most needed
-(otherwise we make the implementation of googletest harder to maintain and more
+(otherwise we make the implementation of GoogleTest harder to maintain and more
 error-prone than necessary).
 
 Historically, the `EXPECT_EQ()` macro took the *expected* value as its first
@@ -162,7 +162,7 @@ methods, the parent process will think the calls have never occurred. Therefore,
 you may want to move your `EXPECT_CALL` statements inside the `EXPECT_DEATH`
 macro.
 
-## EXPECT_EQ(htonl(blah), blah_blah) generates weird compiler errors in opt mode. Is this a googletest bug?
+## EXPECT_EQ(htonl(blah), blah_blah) generates weird compiler errors in opt mode. Is this a GoogleTest bug?
 
 Actually, the bug is in `htonl()`.
 
@@ -199,7 +199,7 @@ const int Foo::kBar;  // No initializer here.
 ```
 
 Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in googletest comparison assertions (`EXPECT_EQ`, etc) will
+particular, using it in GoogleTest comparison assertions (`EXPECT_EQ`, etc) will
 generate an "undefined reference" linker error. The fact that "it used to work"
 doesn't mean it's valid. It just means that you were lucky. :-)
 
@@ -225,7 +225,7 @@ cases may want to use the same or slightly different fixtures. For example, you
 may want to make sure that all of a GUI library's test suites don't leak
 important system resources like fonts and brushes.
 
-In googletest, you share a fixture among test suites by putting the shared logic
+In GoogleTest, you share a fixture among test suites by putting the shared logic
 in a base test fixture, then deriving from that base a separate fixture for each
 test suite that wants to use this common logic. You then use `TEST_F()` to write
 tests using each derived fixture.
@@ -264,10 +264,10 @@ TEST_F(FooTest, Baz) { ... }
 ```
 
 If necessary, you can continue to derive test fixtures from a derived fixture.
-googletest has no limit on how deep the hierarchy can be.
+GoogleTest has no limit on how deep the hierarchy can be.
 
 For a complete example using derived test fixtures, see
-[sample5_unittest.cc](https://github.com/google/googletest/blob/master/googletest/samples/sample5_unittest.cc).
+[sample5_unittest.cc](https://github.com/google/googletest/blob/main/googletest/samples/sample5_unittest.cc).
 
 ## My compiler complains "void value not ignored as it ought to be." What does this mean?
 
@@ -278,7 +278,7 @@ disabled by our build system. Please see more details
 
 ## My death test hangs (or seg-faults). How do I fix it?
 
-In googletest, death tests are run in a child process and the way they work is
+In GoogleTest, death tests are run in a child process and the way they work is
 delicate. To write death tests you really need to understand how they work—see
 the details at [Death Assertions](reference/assertions.md#death) in the
 Assertions Reference.
@@ -305,8 +305,8 @@ bullet - sorry!
 
 ## Should I use the constructor/destructor of the test fixture or SetUp()/TearDown()? {#CtorVsSetUp}
 
-The first thing to remember is that googletest does **not** reuse the same test
-fixture object across multiple tests. For each `TEST_F`, googletest will create
+The first thing to remember is that GoogleTest does **not** reuse the same test
+fixture object across multiple tests. For each `TEST_F`, GoogleTest will create
 a **fresh** test fixture object, immediately call `SetUp()`, run the test body,
 call `TearDown()`, and then delete the test fixture object.
 
@@ -328,7 +328,7 @@ You may still want to use `SetUp()/TearDown()` in the following cases:
 
 *   C++ does not allow virtual function calls in constructors and destructors.
     You can call a method declared as virtual, but it will not use dynamic
-    dispatch, it will use the definition from the class the constructor of which
+    dispatch. It will use the definition from the class the constructor of which
     is currently executing. This is because calling a virtual method before the
     derived class constructor has a chance to run is very dangerous - the
     virtual method might operate on uninitialized data. Therefore, if you need
@@ -345,11 +345,11 @@ You may still want to use `SetUp()/TearDown()` in the following cases:
     that many standard libraries (like STL) may throw when exceptions are
     enabled in the compiler. Therefore you should prefer `TearDown()` if you
     want to write portable tests that work with or without exceptions.
-*   The googletest team is considering making the assertion macros throw on
+*   The GoogleTest team is considering making the assertion macros throw on
     platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux
     client-side), which will eliminate the need for the user to propagate
     failures from a subroutine to its caller. Therefore, you shouldn't use
-    googletest assertions in a destructor if your code could run on such a
+    GoogleTest assertions in a destructor if your code could run on such a
     platform.
 
 ## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it?
@@ -375,7 +375,7 @@ they write
 This is **wrong and dangerous**. The testing services needs to see the return
 value of `RUN_ALL_TESTS()` in order to determine if a test has passed. If your
 `main()` function ignores it, your test will be considered successful even if it
-has a googletest assertion failure. Very bad.
+has a GoogleTest assertion failure. Very bad.
 
 We have decided to fix this (thanks to Michael Chastain for the idea). Now, your
 code will no longer be able to ignore `RUN_ALL_TESTS()` when compiled with
@@ -410,7 +410,6 @@ C++ is case-sensitive. Did you spell it as `Setup()`?
 Similarly, sometimes people spell `SetUpTestSuite()` as `SetupTestSuite()` and
 wonder why it's never called.
 
-
 ## I have several test suites which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious.
 
 You don't have to. Instead of
@@ -441,14 +440,14 @@ TEST_F(BarTest, Abc) { ... }
 TEST_F(BarTest, Def) { ... }
 ```
 
-## googletest output is buried in a whole bunch of LOG messages. What do I do?
+## GoogleTest output is buried in a whole bunch of LOG messages. What do I do?
 
-The googletest output is meant to be a concise and human-friendly report. If
-your test generates textual output itself, it will mix with the googletest
+The GoogleTest output is meant to be a concise and human-friendly report. If
+your test generates textual output itself, it will mix with the GoogleTest
 output, making it hard to read. However, there is an easy solution to this
 problem.
 
-Since `LOG` messages go to stderr, we decided to let googletest output go to
+Since `LOG` messages go to stderr, we decided to let GoogleTest output go to
 stdout. This way, you can easily separate the two using redirection. For
 example:
 
@@ -521,7 +520,7 @@ TEST(MyDeathTest, CompoundStatement) {
 
 ## I have a fixture class `FooTest`, but `TEST_F(FooTest, Bar)` gives me error ``"no matching function for call to `FooTest::FooTest()'"``. Why?
 
-Googletest needs to be able to create objects of your test fixture class, so it
+GoogleTest needs to be able to create objects of your test fixture class, so it
 must have a default constructor. Normally the compiler will define one for you.
 However, there are cases where you have to define your own:
 
@@ -546,11 +545,11 @@ The new NPTL thread library doesn't suffer from this problem, as it doesn't
 create a manager thread. However, if you don't control which machine your test
 runs on, you shouldn't depend on this.
 
-## Why does googletest require the entire test suite, instead of individual tests, to be named *DeathTest when it uses ASSERT_DEATH?
+## Why does GoogleTest require the entire test suite, instead of individual tests, to be named *DeathTest when it uses ASSERT_DEATH?
 
-googletest does not interleave tests from different test suites. That is, it
+GoogleTest does not interleave tests from different test suites. That is, it
 runs all tests in one test suite first, and then runs all tests in the next test
-suite, and so on. googletest does this because it needs to set up a test suite
+suite, and so on. GoogleTest does this because it needs to set up a test suite
 before the first test in it is run, and tear it down afterwards. Splitting up
 the test case would require multiple set-up and tear-down processes, which is
 inefficient and makes the semantics unclean.
@@ -589,11 +588,11 @@ TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
 TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
 ```
 
-## googletest prints the LOG messages in a death test's child process only when the test fails. How can I see the LOG messages when the death test succeeds?
+## GoogleTest prints the LOG messages in a death test's child process only when the test fails. How can I see the LOG messages when the death test succeeds?
 
 Printing the LOG messages generated by the statement inside `EXPECT_DEATH()`
 makes it harder to search for real problems in the parent's log. Therefore,
-googletest only prints them when the death test has failed.
+GoogleTest only prints them when the death test has failed.
 
 If you really need to see such LOG messages, a workaround is to temporarily
 break the death test (e.g. by changing the regex pattern it is expected to
@@ -612,7 +611,7 @@ needs to be defined in the *same* name space. See
 
 ## How do I suppress the memory leak messages on Windows?
 
-Since the statically initialized googletest singleton requires allocations on
+Since the statically initialized GoogleTest singleton requires allocations on
 the heap, the Visual C++ memory leak detector will report memory leaks at the
 end of the program run. The easiest way to avoid this is to use the
 `_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
@@ -626,7 +625,7 @@ things accordingly, you are leaking test-only logic into production code and
 there is no easy way to ensure that the test-only code paths aren't run by
 mistake in production. Such cleverness also leads to
 [Heisenbugs](https://en.wikipedia.org/wiki/Heisenbug). Therefore we strongly
-advise against the practice, and googletest doesn't provide a way to do it.
+advise against the practice, and GoogleTest doesn't provide a way to do it.
 
 In general, the recommended way to cause the code to behave differently under
 test is [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection). You can inject
@@ -673,7 +672,7 @@ TEST(CoolTest, DoSomething) {
 ```
 
 However, the following code is **not allowed** and will produce a runtime error
-from googletest because the test methods are using different test fixture
+from GoogleTest because the test methods are using different test fixture
 classes with the same test suite name.
 
 ```c++
diff --git a/googletest/docs/gmock_cheat_sheet.md b/googletest/docs/gmock_cheat_sheet.md
index 17ed7a54d80933ec8fce9a0691c958809c2dedb5..2fb0403e616a79a46294a6dd5c8489f1f1dd2a78 100644
--- a/googletest/docs/gmock_cheat_sheet.md
+++ b/googletest/docs/gmock_cheat_sheet.md
@@ -8,7 +8,7 @@ Given
 
 ```cpp
 class Foo {
-  ...
+ public:
   virtual ~Foo();
   virtual int GetSize() const = 0;
   virtual string Describe(const char* name) = 0;
@@ -23,7 +23,7 @@ class Foo {
 #include "gmock/gmock.h"
 
 class MockFoo : public Foo {
-  ...
+ public:
   MOCK_METHOD(int, GetSize, (), (const, override));
   MOCK_METHOD(string, Describe, (const char* name), (override));
   MOCK_METHOD(string, Describe, (int type), (override));
@@ -58,7 +58,7 @@ To mock
 ```cpp
 template <typename Elem>
 class StackInterface {
-  ...
+ public:
   virtual ~StackInterface();
   virtual int GetSize() const = 0;
   virtual void Push(const Elem& x) = 0;
@@ -71,7 +71,7 @@ class StackInterface {
 ```cpp
 template <typename Elem>
 class MockStack : public StackInterface<Elem> {
-  ...
+ public:
   MOCK_METHOD(int, GetSize, (), (const, override));
   MOCK_METHOD(void, Push, (const Elem& x), (override));
 };
@@ -140,7 +140,7 @@ To customize the default action for functions with return type `T`, use
   // Sets the default action for return type std::unique_ptr<Buzz> to
   // creating a new Buzz every time.
   DefaultValue<std::unique_ptr<Buzz>>::SetFactory(
-      [] { return MakeUnique<Buzz>(AccessLevel::kInternal); });
+      [] { return std::make_unique<Buzz>(AccessLevel::kInternal); });
 
   // When this fires, the default action of MakeBuzz() will run, which
   // will return a new Buzz object.
@@ -230,7 +230,7 @@ class MockFunction<R(A1, ..., An)> {
 };
 ```
 
-See this [recipe](gmock_cook_book.md#using-check-points) for one application of
+See this [recipe](gmock_cook_book.md#UsingCheckPoints) for one application of
 it.
 
 ## Flags
diff --git a/googletest/docs/gmock_cook_book.md b/googletest/docs/gmock_cook_book.md
index c08958eb16ab892787db493ac667b83736b1a369..fc7db35b82c769fea0c34cf875bf6529d58cbaab 100644
--- a/googletest/docs/gmock_cook_book.md
+++ b/googletest/docs/gmock_cook_book.md
@@ -392,8 +392,7 @@ Old macros and their new equivalents:
 If a mock method has no `EXPECT_CALL` spec but is called, we say that it's an
 "uninteresting call", and the default action (which can be specified using
 `ON_CALL()`) of the method will be taken. Currently, an uninteresting call will
-also by default cause gMock to print a warning. (In the future, we might remove
-this warning by default.)
+also by default cause gMock to print a warning.
 
 However, sometimes you may want to ignore these uninteresting calls, and
 sometimes you may want to treat them as errors. gMock lets you make the decision
@@ -905,7 +904,7 @@ using ::testing::Contains;
 using ::testing::Property;
 
 inline constexpr auto HasFoo = [](const auto& f) {
-  return Property(&MyClass::foo, Contains(f));
+  return Property("foo", &MyClass::foo, Contains(f));
 };
 ...
   EXPECT_THAT(x, HasFoo("blah"));
@@ -1084,7 +1083,7 @@ using ::testing::Lt;
 ```
 
 says that `Blah` will be called with arguments `x`, `y`, and `z` where `x < y <
-z`. Note that in this example, it wasn't necessary specify the positional
+z`. Note that in this example, it wasn't necessary to specify the positional
 matchers.
 
 As a convenience and example, gMock provides some matchers for 2-tuples,
@@ -1159,7 +1158,7 @@ int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
 ```
 
 Note that the predicate function / functor doesn't have to return `bool`. It
-works as long as the return value can be used as the condition in in statement
+works as long as the return value can be used as the condition in the statement
 `if (condition) ...`.
 
 ### Matching Arguments that Are Not Copyable
@@ -1300,23 +1299,27 @@ What if you have a pointer to pointer? You guessed it - you can use nested
 `Pointee(Pointee(Lt(3)))` matches a pointer that points to a pointer that points
 to a number less than 3 (what a mouthful...).
 
-### Testing a Certain Property of an Object
+### Defining a Custom Matcher Class {#CustomMatcherClass}
 
-Sometimes you want to specify that an object argument has a certain property,
-but there is no existing matcher that does this. If you want good error
-messages, you should [define a matcher](#NewMatchers). If you want to do it
-quick and dirty, you could get away with writing an ordinary function.
+Most matchers can be simply defined using [the MATCHER* macros](#NewMatchers),
+which are terse and flexible, and produce good error messages. However, these
+macros are not very explicit about the interfaces they create and are not always
+suitable, especially for matchers that will be widely reused.
 
-Let's say you have a mock function that takes an object of type `Foo`, which has
-an `int bar()` method and an `int baz()` method, and you want to constrain that
-the argument's `bar()` value plus its `baz()` value is a given number. Here's
-how you can define a matcher to do it:
+For more advanced cases, you may need to define your own matcher class. A custom
+matcher allows you to test a specific invariant property of that object. Let's
+take a look at how to do so.
 
-```cpp
-using ::testing::Matcher;
+Imagine you have a mock function that takes an object of type `Foo`, which has
+an `int bar()` method and an `int baz()` method. You want to constrain that the
+argument's `bar()` value plus its `baz()` value is a given number. (This is an
+invariant.) Here's how we can write and use a matcher class to do so:
 
+```cpp
 class BarPlusBazEqMatcher {
  public:
+  using is_gtest_matcher = void;
+
   explicit BarPlusBazEqMatcher(int expected_sum)
       : expected_sum_(expected_sum) {}
 
@@ -1325,23 +1328,24 @@ class BarPlusBazEqMatcher {
     return (foo.bar() + foo.baz()) == expected_sum_;
   }
 
-  void DescribeTo(std::ostream& os) const {
-    os << "bar() + baz() equals " << expected_sum_;
+  void DescribeTo(std::ostream* os) const {
+    *os << "bar() + baz() equals " << expected_sum_;
   }
 
-  void DescribeNegationTo(std::ostream& os) const {
-    os << "bar() + baz() does not equal " << expected_sum_;
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "bar() + baz() does not equal " << expected_sum_;
   }
  private:
   const int expected_sum_;
 };
 
-Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
+::testing::Matcher<const Foo&> BarPlusBazEq(int expected_sum) {
   return BarPlusBazEqMatcher(expected_sum);
 }
 
 ...
-  EXPECT_CALL(..., DoThis(BarPlusBazEq(5)))...;
+  Foo foo;
+  EXPECT_THAT(foo, BarPlusBazEq(5))...;
 ```
 
 ### Matching Containers
@@ -1420,11 +1424,12 @@ Use `Pair` when comparing maps or other associative containers.
 {% raw %}
 
 ```cpp
-using testing::ElementsAre;
-using testing::Pair;
+using ::testing::UnorderedElementsAre;
+using ::testing::Pair;
 ...
-  std::map<string, int> m = {{"a", 1}, {"b", 2}, {"c", 3}};
-  EXPECT_THAT(m, ElementsAre(Pair("a", 1), Pair("b", 2), Pair("c", 3)));
+  absl::flat_hash_map<string, int> m = {{"a", 1}, {"b", 2}, {"c", 3}};
+  EXPECT_THAT(m, UnorderedElementsAre(
+      Pair("a", 1), Pair("b", 2), Pair("c", 3)));
 ```
 
 {% endraw %}
@@ -1441,8 +1446,8 @@ using testing::Pair;
 *   If the container is passed by pointer instead of by reference, just write
     `Pointee(ElementsAre*(...))`.
 *   The order of elements *matters* for `ElementsAre*()`. If you are using it
-    with containers whose element order are undefined (e.g. `hash_map`) you
-    should use `WhenSorted` around `ElementsAre`.
+    with containers whose element order are undefined (such as a
+    `std::unordered_map`) you should use `UnorderedElementsAre`.
 
 ### Sharing Matchers
 
@@ -1452,7 +1457,7 @@ the pointer is copied. When the last matcher that references the implementation
 object dies, the implementation object will be deleted.
 
 Therefore, if you have some complex matcher that you want to use again and
-again, there is no need to build it everytime. Just assign it to a matcher
+again, there is no need to build it every time. Just assign it to a matcher
 variable and use that variable repeatedly! For example,
 
 ```cpp
@@ -1754,7 +1759,7 @@ specifies the following DAG (where `s1` is `A -> B`, and `s2` is `A -> C -> D`):
        |
   A ---|
        |
-        +---> C ---> D
+       +---> C ---> D
 ```
 
 This means that A must occur before B and C, and C must occur before D. There's
@@ -1899,7 +1904,7 @@ using testing::ReturnPointee;
 ### Combining Actions
 
 Want to do more than one thing when a function is called? That's fine. `DoAll()`
-allow you to do sequence of actions every time. Only the return value of the
+allows you to do a sequence of actions every time. Only the return value of the
 last action in the sequence will be used.
 
 ```cpp
@@ -1980,6 +1985,7 @@ If the mock method also needs to return a value as well, you can chain
 
 ```cpp
 using ::testing::_;
+using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 
@@ -2033,10 +2039,7 @@ class MockRolodex : public Rolodex {
 }
 ...
   MockRolodex rolodex;
-  vector<string> names;
-  names.push_back("George");
-  names.push_back("John");
-  names.push_back("Thomas");
+  vector<string> names = {"George", "John", "Thomas"};
   EXPECT_CALL(rolodex, GetNames(_))
       .WillOnce(SetArrayArgument<0>(names.begin(), names.end()));
 ```
@@ -2604,7 +2607,7 @@ efficient. When the last action that references the implementation object dies,
 the implementation object will be deleted.
 
 If you have some complex action that you want to use again and again, you may
-not have to build it from scratch everytime. If the action doesn't have an
+not have to build it from scratch every time. If the action doesn't have an
 internal state (i.e. if it always does the same thing no matter how many times
 it has been called), you can assign it to an action variable and use that
 variable repeatedly. For example:
@@ -2781,7 +2784,7 @@ If you just need to return a pre-defined move-only value, you can use the
   // When this fires, the unique_ptr<> specified by ByMove(...) will
   // be returned.
   EXPECT_CALL(mock_buzzer_, MakeBuzz("world"))
-      .WillOnce(Return(ByMove(MakeUnique<Buzz>(AccessLevel::kInternal))));
+      .WillOnce(Return(ByMove(std::make_unique<Buzz>(AccessLevel::kInternal))));
 
   EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
 ```
@@ -2802,7 +2805,7 @@ pretty much anything you want:
 ```cpp
   EXPECT_CALL(mock_buzzer_, MakeBuzz("x"))
       .WillRepeatedly([](StringPiece text) {
-        return MakeUnique<Buzz>(AccessLevel::kInternal);
+        return std::make_unique<Buzz>(AccessLevel::kInternal);
       });
 
   EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("x"));
@@ -2821,7 +2824,7 @@ can always use `Return`, or a [lambda or functor](#FunctionsAsActions):
   using ::testing::Unused;
 
   EXPECT_CALL(mock_buzzer_, ShareBuzz(NotNull(), _)).WillOnce(Return(true));
-  EXPECT_TRUE(mock_buzzer_.ShareBuzz(MakeUnique<Buzz>(AccessLevel::kInternal)),
+  EXPECT_TRUE(mock_buzzer_.ShareBuzz(std::make_unique<Buzz>(AccessLevel::kInternal)),
               0);
 
   EXPECT_CALL(mock_buzzer_, ShareBuzz(_, _)).WillOnce(
@@ -2865,7 +2868,7 @@ method:
   // When one calls ShareBuzz() on the MockBuzzer like this, the call is
   // forwarded to DoShareBuzz(), which is mocked.  Therefore this statement
   // will trigger the above EXPECT_CALL.
-  mock_buzzer_.ShareBuzz(MakeUnique<Buzz>(AccessLevel::kInternal), 0);
+  mock_buzzer_.ShareBuzz(std::make_unique<Buzz>(AccessLevel::kInternal), 0);
 ```
 
 ### Making the Compilation Faster
@@ -3809,22 +3812,19 @@ Cardinality EvenNumber() {
       .Times(EvenNumber());
 ```
 
-### Writing New Actions Quickly {#QuickNewActions}
+### Writing New Actions {#QuickNewActions}
 
 If the built-in actions don't work for you, you can easily define your own one.
-Just define a functor class with a (possibly templated) call operator, matching
-the signature of your action.
+All you need is a call operator with a signature compatible with the mocked
+function. So you can use a lambda:
 
-```cpp
-struct Increment {
-  template <typename T>
-  T operator()(T* arg) {
-    return ++(*arg);
-  }
-}
+```
+MockFunction<int(int)> mock;
+EXPECT_CALL(mock, Call).WillOnce([](const int input) { return input * 7; });
+EXPECT_EQ(14, mock.AsStdFunction()(2));
 ```
 
-The same approach works with stateful functors (or any callable, really):
+Or a struct with a call operator (even a templated one):
 
 ```
 struct MultiplyBy {
@@ -3832,12 +3832,54 @@ struct MultiplyBy {
   T operator()(T arg) { return arg * multiplier; }
 
   int multiplier;
-}
+};
 
 // Then use:
 // EXPECT_CALL(...).WillOnce(MultiplyBy{7});
 ```
 
+It's also fine for the callable to take no arguments, ignoring the arguments
+supplied to the mock function:
+
+```
+MockFunction<int(int)> mock;
+EXPECT_CALL(mock, Call).WillOnce([] { return 17; });
+EXPECT_EQ(17, mock.AsStdFunction()(0));
+```
+
+When used with `WillOnce`, the callable can assume it will be called at most
+once and is allowed to be a move-only type:
+
+```
+// An action that contains move-only types and has an &&-qualified operator,
+// demanding in the type system that it be called at most once. This can be
+// used with WillOnce, but the compiler will reject it if handed to
+// WillRepeatedly.
+struct MoveOnlyAction {
+  std::unique_ptr<int> move_only_state;
+  std::unique_ptr<int> operator()() && { return std::move(move_only_state); }
+};
+
+MockFunction<std::unique_ptr<int>()> mock;
+EXPECT_CALL(mock, Call).WillOnce(MoveOnlyAction{std::make_unique<int>(17)});
+EXPECT_THAT(mock.AsStdFunction()(), Pointee(Eq(17)));
+```
+
+More generally, to use with a mock function whose signature is `R(Args...)` the
+object can be anything convertible to `OnceAction<R(Args...)>` or
+`Action<R(Args...)`>. The difference between the two is that `OnceAction` has
+weaker requirements (`Action` requires a copy-constructible input that can be
+called repeatedly whereas `OnceAction` requires only move-constructible and
+supports `&&`-qualified call operators), but can be used only with `WillOnce`.
+`OnceAction` is typically relevant only when supporting move-only types or
+actions that want a type-system guarantee that they will be called at most once.
+
+Typically the `OnceAction` and `Action` templates need not be referenced
+directly in your actions: a struct or class with a call operator is sufficient,
+as in the examples above. But fancier polymorphic actions that need to know the
+specific return type of the mock function can define templated conversion
+operators to make that possible. See `gmock-actions.h` for examples.
+
 #### Legacy macro-based Actions
 
 Before C++11, the functor-based actions were not supported; the old way of
@@ -4191,7 +4233,7 @@ This implementation class does *not* need to inherit from any particular class.
 What matters is that it must have a `Perform()` method template. This method
 template takes the mock function's arguments as a tuple in a **single**
 argument, and returns the result of the action. It can be either `const` or not,
-but must be invokable with exactly one template argument, which is the result
+but must be invocable with exactly one template argument, which is the result
 type. In other words, you must be able to call `Perform<R>(args)` where `R` is
 the mock function's return type and `args` is its arguments in a tuple.
 
diff --git a/googletest/docs/gmock_faq.md b/googletest/docs/gmock_faq.md
index 2cd9b3f3155966fe078e2f17809eea4b8045c7bd..8f220bf7a8fec033ed9cb827a794397315962fcc 100644
--- a/googletest/docs/gmock_faq.md
+++ b/googletest/docs/gmock_faq.md
@@ -369,8 +369,8 @@ Usually, if your action is for a particular function type, defining it using
 different types (e.g. if you are defining `Return(*value*)`),
 `MakePolymorphicAction()` is easiest. Sometimes you want precise control on what
 types of functions the action can be used in, and implementing `ActionInterface`
-is the way to go here. See the implementation of `Return()` in
-`testing/base/public/gmock-actions.h` for an example.
+is the way to go here. See the implementation of `Return()` in `gmock-actions.h`
+for an example.
 
 ### I use SetArgPointee() in WillOnce(), but gcc complains about "conflicting return type specified". What does it mean?
 
diff --git a/googletest/docs/gmock_for_dummies.md b/googletest/docs/gmock_for_dummies.md
index 1f4cc246c483109a494adc7c0b3d0981e061c77b..b7264d3587f71ada659741bd6c47ac015ff46e99 100644
--- a/googletest/docs/gmock_for_dummies.md
+++ b/googletest/docs/gmock_for_dummies.md
@@ -190,10 +190,10 @@ Some people put it in a `_test.cc`. This is fine when the interface being mocked
 `Foo` changes it, your test could break. (You can't really expect `Foo`'s
 maintainer to fix every test that uses `Foo`, can you?)
 
-So, the rule of thumb is: if you need to mock `Foo` and it's owned by others,
-define the mock class in `Foo`'s package (better, in a `testing` sub-package
-such that you can clearly separate production code and testing utilities), put
-it in a `.h` and a `cc_library`. Then everyone can reference them from their
+Generally, you should not mock classes you don't own. If you must mock such a
+class owned by others, define the mock class in `Foo`'s Bazel package (usually
+the same directory or a `testing` sub-directory), and put it in a `.h` and a
+`cc_library` with `testonly=True`. Then everyone can reference them from their
 tests. If `Foo` ever changes, there is only one copy of `MockFoo` to change, and
 only tests that depend on the changed methods need to be fixed.
 
@@ -480,8 +480,8 @@ the *default* action for the function every time (unless, of course, you have a
 `WillRepeatedly()`.).
 
 What can we do inside `WillOnce()` besides `Return()`? You can return a
-reference using `ReturnRef(*variable*)`, or invoke a pre-defined function, among
-[others](gmock_cook_book.md#using-actions).
+reference using `ReturnRef(`*`variable`*`)`, or invoke a pre-defined function,
+among [others](gmock_cook_book.md#using-actions).
 
 **Important note:** The `EXPECT_CALL()` statement evaluates the action clause
 only once, even though the action may be performed many times. Therefore you
diff --git a/googletest/docs/pkgconfig.md b/googletest/docs/pkgconfig.md
index 768e9b4c2673977f4f459dbd76c569ad490978ee..18a2546a3846acde26b930a5ee30a00cce96a570 100644
--- a/googletest/docs/pkgconfig.md
+++ b/googletest/docs/pkgconfig.md
@@ -105,7 +105,7 @@ includedir=/usr/include
 
 Name: gtest
 Description: GoogleTest (without main() function)
-Version: 1.10.0
+Version: 1.11.0
 URL: https://github.com/google/googletest
 Libs: -L${libdir} -lgtest -lpthread
 Cflags: -I${includedir} -DGTEST_HAS_PTHREAD=1 -lpthread
diff --git a/googletest/docs/primer.md b/googletest/docs/primer.md
index 6d8fdf443923cacc83425cf45d5102d9889f6241..2ffbf53bc8dff6337e8f4c4d33d6f7b4df767bbe 100644
--- a/googletest/docs/primer.md
+++ b/googletest/docs/primer.md
@@ -162,9 +162,9 @@ TEST(TestSuiteName, TestName) {
 
 `TEST()` arguments go from general to specific. The *first* argument is the name
 of the test suite, and the *second* argument is the test's name within the test
-suite. Both names must be valid C++ identifiers, and they should not contain
-any underscores (`_`). A test's *full name* consists of its containing test suite and
-its individual name. Tests from different test suites can have the same
+suite. Both names must be valid C++ identifiers, and they should not contain any
+underscores (`_`). A test's *full name* consists of its containing test suite
+and its individual name. Tests from different test suites can have the same
 individual name.
 
 For example, let's take a simple integer function:
@@ -245,8 +245,8 @@ Also, you must first define a test fixture class before using it in a
 declaration`".
 
 For each test defined with `TEST_F()`, googletest will create a *fresh* test
-fixture at runtime, immediately initialize it via `SetUp()`, run the test,
-clean up by calling `TearDown()`, and then delete the test fixture. Note that
+fixture at runtime, immediately initialize it via `SetUp()`, run the test, clean
+up by calling `TearDown()`, and then delete the test fixture. Note that
 different tests in the same test suite have different test fixture objects, and
 googletest always deletes a test fixture before it creates the next one.
 googletest does **not** reuse the same test fixture for multiple tests. Any
@@ -274,6 +274,7 @@ First, define a fixture class. By convention, you should give it the name
 class QueueTest : public ::testing::Test {
  protected:
   void SetUp() override {
+     // q0_ remains empty
      q1_.Enqueue(1);
      q2_.Enqueue(2);
      q2_.Enqueue(3);
@@ -342,8 +343,8 @@ your defined tests in order to run them.
 
 After defining your tests, you can run them with `RUN_ALL_TESTS()`, which
 returns `0` if all the tests are successful, or `1` otherwise. Note that
-`RUN_ALL_TESTS()` runs *all tests* in your link unit--they can be from
-different test suites, or even different source files.
+`RUN_ALL_TESTS()` runs *all tests* in your link unit--they can be from different
+test suites, or even different source files.
 
 When invoked, the `RUN_ALL_TESTS()` macro:
 
@@ -456,8 +457,8 @@ int main(int argc, char **argv) {
 
 The `::testing::InitGoogleTest()` function parses the command line for
 googletest flags, and removes all recognized flags. This allows the user to
-control a test program's behavior via various flags, which we'll cover in
-the [AdvancedGuide](advanced.md). You **must** call this function before calling
+control a test program's behavior via various flags, which we'll cover in the
+[AdvancedGuide](advanced.md). You **must** call this function before calling
 `RUN_ALL_TESTS()`, or the flags won't be properly initialized.
 
 On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
diff --git a/googletest/docs/quickstart-bazel.md b/googletest/docs/quickstart-bazel.md
index 362ee6d0506eb04b85fa1b40e57db3ef1c38c09a..15c27a22ed9c63eeb234e35db8f02bb63ba8c9b8 100644
--- a/googletest/docs/quickstart-bazel.md
+++ b/googletest/docs/quickstart-bazel.md
@@ -9,7 +9,7 @@ we recommend this tutorial as a starting point.
 To complete this tutorial, you'll need:
 
 *   A compatible operating system (e.g. Linux, macOS, Windows).
-*   A compatible C++ compiler that supports at least C++11.
+*   A compatible C++ compiler that supports at least C++14.
 *   [Bazel](https://bazel.build/), the preferred build system used by the
     GoogleTest team.
 
@@ -17,16 +17,15 @@ See [Supported Platforms](platforms.md) for more information about platforms
 compatible with GoogleTest.
 
 If you don't already have Bazel installed, see the
-[Bazel installation guide](https://docs.bazel.build/versions/master/install.html).
+[Bazel installation guide](https://bazel.build/install).
 
-{: .callout .note}
-Note: The terminal commands in this tutorial show a Unix shell prompt, but the
-commands work on the Windows command line as well.
+{: .callout .note} Note: The terminal commands in this tutorial show a Unix
+shell prompt, but the commands work on the Windows command line as well.
 
 ## Set up a Bazel workspace
 
 A
-[Bazel workspace](https://docs.bazel.build/versions/master/build-ref.html#workspace)
+[Bazel workspace](https://docs.bazel.build/versions/main/build-ref.html#workspace)
 is a directory on your filesystem that you use to manage source files for the
 software you want to build. Each workspace directory has a text file named
 `WORKSPACE` which may be empty, or may contain references to external
@@ -40,9 +39,9 @@ $ mkdir my_workspace && cd my_workspace
 
 Next, you’ll create the `WORKSPACE` file to specify dependencies. A common and
 recommended way to depend on GoogleTest is to use a
-[Bazel external dependency](https://docs.bazel.build/versions/master/external.html)
+[Bazel external dependency](https://docs.bazel.build/versions/main/external.html)
 via the
-[`http_archive` rule](https://docs.bazel.build/versions/master/repo/http.html#http_archive).
+[`http_archive` rule](https://docs.bazel.build/versions/main/repo/http.html#http_archive).
 To do this, in the root directory of your workspace (`my_workspace/`), create a
 file named `WORKSPACE` with the following contents:
 
@@ -51,28 +50,16 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
   name = "com_google_googletest",
-  urls = ["https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip"],
-  strip_prefix = "googletest-609281088cfefc76f9d0ce82e1ff6c30cc3591e5",
+  urls = ["https://github.com/google/googletest/archive/5ab508a01f9eb089207ee87fd547d290da39d015.zip"],
+  strip_prefix = "googletest-5ab508a01f9eb089207ee87fd547d290da39d015",
 )
 ```
 
 The above configuration declares a dependency on GoogleTest which is downloaded
 as a ZIP archive from GitHub. In the above example,
-`609281088cfefc76f9d0ce82e1ff6c30cc3591e5` is the Git commit hash of the
+`5ab508a01f9eb089207ee87fd547d290da39d015` is the Git commit hash of the
 GoogleTest version to use; we recommend updating the hash often to point to the
-latest version.
-
-Bazel also needs a dependency on the
-[`rules_cc` repository](https://github.com/bazelbuild/rules_cc) to build C++
-code, so add the following to the `WORKSPACE` file:
-
-```
-http_archive(
-  name = "rules_cc",
-  urls = ["https://github.com/bazelbuild/rules_cc/archive/40548a2974f1aea06215272d9c2b47a14a24e556.zip"],
-  strip_prefix = "rules_cc-40548a2974f1aea06215272d9c2b47a14a24e556",
-)
-```
+latest version. Use a recent hash on the `main` branch.
 
 Now you're ready to build C++ code that uses GoogleTest.
 
@@ -104,8 +91,6 @@ To build the code, create a file named `BUILD` in the same directory with the
 following contents:
 
 ```
-load("@rules_cc//cc:defs.bzl", "cc_test")
-
 cc_test(
   name = "hello_test",
   size = "small",
@@ -118,7 +103,7 @@ This `cc_test` rule declares the C++ test binary you want to build, and links to
 GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE`
 file (`@com_google_googletest`). For more information about Bazel `BUILD` files,
 see the
-[Bazel C++ Tutorial](https://docs.bazel.build/versions/master/tutorial/cpp.html).
+[Bazel C++ Tutorial](https://docs.bazel.build/versions/main/tutorial/cpp.html).
 
 Now you can build and run your test:
 
diff --git a/googletest/docs/quickstart-cmake.md b/googletest/docs/quickstart-cmake.md
index 420f1d3a3c245e978dbf4c56c56660b25c4b8137..5abe50441294bd3183c3d1d9f1934f7fea03f88f 100644
--- a/googletest/docs/quickstart-cmake.md
+++ b/googletest/docs/quickstart-cmake.md
@@ -10,7 +10,7 @@ this tutorial as a starting point. If your project uses Bazel, see the
 To complete this tutorial, you'll need:
 
 *   A compatible operating system (e.g. Linux, macOS, Windows).
-*   A compatible C++ compiler that supports at least C++11.
+*   A compatible C++ compiler that supports at least C++14.
 *   [CMake](https://cmake.org/) and a compatible build tool for building the
     project.
     *   Compatible build tools include
@@ -52,13 +52,13 @@ To do this, in your project directory (`my_project`), create a file named
 cmake_minimum_required(VERSION 3.14)
 project(my_project)
 
-# GoogleTest requires at least C++11
-set(CMAKE_CXX_STANDARD 11)
+# GoogleTest requires at least C++14
+set(CMAKE_CXX_STANDARD 14)
 
 include(FetchContent)
 FetchContent_Declare(
   googletest
-  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
+  URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
 )
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
@@ -66,7 +66,7 @@ FetchContent_MakeAvailable(googletest)
 ```
 
 The above configuration declares a dependency on GoogleTest which is downloaded
-from GitHub. In the above example, `609281088cfefc76f9d0ce82e1ff6c30cc3591e5` is
+from GitHub. In the above example, `03597a01ee50ed33e9dfd640b249b4be3799d395` is
 the Git commit hash of the GoogleTest version to use; we recommend updating the
 hash often to point to the latest version.
 
@@ -108,7 +108,7 @@ add_executable(
 )
 target_link_libraries(
   hello_test
-  gtest_main
+  GTest::gtest_main
 )
 
 include(GoogleTest)
diff --git a/googletest/docs/reference/actions.md b/googletest/docs/reference/actions.md
index 166d2a897a44465c75a2f3fb9ad34025c8fc98d1..ab81a129eff692d513b27c155abed96dd30f8db6 100644
--- a/googletest/docs/reference/actions.md
+++ b/googletest/docs/reference/actions.md
@@ -6,7 +6,7 @@ provided by GoogleTest. All actions are defined in the `::testing` namespace.
 
 ## Returning a Value
 
-|                                   |                                               |
+| Action                            | Description                                   |
 | :-------------------------------- | :-------------------------------------------- |
 | `Return()`                        | Return from a `void` mock function.           |
 | `Return(value)`                   | Return `value`. If the type of `value` is     different to the mock function's return type, `value` is converted to the latter type <i>at the time the expectation is set</i>, not when the action is executed. |
@@ -20,7 +20,7 @@ provided by GoogleTest. All actions are defined in the `::testing` namespace.
 
 ## Side Effects
 
-|                                    |                                         |
+| Action                             | Description                             |
 | :--------------------------------- | :-------------------------------------- |
 | `Assign(&variable, value)` | Assign `value` to variable. |
 | `DeleteArg<N>()` | Delete the `N`-th (0-based) argument, which must be a pointer. |
@@ -38,9 +38,9 @@ provided by GoogleTest. All actions are defined in the `::testing` namespace.
 In the following, by "callable" we mean a free function, `std::function`,
 functor, or lambda.
 
-|                                     |                                        |
+| Action                              | Description                            |
 | :---------------------------------- | :------------------------------------- |
-| `f` | Invoke f with the arguments passed to the mock function, where f is a callable. |
+| `f` | Invoke `f` with the arguments passed to the mock function, where `f` is a callable. |
 | `Invoke(f)` | Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor. |
 | `Invoke(object_pointer, &class::method)` | Invoke the method on the object with the arguments passed to the mock function. |
 | `InvokeWithoutArgs(f)` | Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments. |
@@ -86,7 +86,7 @@ value, and `foo` by reference.
 
 ## Default Action
 
-| Matcher       | Description                                            |
+| Action        | Description                                            |
 | :------------ | :----------------------------------------------------- |
 | `DoDefault()` | Do the default action (specified by `ON_CALL()` or the built-in one). |
 
@@ -96,7 +96,7 @@ composite action - trying to do so will result in a run-time error.
 
 ## Composite Actions
 
-|                                |                                             |
+| Action                         | Description                                 |
 | :----------------------------- | :------------------------------------------ |
 | `DoAll(a1, a2, ..., an)`       | Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void and will receive a  readonly view of the arguments. |
 | `IgnoreResult(a)`              | Perform action `a` and ignore its result. `a` must not return void. |
@@ -106,7 +106,7 @@ composite action - trying to do so will result in a run-time error.
 
 ## Defining Actions
 
-|                                    |                                         |
+| Macro                              | Description                             |
 | :--------------------------------- | :-------------------------------------- |
 | `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. |
 | `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. |
diff --git a/googletest/docs/reference/matchers.md b/googletest/docs/reference/matchers.md
index 9e40cab70454a68fa8a9d708b6fa2fe87e498a76..9fb159275131504ec920303268297a373502ab49 100644
--- a/googletest/docs/reference/matchers.md
+++ b/googletest/docs/reference/matchers.md
@@ -8,9 +8,13 @@ A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or
 | `EXPECT_THAT(actual_value, matcher)` | Asserts that `actual_value` matches `matcher`. |
 | `ASSERT_THAT(actual_value, matcher)` | The same as `EXPECT_THAT(actual_value, matcher)`, except that it generates a **fatal** failure. |
 
-{: .callout .note}
-**Note:** Although equality matching via `EXPECT_THAT(actual_value,
-expected_value)` is supported, prefer to make the comparison explicit via
+{: .callout .warning}
+**WARNING:** Equality matching via `EXPECT_THAT(actual_value, expected_value)`
+is supported, however note that implicit conversions can cause surprising
+results. For example, `EXPECT_THAT(some_bool, "some string")` will compile and
+may pass unintentionally.
+
+**BEST PRACTICE:** Prefer to make the comparison explicit via
 `EXPECT_THAT(actual_value, Eq(expected_value))` or `EXPECT_EQ(actual_value,
 expected_value)`.
 
@@ -88,16 +92,17 @@ The `argument` can be either a C string or a C++ string object:
 
 | Matcher                 | Description                                        |
 | :---------------------- | :------------------------------------------------- |
-| `ContainsRegex(string)` | `argument` matches the given regular expression.   |
-| `EndsWith(suffix)`      | `argument` ends with string `suffix`.              |
-| `HasSubstr(string)`     | `argument` contains `string` as a sub-string.      |
-| `IsEmpty()`             | `argument` is an empty string.                     |
-| `MatchesRegex(string)`  | `argument` matches the given regular expression with the match starting at the first character and ending at the last character. |
-| `StartsWith(prefix)`    | `argument` starts with string `prefix`.            |
-| `StrCaseEq(string)`     | `argument` is equal to `string`, ignoring case.    |
-| `StrCaseNe(string)`     | `argument` is not equal to `string`, ignoring case. |
-| `StrEq(string)`         | `argument` is equal to `string`.                   |
-| `StrNe(string)`         | `argument` is not equal to `string`.               |
+| `ContainsRegex(string)`  | `argument` matches the given regular expression.  |
+| `EndsWith(suffix)`       | `argument` ends with string `suffix`.             |
+| `HasSubstr(string)`      | `argument` contains `string` as a sub-string.     |
+| `IsEmpty()`              | `argument` is an empty string.                    |
+| `MatchesRegex(string)`   | `argument` matches the given regular expression with the match starting at the first character and ending at the last character. |
+| `StartsWith(prefix)`     | `argument` starts with string `prefix`.           |
+| `StrCaseEq(string)`      | `argument` is equal to `string`, ignoring case.   |
+| `StrCaseNe(string)`      | `argument` is not equal to `string`, ignoring case. |
+| `StrEq(string)`          | `argument` is equal to `string`.                  |
+| `StrNe(string)`          | `argument` is not equal to `string`.              |
+| `WhenBase64Unescaped(m)` | `argument` is a base-64 escaped string whose unescaped string matches `m`. |
 
 `ContainsRegex()` and `MatchesRegex()` take ownership of the `RE` object. They
 use the regular expression syntax defined
@@ -116,6 +121,7 @@ messages, you can use:
 | `BeginEndDistanceIs(m)` | `argument` is a container whose `begin()` and `end()` iterators are separated by a number of increments matching `m`. E.g. `BeginEndDistanceIs(2)` or `BeginEndDistanceIs(Lt(2))`. For containers that define a `size()` method, `SizeIs(m)` may be more efficient. |
 | `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. |
 | `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. |
+| `Contains(e).Times(n)` | `argument` contains elements that match `e`, which can be either a value or a matcher, and the number of matches is `n`, which can be either a value or a matcher. Unlike the plain `Contains` and `Each` this allows to check for arbitrary occurrences including testing for absence with `Contains(e).Times(0)`. |
 | `Each(e)` | `argument` is a container where *every* element matches `e`, which can be either a value or a matcher. |
 | `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the *i*-th element matches `ei`, which can be a value or a matcher. |
 | `ElementsAreArray({e0, e1, ..., en})`, `ElementsAreArray(a_container)`, `ElementsAreArray(begin, end)`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. |
@@ -146,7 +152,6 @@ messages, you can use:
     one might write:
 
     ```cpp
-    using ::std::get;
     MATCHER(FooEq, "") {
       return std::get<0>(arg).Equals(std::get<1>(arg));
     }
@@ -193,6 +198,7 @@ messages, you can use:
 | Matcher          | Description                                       |
 | :--------------- | :------------------------------------------------ |
 | `ResultOf(f, m)` | `f(argument)` matches matcher `m`, where `f` is a function or functor. |
+| `ResultOf(result_description, f, m)` | The same as the two-parameter version, but provides a better error message.
 
 ## Pointer Matchers
 
@@ -237,6 +243,7 @@ You can make a matcher from one or more other matchers:
 | `AnyOf(m1, m2, ..., mn)` | `argument` matches at least one of the matchers `m1` to `mn`. |
 | `AnyOfArray({m0, m1, ..., mn})`, `AnyOfArray(a_container)`, `AnyOfArray(begin, end)`, `AnyOfArray(array)`, or `AnyOfArray(array, count)` | The same as `AnyOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. |
 | `Not(m)` | `argument` doesn't match matcher `m`. |
+| `Conditional(cond, m1, m2)` | Matches matcher `m1` if `cond` evaluates to true, else matches `m2`.|
 
 ## Adapters for Matchers
 
@@ -259,7 +266,7 @@ which must be a permanent callback.
 
 ## Defining Matchers
 
-| Matcher                              | Description                           |
+| Macro                                | Description                           |
 | :----------------------------------- | :------------------------------------ |
 | `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
 | `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a matcher `IsDivisibleBy(n)` to match a number divisible by `n`. |
diff --git a/googletest/docs/reference/mocking.md b/googletest/docs/reference/mocking.md
index c29f71603f41367094f9e6c53db2485a9a8b5bd3..e414ffbd0dea39b9a97989f2939943a4a87362bd 100644
--- a/googletest/docs/reference/mocking.md
+++ b/googletest/docs/reference/mocking.md
@@ -248,7 +248,9 @@ EXPECT_CALL(my_mock, GetNumber())
     .WillOnce(Return(3));
 ```
 
-The `WillOnce` clause can be used any number of times on an expectation.
+The `WillOnce` clause can be used any number of times on an expectation. Unlike
+`WillRepeatedly`, the action fed to each `WillOnce` call will be called at most
+once, so may be a move-only type and/or have an `&&`-qualified call operator.
 
 #### WillRepeatedly {#EXPECT_CALL.WillRepeatedly}
 
diff --git a/googletest/docs/reference/testing.md b/googletest/docs/reference/testing.md
index 554d6c95840eee3f131d33ecd7eaa4f0e68dd03b..62cdcc1c6555542856533412608e2173e7ea9a0d 100644
--- a/googletest/docs/reference/testing.md
+++ b/googletest/docs/reference/testing.md
@@ -109,7 +109,7 @@ namespace:
 | `ValuesIn(container)` or `ValuesIn(begin,end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. |
 | `Bool()`                     | Yields sequence `{false, true}`.            |
 | `Combine(g1, g2, ..., gN)`   | Yields as `std::tuple` *n*-tuples all combinations (Cartesian product) of the values generated by the given *n* generators `g1`, `g2`, ..., `gN`. |
-
+| `ConvertGenerator<T>(g)`     | Yields values generated by generator `g`, `static_cast` to `T`. |
 The optional last argument *`name_generator`* is a function or functor that
 generates custom test name suffixes based on the test parameters. The function
 must accept an argument of type
@@ -518,8 +518,8 @@ Logs a property for the current test, test suite, or entire invocation of the
 test program. Only the last value for a given key is logged.
 
 The key must be a valid XML attribute name, and cannot conflict with the ones
-already used by GoogleTest (`name`, `status`, `time`, `classname`, `type_param`,
-and `value_param`).
+already used by GoogleTest (`name`, `file`, `line`, `status`, `time`,
+`classname`, `type_param`, and `value_param`).
 
 `RecordProperty` is `public static` so it can be called from utility functions
 that are not members of the test fixture.
diff --git a/googletest/docs/samples.md b/googletest/docs/samples.md
index 2d97ca55b2c36b42bd8fb6d14d344fa66e82d6e5..dedc59098df5ae6a318bae5992694dc11b6daf62 100644
--- a/googletest/docs/samples.md
+++ b/googletest/docs/samples.md
@@ -1,7 +1,7 @@
 # Googletest Samples
 
 If you're like us, you'd like to look at
-[googletest samples.](https://github.com/google/googletest/tree/master/googletest/samples)
+[googletest samples.](https://github.com/google/googletest/blob/main/googletest/samples)
 The sample directory has a number of well-commented samples showing how to use a
 variety of googletest features.
 
diff --git a/googletest/googlemock/CMakeLists.txt b/googletest/googlemock/CMakeLists.txt
index aedbaa382746cb27e46d353e950e82d6c926b464..5c1f0dafea8bfa9d6e3af07508437b29f4e7489f 100644
--- a/googletest/googlemock/CMakeLists.txt
+++ b/googletest/googlemock/CMakeLists.txt
@@ -94,7 +94,6 @@ if (MSVC)
               src/gmock-all.cc
               src/gmock_main.cc)
 else()
-
   cxx_library(gmock "${cxx_strict}" src/gmock-all.cc)
   target_link_libraries(gmock PUBLIC gtest)
   set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION})
@@ -106,11 +105,12 @@ endif()
 # to the targets for when we are part of a parent build (ie being pulled
 # in via add_subdirectory() rather than being a standalone build).
 if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  string(REPLACE ";" "$<SEMICOLON>" dirs "${gmock_build_include_dirs}")
   target_include_directories(gmock SYSTEM INTERFACE
-    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    "$<BUILD_INTERFACE:${dirs}>"
     "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
   target_include_directories(gmock_main SYSTEM INTERFACE
-    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    "$<BUILD_INTERFACE:${dirs}>"
     "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
 endif()
 
@@ -151,7 +151,10 @@ if (gmock_build_tests)
   cxx_test(gmock_ex_test gmock_main)
   cxx_test(gmock-function-mocker_test gmock_main)
   cxx_test(gmock-internal-utils_test gmock_main)
-  cxx_test(gmock-matchers_test gmock_main)
+  cxx_test(gmock-matchers-arithmetic_test gmock_main)
+  cxx_test(gmock-matchers-comparisons_test gmock_main)
+  cxx_test(gmock-matchers-containers_test gmock_main)
+  cxx_test(gmock-matchers-misc_test gmock_main)
   cxx_test(gmock-more-actions_test gmock_main)
   cxx_test(gmock-nice-strict_test gmock_main)
   cxx_test(gmock-port_test gmock_main)
diff --git a/googletest/googlemock/README.md b/googletest/googlemock/README.md
index ead688325d2c603575148543bd0f1b136412c207..7da60655dba8b8e91ec66a9a65f97139af03ee9b 100644
--- a/googletest/googlemock/README.md
+++ b/googletest/googlemock/README.md
@@ -35,10 +35,6 @@ Details and examples can be found here:
 *   [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html)
 *   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html)
 
-Please note that code under scripts/generator/ is from the
-[cppclean project](http://code.google.com/p/cppclean/) and under the Apache
-License, which is different from GoogleMock's license.
-
 GoogleMock is a part of
 [GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
 subject to the same requirements.
diff --git a/googletest/googlemock/include/gmock/gmock-actions.h b/googletest/googlemock/include/gmock/gmock-actions.h
index f2393bd3afadaba8506261b18a32040395a28267..aad07d51cc1a26f0b55d12633c374b45b2eff49d 100644
--- a/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/googletest/googlemock/include/gmock/gmock-actions.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // The ACTION* family of macros can be used in a namespace scope to
@@ -123,15 +122,16 @@
 // MORE INFORMATION:
 //
 // To learn more about using these macros, please search for 'ACTION' on
-// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+// https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
 
 #ifndef _WIN32_WCE
-# include <errno.h>
+#include <errno.h>
 #endif
 
 #include <algorithm>
@@ -147,8 +147,8 @@
 #include "gmock/internal/gmock-pp.h"
 
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #endif
 
 namespace testing {
@@ -196,9 +196,7 @@ class BuiltInDefaultValue {
  public:
   // This function returns true if and only if type T has a built-in default
   // value.
-  static bool Exists() {
-    return ::std::is_default_constructible<T>::value;
-  }
+  static bool Exists() { return ::std::is_default_constructible<T>::value; }
 
   static T Get() {
     return BuiltInDefaultValueGetter<
@@ -227,11 +225,11 @@ class BuiltInDefaultValue<T*> {
 // The following specializations define the default values for
 // specific types we care about.
 #define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
-  template <> \
-  class BuiltInDefaultValue<type> { \
-   public: \
-    static bool Exists() { return true; } \
-    static type Get() { return value; } \
+  template <>                                                     \
+  class BuiltInDefaultValue<type> {                               \
+   public:                                                        \
+    static bool Exists() { return true; }                         \
+    static type Get() { return value; }                           \
   }
 
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
@@ -255,21 +253,309 @@ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);        // NOLINT
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);    // NOLINT
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
 
 #undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
 
-// Simple two-arg form of std::disjunction.
-template <typename P, typename Q>
-using disjunction = typename ::std::conditional<P::value, P, Q>::type;
+// Partial implementations of metaprogramming types from the standard library
+// not available in C++11.
+
+template <typename P>
+struct negation
+    // NOLINTNEXTLINE
+    : std::integral_constant<bool, bool(!P::value)> {};
+
+// Base case: with zero predicates the answer is always true.
+template <typename...>
+struct conjunction : std::true_type {};
+
+// With a single predicate, the answer is that predicate.
+template <typename P1>
+struct conjunction<P1> : P1 {};
+
+// With multiple predicates the answer is the first predicate if that is false,
+// and we recurse otherwise.
+template <typename P1, typename... Ps>
+struct conjunction<P1, Ps...>
+    : std::conditional<bool(P1::value), conjunction<Ps...>, P1>::type {};
+
+template <typename...>
+struct disjunction : std::false_type {};
+
+template <typename P1>
+struct disjunction<P1> : P1 {};
+
+template <typename P1, typename... Ps>
+struct disjunction<P1, Ps...>
+    // NOLINTNEXTLINE
+    : std::conditional<!bool(P1::value), disjunction<Ps...>, P1>::type {};
+
+template <typename...>
+using void_t = void;
+
+// Detects whether an expression of type `From` can be implicitly converted to
+// `To` according to [conv]. In C++17, [conv]/3 defines this as follows:
+//
+//     An expression e can be implicitly converted to a type T if and only if
+//     the declaration T t=e; is well-formed, for some invented temporary
+//     variable t ([dcl.init]).
+//
+// [conv]/2 implies we can use function argument passing to detect whether this
+// initialization is valid.
+//
+// Note that this is distinct from is_convertible, which requires this be valid:
+//
+//     To test() {
+//       return declval<From>();
+//     }
+//
+// In particular, is_convertible doesn't give the correct answer when `To` and
+// `From` are the same non-moveable type since `declval<From>` will be an rvalue
+// reference, defeating the guaranteed copy elision that would otherwise make
+// this function work.
+//
+// REQUIRES: `From` is not cv void.
+template <typename From, typename To>
+struct is_implicitly_convertible {
+ private:
+  // A function that accepts a parameter of type T. This can be called with type
+  // U successfully only if U is implicitly convertible to T.
+  template <typename T>
+  static void Accept(T);
+
+  // A function that creates a value of type T.
+  template <typename T>
+  static T Make();
+
+  // An overload be selected when implicit conversion from T to To is possible.
+  template <typename T, typename = decltype(Accept<To>(Make<T>()))>
+  static std::true_type TestImplicitConversion(int);
+
+  // A fallback overload selected in all other cases.
+  template <typename T>
+  static std::false_type TestImplicitConversion(...);
+
+ public:
+  using type = decltype(TestImplicitConversion<From>(0));
+  static constexpr bool value = type::value;
+};
+
+// Like std::invoke_result_t from C++17, but works only for objects with call
+// operators (not e.g. member function pointers, which we don't need specific
+// support for in OnceAction because std::function deals with them).
+template <typename F, typename... Args>
+using call_result_t = decltype(std::declval<F>()(std::declval<Args>()...));
+
+template <typename Void, typename R, typename F, typename... Args>
+struct is_callable_r_impl : std::false_type {};
+
+// Specialize the struct for those template arguments where call_result_t is
+// well-formed. When it's not, the generic template above is chosen, resulting
+// in std::false_type.
+template <typename R, typename F, typename... Args>
+struct is_callable_r_impl<void_t<call_result_t<F, Args...>>, R, F, Args...>
+    : std::conditional<
+          std::is_void<R>::value,  //
+          std::true_type,          //
+          is_implicitly_convertible<call_result_t<F, Args...>, R>>::type {};
+
+// Like std::is_invocable_r from C++17, but works only for objects with call
+// operators. See the note on call_result_t.
+template <typename R, typename F, typename... Args>
+using is_callable_r = is_callable_r_impl<void, R, F, Args...>;
+
+// Like std::as_const from C++17.
+template <typename T>
+typename std::add_const<T>::type& as_const(T& t) {
+  return t;
+}
 
 }  // namespace internal
 
+// Specialized for function types below.
+template <typename F>
+class OnceAction;
+
+// An action that can only be used once.
+//
+// This is accepted by WillOnce, which doesn't require the underlying action to
+// be copy-constructible (only move-constructible), and promises to invoke it as
+// an rvalue reference. This allows the action to work with move-only types like
+// std::move_only_function in a type-safe manner.
+//
+// For example:
+//
+//     // Assume we have some API that needs to accept a unique pointer to some
+//     // non-copyable object Foo.
+//     void AcceptUniquePointer(std::unique_ptr<Foo> foo);
+//
+//     // We can define an action that provides a Foo to that API. Because It
+//     // has to give away its unique pointer, it must not be called more than
+//     // once, so its call operator is &&-qualified.
+//     struct ProvideFoo {
+//       std::unique_ptr<Foo> foo;
+//
+//       void operator()() && {
+//         AcceptUniquePointer(std::move(Foo));
+//       }
+//     };
+//
+//     // This action can be used with WillOnce.
+//     EXPECT_CALL(mock, Call)
+//         .WillOnce(ProvideFoo{std::make_unique<Foo>(...)});
+//
+//     // But a call to WillRepeatedly will fail to compile. This is correct,
+//     // since the action cannot correctly be used repeatedly.
+//     EXPECT_CALL(mock, Call)
+//         .WillRepeatedly(ProvideFoo{std::make_unique<Foo>(...)});
+//
+// A less-contrived example would be an action that returns an arbitrary type,
+// whose &&-qualified call operator is capable of dealing with move-only types.
+template <typename Result, typename... Args>
+class OnceAction<Result(Args...)> final {
+ private:
+  // True iff we can use the given callable type (or lvalue reference) directly
+  // via StdFunctionAdaptor.
+  template <typename Callable>
+  using IsDirectlyCompatible = internal::conjunction<
+      // It must be possible to capture the callable in StdFunctionAdaptor.
+      std::is_constructible<typename std::decay<Callable>::type, Callable>,
+      // The callable must be compatible with our signature.
+      internal::is_callable_r<Result, typename std::decay<Callable>::type,
+                              Args...>>;
+
+  // True iff we can use the given callable type via StdFunctionAdaptor once we
+  // ignore incoming arguments.
+  template <typename Callable>
+  using IsCompatibleAfterIgnoringArguments = internal::conjunction<
+      // It must be possible to capture the callable in a lambda.
+      std::is_constructible<typename std::decay<Callable>::type, Callable>,
+      // The callable must be invocable with zero arguments, returning something
+      // convertible to Result.
+      internal::is_callable_r<Result, typename std::decay<Callable>::type>>;
+
+ public:
+  // Construct from a callable that is directly compatible with our mocked
+  // signature: it accepts our function type's arguments and returns something
+  // convertible to our result type.
+  template <typename Callable,
+            typename std::enable_if<
+                internal::conjunction<
+                    // Teach clang on macOS that we're not talking about a
+                    // copy/move constructor here. Otherwise it gets confused
+                    // when checking the is_constructible requirement of our
+                    // traits above.
+                    internal::negation<std::is_same<
+                        OnceAction, typename std::decay<Callable>::type>>,
+                    IsDirectlyCompatible<Callable>>  //
+                ::value,
+                int>::type = 0>
+  OnceAction(Callable&& callable)  // NOLINT
+      : function_(StdFunctionAdaptor<typename std::decay<Callable>::type>(
+            {}, std::forward<Callable>(callable))) {}
+
+  // As above, but for a callable that ignores the mocked function's arguments.
+  template <typename Callable,
+            typename std::enable_if<
+                internal::conjunction<
+                    // Teach clang on macOS that we're not talking about a
+                    // copy/move constructor here. Otherwise it gets confused
+                    // when checking the is_constructible requirement of our
+                    // traits above.
+                    internal::negation<std::is_same<
+                        OnceAction, typename std::decay<Callable>::type>>,
+                    // Exclude callables for which the overload above works.
+                    // We'd rather provide the arguments if possible.
+                    internal::negation<IsDirectlyCompatible<Callable>>,
+                    IsCompatibleAfterIgnoringArguments<Callable>>::value,
+                int>::type = 0>
+  OnceAction(Callable&& callable)  // NOLINT
+                                   // Call the constructor above with a callable
+                                   // that ignores the input arguments.
+      : OnceAction(IgnoreIncomingArguments<typename std::decay<Callable>::type>{
+            std::forward<Callable>(callable)}) {}
+
+  // We are naturally copyable because we store only an std::function, but
+  // semantically we should not be copyable.
+  OnceAction(const OnceAction&) = delete;
+  OnceAction& operator=(const OnceAction&) = delete;
+  OnceAction(OnceAction&&) = default;
+
+  // Invoke the underlying action callable with which we were constructed,
+  // handing it the supplied arguments.
+  Result Call(Args... args) && {
+    return function_(std::forward<Args>(args)...);
+  }
+
+ private:
+  // An adaptor that wraps a callable that is compatible with our signature and
+  // being invoked as an rvalue reference so that it can be used as an
+  // StdFunctionAdaptor. This throws away type safety, but that's fine because
+  // this is only used by WillOnce, which we know calls at most once.
+  //
+  // Once we have something like std::move_only_function from C++23, we can do
+  // away with this.
+  template <typename Callable>
+  class StdFunctionAdaptor final {
+   public:
+    // A tag indicating that the (otherwise universal) constructor is accepting
+    // the callable itself, instead of e.g. stealing calls for the move
+    // constructor.
+    struct CallableTag final {};
+
+    template <typename F>
+    explicit StdFunctionAdaptor(CallableTag, F&& callable)
+        : callable_(std::make_shared<Callable>(std::forward<F>(callable))) {}
+
+    // Rather than explicitly returning Result, we return whatever the wrapped
+    // callable returns. This allows for compatibility with existing uses like
+    // the following, when the mocked function returns void:
+    //
+    //     EXPECT_CALL(mock_fn_, Call)
+    //         .WillOnce([&] {
+    //            [...]
+    //            return 0;
+    //         });
+    //
+    // Such a callable can be turned into std::function<void()>. If we use an
+    // explicit return type of Result here then it *doesn't* work with
+    // std::function, because we'll get a "void function should not return a
+    // value" error.
+    //
+    // We need not worry about incompatible result types because the SFINAE on
+    // OnceAction already checks this for us. std::is_invocable_r_v itself makes
+    // the same allowance for void result types.
+    template <typename... ArgRefs>
+    internal::call_result_t<Callable, ArgRefs...> operator()(
+        ArgRefs&&... args) const {
+      return std::move(*callable_)(std::forward<ArgRefs>(args)...);
+    }
+
+   private:
+    // We must put the callable on the heap so that we are copyable, which
+    // std::function needs.
+    std::shared_ptr<Callable> callable_;
+  };
+
+  // An adaptor that makes a callable that accepts zero arguments callable with
+  // our mocked arguments.
+  template <typename Callable>
+  struct IgnoreIncomingArguments {
+    internal::call_result_t<Callable> operator()(Args&&...) {
+      return std::move(callable)();
+    }
+
+    Callable callable;
+  };
+
+  std::function<Result(Args...)> function_;
+};
+
 // When an unexpected function call is encountered, Google Mock will
 // let it return a default value if the user has specified one for its
 // return type, or if the return type has a built-in default value;
@@ -339,7 +625,8 @@ class DefaultValue {
 
    private:
     const T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+    FixedValueProducer(const FixedValueProducer&) = delete;
+    FixedValueProducer& operator=(const FixedValueProducer&) = delete;
   };
 
   class FactoryValueProducer : public ValueProducer {
@@ -350,7 +637,8 @@ class DefaultValue {
 
    private:
     const FactoryFunction factory_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+    FactoryValueProducer(const FactoryValueProducer&) = delete;
+    FactoryValueProducer& operator=(const FactoryValueProducer&) = delete;
   };
 
   static ValueProducer* producer_;
@@ -424,28 +712,34 @@ class ActionInterface {
   virtual Result Perform(const ArgumentTuple& args) = 0;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+  ActionInterface(const ActionInterface&) = delete;
+  ActionInterface& operator=(const ActionInterface&) = delete;
 };
 
-// An Action<F> is a copyable and IMMUTABLE (except by assignment)
-// object that represents an action to be taken when a mock function
-// of type F is called.  The implementation of Action<T> is just a
-// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
-// You can view an object implementing ActionInterface<F> as a
-// concrete action (including its current state), and an Action<F>
-// object as a handle to it.
 template <typename F>
-class Action {
+class Action;
+
+// An Action<R(Args...)> is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function of type
+// R(Args...) is called. The implementation of Action<T> is just a
+// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action! You
+// can view an object implementing ActionInterface<F> as a concrete action
+// (including its current state), and an Action<F> object as a handle to it.
+template <typename R, typename... Args>
+class Action<R(Args...)> {
+ private:
+  using F = R(Args...);
+
   // Adapter class to allow constructing Action from a legacy ActionInterface.
   // New code should create Actions from functors instead.
   struct ActionAdapter {
     // Adapter must be copyable to satisfy std::function requirements.
     ::std::shared_ptr<ActionInterface<F>> impl_;
 
-    template <typename... Args>
-    typename internal::Function<F>::Result operator()(Args&&... args) {
+    template <typename... InArgs>
+    typename internal::Function<F>::Result operator()(InArgs&&... args) {
       return impl_->Perform(
-          ::std::forward_as_tuple(::std::forward<Args>(args)...));
+          ::std::forward_as_tuple(::std::forward<InArgs>(args)...));
     }
   };
 
@@ -480,7 +774,8 @@ class Action {
   // Action<F>, as long as F's arguments can be implicitly converted
   // to Func's and Func's return type can be implicitly converted to F's.
   template <typename Func>
-  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
+  Action(const Action<Func>& action)  // NOLINT
+      : fun_(action.fun_) {}
 
   // Returns true if and only if this is the DoDefault() action.
   bool IsDoDefault() const { return fun_ == nullptr; }
@@ -498,6 +793,24 @@ class Action {
     return internal::Apply(fun_, ::std::move(args));
   }
 
+  // An action can be used as a OnceAction, since it's obviously safe to call it
+  // once.
+  operator OnceAction<F>() const {  // NOLINT
+    // Return a OnceAction-compatible callable that calls Perform with the
+    // arguments it is provided. We could instead just return fun_, but then
+    // we'd need to handle the IsDoDefault() case separately.
+    struct OA {
+      Action<F> action;
+
+      R operator()(Args... args) && {
+        return action.Perform(
+            std::forward_as_tuple(std::forward<Args>(args)...));
+      }
+    };
+
+    return OA{*this};
+  }
+
  private:
   template <typename G>
   friend class Action;
@@ -514,8 +827,8 @@ class Action {
 
   template <typename FunctionImpl>
   struct IgnoreArgs {
-    template <typename... Args>
-    Result operator()(const Args&...) const {
+    template <typename... InArgs>
+    Result operator()(const InArgs&...) const {
       return function_impl();
     }
 
@@ -606,118 +919,198 @@ struct ByMoveWrapper {
   T payload;
 };
 
-// Implements the polymorphic Return(x) action, which can be used in
-// any function that returns the type of x, regardless of the argument
-// types.
-//
-// Note: The value passed into Return must be converted into
-// Function<F>::Result when this action is cast to Action<F> rather than
-// when that action is performed. This is important in scenarios like
-//
-// MOCK_METHOD1(Method, T(U));
-// ...
-// {
-//   Foo foo;
-//   X x(&foo);
-//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
-// }
-//
-// In the example above the variable x holds reference to foo which leaves
-// scope and gets destroyed.  If copying X just copies a reference to foo,
-// that copy will be left with a hanging reference.  If conversion to T
-// makes a copy of foo, the above code is safe. To support that scenario, we
-// need to make sure that the type conversion happens inside the EXPECT_CALL
-// statement, and conversion of the result of Return to Action<T(U)> is a
-// good place for that.
-//
-// The real life example of the above scenario happens when an invocation
-// of gtl::Container() is passed into Return.
-//
+// The general implementation of Return(R). Specializations follow below.
 template <typename R>
-class ReturnAction {
+class ReturnAction final {
  public:
-  // Constructs a ReturnAction object from the value to be returned.
-  // 'value' is passed by value instead of by const reference in order
-  // to allow Return("string literal") to compile.
-  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
+  explicit ReturnAction(R value) : value_(std::move(value)) {}
+
+  template <typename U, typename... Args,
+            typename = typename std::enable_if<conjunction<
+                // See the requirements documented on Return.
+                negation<std::is_same<void, U>>,  //
+                negation<std::is_reference<U>>,   //
+                std::is_convertible<R, U>,        //
+                std::is_move_constructible<U>>::value>::type>
+  operator OnceAction<U(Args...)>() && {  // NOLINT
+    return Impl<U>(std::move(value_));
+  }
 
-  // This template type conversion operator allows Return(x) to be
-  // used in ANY function that returns x's type.
-  template <typename F>
-  operator Action<F>() const {  // NOLINT
-    // Assert statement belongs here because this is the best place to verify
-    // conditions on F. It produces the clearest error messages
-    // in most compilers.
-    // Impl really belongs in this scope as a local class but can't
-    // because MSVC produces duplicate symbols in different translation units
-    // in this case. Until MS fixes that bug we put Impl into the class scope
-    // and put the typedef both here (for use in assert statement) and
-    // in the Impl class. But both definitions must be the same.
-    typedef typename Function<F>::Result Result;
-    GTEST_COMPILE_ASSERT_(
-        !std::is_reference<Result>::value,
-        use_ReturnRef_instead_of_Return_to_return_a_reference);
-    static_assert(!std::is_void<Result>::value,
-                  "Can't use Return() on an action expected to return `void`.");
-    return Action<F>(new Impl<R, F>(value_));
+  template <typename U, typename... Args,
+            typename = typename std::enable_if<conjunction<
+                // See the requirements documented on Return.
+                negation<std::is_same<void, U>>,   //
+                negation<std::is_reference<U>>,    //
+                std::is_convertible<const R&, U>,  //
+                std::is_copy_constructible<U>>::value>::type>
+  operator Action<U(Args...)>() const {  // NOLINT
+    return Impl<U>(value_);
   }
 
  private:
-  // Implements the Return(x) action for a particular function type F.
-  template <typename R_, typename F>
-  class Impl : public ActionInterface<F> {
+  // Implements the Return(x) action for a mock function that returns type U.
+  template <typename U>
+  class Impl final {
    public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+    // The constructor used when the return value is allowed to move from the
+    // input value (i.e. we are converting to OnceAction).
+    explicit Impl(R&& input_value)
+        : state_(new State(std::move(input_value))) {}
 
-    // The implicit cast is necessary when Result has more than one
-    // single-argument constructor (e.g. Result is std::vector<int>) and R
-    // has a type conversion operator template.  In that case, value_(value)
-    // won't compile as the compiler doesn't known which constructor of
-    // Result to call.  ImplicitCast_ forces the compiler to convert R to
-    // Result without considering explicit constructors, thus resolving the
-    // ambiguity. value_ is then initialized using its copy constructor.
-    explicit Impl(const std::shared_ptr<R>& value)
-        : value_before_cast_(*value),
-          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+    // The constructor used when the return value is not allowed to move from
+    // the input value (i.e. we are converting to Action).
+    explicit Impl(const R& input_value) : state_(new State(input_value)) {}
 
-    Result Perform(const ArgumentTuple&) override { return value_; }
+    U operator()() && { return std::move(state_->value); }
+    U operator()() const& { return state_->value; }
 
    private:
-    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
-                          Result_cannot_be_a_reference_type);
-    // We save the value before casting just in case it is being cast to a
-    // wrapper type.
-    R value_before_cast_;
-    Result value_;
-
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+    // We put our state on the heap so that the compiler-generated copy/move
+    // constructors work correctly even when U is a reference-like type. This is
+    // necessary only because we eagerly create State::value (see the note on
+    // that symbol for details). If we instead had only the input value as a
+    // member then the default constructors would work fine.
+    //
+    // For example, when R is std::string and U is std::string_view, value is a
+    // reference to the string backed by input_value. The copy constructor would
+    // copy both, so that we wind up with a new input_value object (with the
+    // same contents) and a reference to the *old* input_value object rather
+    // than the new one.
+    struct State {
+      explicit State(const R& input_value_in)
+          : input_value(input_value_in),
+            // Make an implicit conversion to Result before initializing the U
+            // object we store, avoiding calling any explicit constructor of U
+            // from R.
+            //
+            // This simulates the language rules: a function with return type U
+            // that does `return R()` requires R to be implicitly convertible to
+            // U, and uses that path for the conversion, even U Result has an
+            // explicit constructor from R.
+            value(ImplicitCast_<U>(internal::as_const(input_value))) {}
+
+      // As above, but for the case where we're moving from the ReturnAction
+      // object because it's being used as a OnceAction.
+      explicit State(R&& input_value_in)
+          : input_value(std::move(input_value_in)),
+            // For the same reason as above we make an implicit conversion to U
+            // before initializing the value.
+            //
+            // Unlike above we provide the input value as an rvalue to the
+            // implicit conversion because this is a OnceAction: it's fine if it
+            // wants to consume the input value.
+            value(ImplicitCast_<U>(std::move(input_value))) {}
+
+      // A copy of the value originally provided by the user. We retain this in
+      // addition to the value of the mock function's result type below in case
+      // the latter is a reference-like type. See the std::string_view example
+      // in the documentation on Return.
+      R input_value;
+
+      // The value we actually return, as the type returned by the mock function
+      // itself.
+      //
+      // We eagerly initialize this here, rather than lazily doing the implicit
+      // conversion automatically each time Perform is called, for historical
+      // reasons: in 2009-11, commit a070cbd91c (Google changelist 13540126)
+      // made the Action<U()> conversion operator eagerly convert the R value to
+      // U, but without keeping the R alive. This broke the use case discussed
+      // in the documentation for Return, making reference-like types such as
+      // std::string_view not safe to use as U where the input type R is a
+      // value-like type such as std::string.
+      //
+      // The example the commit gave was not very clear, nor was the issue
+      // thread (https://github.com/google/googlemock/issues/86), but it seems
+      // the worry was about reference-like input types R that flatten to a
+      // value-like type U when being implicitly converted. An example of this
+      // is std::vector<bool>::reference, which is often a proxy type with an
+      // reference to the underlying vector:
+      //
+      //     // Helper method: have the mock function return bools according
+      //     // to the supplied script.
+      //     void SetActions(MockFunction<bool(size_t)>& mock,
+      //                     const std::vector<bool>& script) {
+      //       for (size_t i = 0; i < script.size(); ++i) {
+      //         EXPECT_CALL(mock, Call(i)).WillOnce(Return(script[i]));
+      //       }
+      //     }
+      //
+      //     TEST(Foo, Bar) {
+      //       // Set actions using a temporary vector, whose operator[]
+      //       // returns proxy objects that references that will be
+      //       // dangling once the call to SetActions finishes and the
+      //       // vector is destroyed.
+      //       MockFunction<bool(size_t)> mock;
+      //       SetActions(mock, {false, true});
+      //
+      //       EXPECT_FALSE(mock.AsStdFunction()(0));
+      //       EXPECT_TRUE(mock.AsStdFunction()(1));
+      //     }
+      //
+      // This eager conversion helps with a simple case like this, but doesn't
+      // fully make these types work in general. For example the following still
+      // uses a dangling reference:
+      //
+      //     TEST(Foo, Baz) {
+      //       MockFunction<std::vector<std::string>()> mock;
+      //
+      //       // Return the same vector twice, and then the empty vector
+      //       // thereafter.
+      //       auto action = Return(std::initializer_list<std::string>{
+      //           "taco", "burrito",
+      //       });
+      //
+      //       EXPECT_CALL(mock, Call)
+      //           .WillOnce(action)
+      //           .WillOnce(action)
+      //           .WillRepeatedly(Return(std::vector<std::string>{}));
+      //
+      //       EXPECT_THAT(mock.AsStdFunction()(),
+      //                   ElementsAre("taco", "burrito"));
+      //       EXPECT_THAT(mock.AsStdFunction()(),
+      //                   ElementsAre("taco", "burrito"));
+      //       EXPECT_THAT(mock.AsStdFunction()(), IsEmpty());
+      //     }
+      //
+      U value;
+    };
+
+    const std::shared_ptr<State> state_;
   };
 
-  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
-  // move its contents instead.
-  template <typename R_, typename F>
-  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
-   public:
-    typedef typename Function<F>::Result Result;
-    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  R value_;
+};
+
+// A specialization of ReturnAction<R> when R is ByMoveWrapper<T> for some T.
+//
+// This version applies the type system-defeating hack of moving from T even in
+// the const call operator, checking at runtime that it isn't called more than
+// once, since the user has declared their intent to do so by using ByMove.
+template <typename T>
+class ReturnAction<ByMoveWrapper<T>> final {
+ public:
+  explicit ReturnAction(ByMoveWrapper<T> wrapper)
+      : state_(new State(std::move(wrapper.payload))) {}
 
-    explicit Impl(const std::shared_ptr<R>& wrapper)
-        : performed_(false), wrapper_(wrapper) {}
+  T operator()() const {
+    GTEST_CHECK_(!state_->called)
+        << "A ByMove() action must be performed at most once.";
 
-    Result Perform(const ArgumentTuple&) override {
-      GTEST_CHECK_(!performed_)
-          << "A ByMove() action should only be performed once.";
-      performed_ = true;
-      return std::move(wrapper_->payload);
-    }
+    state_->called = true;
+    return std::move(state_->value);
+  }
 
-   private:
-    bool performed_;
-    const std::shared_ptr<R> wrapper_;
+ private:
+  // We store our state on the heap so that we are copyable as required by
+  // Action, despite the fact that we are stateful and T may not be copyable.
+  struct State {
+    explicit State(T&& value_in) : value(std::move(value_in)) {}
+
+    T value;
+    bool called = false;
   };
 
-  const std::shared_ptr<R> value_;
+  const std::shared_ptr<State> state_;
 };
 
 // Implements the ReturnNull() action.
@@ -759,8 +1152,8 @@ class ReturnRefAction {
     // Asserts that the function return type is a reference.  This
     // catches the user error of using ReturnRef(x) when Return(x)
     // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
-                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    static_assert(std::is_reference<Result>::value,
+                  "use Return instead of ReturnRef to return a value");
     return Action<F>(new Impl<F>(ref_));
   }
 
@@ -801,9 +1194,8 @@ class ReturnRefOfCopyAction {
     // Asserts that the function return type is a reference.  This
     // catches the user error of using ReturnRefOfCopy(x) when Return(x)
     // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(
-        std::is_reference<Result>::value,
-        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    static_assert(std::is_reference<Result>::value,
+                  "use Return instead of ReturnRefOfCopy to return a value");
     return Action<F>(new Impl<F>(value_));
   }
 
@@ -839,7 +1231,7 @@ class ReturnRoundRobinAction {
 
   template <typename... Args>
   T operator()(Args&&...) const {
-     return state_->Next();
+    return state_->Next();
   }
 
  private:
@@ -862,7 +1254,9 @@ class DoDefaultAction {
   // This template type conversion operator allows DoDefault() to be
   // used in any function.
   template <typename F>
-  operator Action<F>() const { return Action<F>(); }  // NOLINT
+  operator Action<F>() const {
+    return Action<F>();
+  }  // NOLINT
 };
 
 // Implements the Assign action to set a given pointer referent to a
@@ -890,8 +1284,7 @@ template <typename T>
 class SetErrnoAndReturnAction {
  public:
   SetErrnoAndReturnAction(int errno_value, T result)
-      : errno_(errno_value),
-        result_(result) {}
+      : errno_(errno_value), result_(result) {}
   template <typename Result, typename ArgumentTuple>
   Result Perform(const ArgumentTuple& /* args */) const {
     errno = errno_;
@@ -1002,8 +1395,8 @@ class IgnoreResultAction {
    private:
     // Type OriginalFunction is the same as F except that its return
     // type is IgnoredValue.
-    typedef typename internal::Function<F>::MakeResultIgnoredValue
-        OriginalFunction;
+    typedef
+        typename internal::Function<F>::MakeResultIgnoredValue OriginalFunction;
 
     const Action<OriginalFunction> action_;
   };
@@ -1013,55 +1406,243 @@ class IgnoreResultAction {
 
 template <typename InnerAction, size_t... I>
 struct WithArgsAction {
-  InnerAction action;
+  InnerAction inner_action;
 
-  // The inner action could be anything convertible to Action<X>.
-  // We use the conversion operator to detect the signature of the inner Action.
+  // The signature of the function as seen by the inner action, given an out
+  // action with the given result and argument types.
   template <typename R, typename... Args>
+  using InnerSignature =
+      R(typename std::tuple_element<I, std::tuple<Args...>>::type...);
+
+  // Rather than a call operator, we must define conversion operators to
+  // particular action types. This is necessary for embedded actions like
+  // DoDefault(), which rely on an action conversion operators rather than
+  // providing a call operator because even with a particular set of arguments
+  // they don't have a fixed return type.
+
+  template <typename R, typename... Args,
+            typename std::enable_if<
+                std::is_convertible<
+                    InnerAction,
+                    // Unfortunately we can't use the InnerSignature alias here;
+                    // MSVC complains about the I parameter pack not being
+                    // expanded (error C3520) despite it being expanded in the
+                    // type alias.
+                    // TupleElement is also an MSVC workaround.
+                    // See its definition for details.
+                    OnceAction<R(internal::TupleElement<
+                                 I, std::tuple<Args...>>...)>>::value,
+                int>::type = 0>
+  operator OnceAction<R(Args...)>() && {  // NOLINT
+    struct OA {
+      OnceAction<InnerSignature<R, Args...>> inner_action;
+
+      R operator()(Args&&... args) && {
+        return std::move(inner_action)
+            .Call(std::get<I>(
+                std::forward_as_tuple(std::forward<Args>(args)...))...);
+      }
+    };
+
+    return OA{std::move(inner_action)};
+  }
+
+  template <typename R, typename... Args,
+            typename std::enable_if<
+                std::is_convertible<
+                    const InnerAction&,
+                    // Unfortunately we can't use the InnerSignature alias here;
+                    // MSVC complains about the I parameter pack not being
+                    // expanded (error C3520) despite it being expanded in the
+                    // type alias.
+                    // TupleElement is also an MSVC workaround.
+                    // See its definition for details.
+                    Action<R(internal::TupleElement<
+                             I, std::tuple<Args...>>...)>>::value,
+                int>::type = 0>
   operator Action<R(Args...)>() const {  // NOLINT
-    using TupleType = std::tuple<Args...>;
-    Action<R(typename std::tuple_element<I, TupleType>::type...)>
-        converted(action);
+    Action<InnerSignature<R, Args...>> converted(inner_action);
 
-    return [converted](Args... args) -> R {
+    return [converted](Args&&... args) -> R {
       return converted.Perform(std::forward_as_tuple(
-        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
+          std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
     };
   }
 };
 
 template <typename... Actions>
-struct DoAllAction {
- private:
+class DoAllAction;
+
+// Base case: only a single action.
+template <typename FinalAction>
+class DoAllAction<FinalAction> {
+ public:
+  struct UserConstructorTag {};
+
   template <typename T>
-  using NonFinalType =
-      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
+  explicit DoAllAction(UserConstructorTag, T&& action)
+      : final_action_(std::forward<T>(action)) {}
+
+  // Rather than a call operator, we must define conversion operators to
+  // particular action types. This is necessary for embedded actions like
+  // DoDefault(), which rely on an action conversion operators rather than
+  // providing a call operator because even with a particular set of arguments
+  // they don't have a fixed return type.
+
+  template <typename R, typename... Args,
+            typename std::enable_if<
+                std::is_convertible<FinalAction, OnceAction<R(Args...)>>::value,
+                int>::type = 0>
+  operator OnceAction<R(Args...)>() && {  // NOLINT
+    return std::move(final_action_);
+  }
 
-  template <typename ActionT, size_t... I>
-  std::vector<ActionT> Convert(IndexSequence<I...>) const {
-    return {ActionT(std::get<I>(actions))...};
+  template <
+      typename R, typename... Args,
+      typename std::enable_if<
+          std::is_convertible<const FinalAction&, Action<R(Args...)>>::value,
+          int>::type = 0>
+  operator Action<R(Args...)>() const {  // NOLINT
+    return final_action_;
   }
 
+ private:
+  FinalAction final_action_;
+};
+
+// Recursive case: support N actions by calling the initial action and then
+// calling through to the base class containing N-1 actions.
+template <typename InitialAction, typename... OtherActions>
+class DoAllAction<InitialAction, OtherActions...>
+    : private DoAllAction<OtherActions...> {
+ private:
+  using Base = DoAllAction<OtherActions...>;
+
+  // The type of reference that should be provided to an initial action for a
+  // mocked function parameter of type T.
+  //
+  // There are two quirks here:
+  //
+  //  *  Unlike most forwarding functions, we pass scalars through by value.
+  //     This isn't strictly necessary because an lvalue reference would work
+  //     fine too and be consistent with other non-reference types, but it's
+  //     perhaps less surprising.
+  //
+  //     For example if the mocked function has signature void(int), then it
+  //     might seem surprising for the user's initial action to need to be
+  //     convertible to Action<void(const int&)>. This is perhaps less
+  //     surprising for a non-scalar type where there may be a performance
+  //     impact, or it might even be impossible, to pass by value.
+  //
+  //  *  More surprisingly, `const T&` is often not a const reference type.
+  //     By the reference collapsing rules in C++17 [dcl.ref]/6, if T refers to
+  //     U& or U&& for some non-scalar type U, then InitialActionArgType<T> is
+  //     U&. In other words, we may hand over a non-const reference.
+  //
+  //     So for example, given some non-scalar type Obj we have the following
+  //     mappings:
+  //
+  //            T               InitialActionArgType<T>
+  //         -------            -----------------------
+  //         Obj                const Obj&
+  //         Obj&               Obj&
+  //         Obj&&              Obj&
+  //         const Obj          const Obj&
+  //         const Obj&         const Obj&
+  //         const Obj&&        const Obj&
+  //
+  //     In other words, the initial actions get a mutable view of an non-scalar
+  //     argument if and only if the mock function itself accepts a non-const
+  //     reference type. They are never given an rvalue reference to an
+  //     non-scalar type.
+  //
+  //     This situation makes sense if you imagine use with a matcher that is
+  //     designed to write through a reference. For example, if the caller wants
+  //     to fill in a reference argument and then return a canned value:
+  //
+  //         EXPECT_CALL(mock, Call)
+  //             .WillOnce(DoAll(SetArgReferee<0>(17), Return(19)));
+  //
+  template <typename T>
+  using InitialActionArgType =
+      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
+
  public:
-  std::tuple<Actions...> actions;
+  struct UserConstructorTag {};
+
+  template <typename T, typename... U>
+  explicit DoAllAction(UserConstructorTag, T&& initial_action,
+                       U&&... other_actions)
+      : Base({}, std::forward<U>(other_actions)...),
+        initial_action_(std::forward<T>(initial_action)) {}
+
+  template <typename R, typename... Args,
+            typename std::enable_if<
+                conjunction<
+                    // Both the initial action and the rest must support
+                    // conversion to OnceAction.
+                    std::is_convertible<
+                        InitialAction,
+                        OnceAction<void(InitialActionArgType<Args>...)>>,
+                    std::is_convertible<Base, OnceAction<R(Args...)>>>::value,
+                int>::type = 0>
+  operator OnceAction<R(Args...)>() && {  // NOLINT
+    // Return an action that first calls the initial action with arguments
+    // filtered through InitialActionArgType, then forwards arguments directly
+    // to the base class to deal with the remaining actions.
+    struct OA {
+      OnceAction<void(InitialActionArgType<Args>...)> initial_action;
+      OnceAction<R(Args...)> remaining_actions;
+
+      R operator()(Args... args) && {
+        std::move(initial_action)
+            .Call(static_cast<InitialActionArgType<Args>>(args)...);
+
+        return std::move(remaining_actions).Call(std::forward<Args>(args)...);
+      }
+    };
 
-  template <typename R, typename... Args>
+    return OA{
+        std::move(initial_action_),
+        std::move(static_cast<Base&>(*this)),
+    };
+  }
+
+  template <
+      typename R, typename... Args,
+      typename std::enable_if<
+          conjunction<
+              // Both the initial action and the rest must support conversion to
+              // Action.
+              std::is_convertible<const InitialAction&,
+                                  Action<void(InitialActionArgType<Args>...)>>,
+              std::is_convertible<const Base&, Action<R(Args...)>>>::value,
+          int>::type = 0>
   operator Action<R(Args...)>() const {  // NOLINT
-    struct Op {
-      std::vector<Action<void(NonFinalType<Args>...)>> converted;
-      Action<R(Args...)> last;
+    // Return an action that first calls the initial action with arguments
+    // filtered through InitialActionArgType, then forwards arguments directly
+    // to the base class to deal with the remaining actions.
+    struct OA {
+      Action<void(InitialActionArgType<Args>...)> initial_action;
+      Action<R(Args...)> remaining_actions;
+
       R operator()(Args... args) const {
-        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
-        for (auto& a : converted) {
-          a.Perform(tuple_args);
-        }
-        return last.Perform(std::move(tuple_args));
+        initial_action.Perform(std::forward_as_tuple(
+            static_cast<InitialActionArgType<Args>>(args)...));
+
+        return remaining_actions.Perform(
+            std::forward_as_tuple(std::forward<Args>(args)...));
       }
     };
-    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
-                  MakeIndexSequence<sizeof...(Actions) - 1>()),
-              std::get<sizeof...(Actions) - 1>(actions)};
+
+    return OA{
+        initial_action_,
+        static_cast<const Base&>(*this),
+    };
   }
+
+ private:
+  InitialAction initial_action_;
 };
 
 template <typename T, typename... Params>
@@ -1078,10 +1659,11 @@ struct ReturnNewAction {
 
 template <size_t k>
 struct ReturnArgAction {
-  template <typename... Args>
-  auto operator()(const Args&... args) const ->
-      typename std::tuple_element<k, std::tuple<Args...>>::type {
-    return std::get<k>(std::tie(args...));
+  template <typename... Args,
+            typename = typename std::enable_if<(k < sizeof...(Args))>::type>
+  auto operator()(Args&&... args) const -> decltype(std::get<k>(
+      std::forward_as_tuple(std::forward<Args>(args)...))) {
+    return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
   }
 };
 
@@ -1203,7 +1785,8 @@ typedef internal::IgnoredValue Unused;
 template <typename... Action>
 internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
     Action&&... action) {
-  return {std::forward_as_tuple(std::forward<Action>(action)...)};
+  return internal::DoAllAction<typename std::decay<Action>::type...>(
+      {}, std::forward<Action>(action)...);
 }
 
 // WithArg<k>(an_action) creates an action that passes the k-th
@@ -1212,8 +1795,8 @@ internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
 // multiple arguments.  For convenience, we also provide
 // WithArgs<k>(an_action) (defined below) as a synonym.
 template <size_t k, typename InnerAction>
-internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
-WithArg(InnerAction&& action) {
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k> WithArg(
+    InnerAction&& action) {
   return {std::forward<InnerAction>(action)};
 }
 
@@ -1232,14 +1815,35 @@ WithArgs(InnerAction&& action) {
 // argument.  In other words, it adapts an action accepting no
 // argument to one that accepts (and ignores) arguments.
 template <typename InnerAction>
-internal::WithArgsAction<typename std::decay<InnerAction>::type>
-WithoutArgs(InnerAction&& action) {
+internal::WithArgsAction<typename std::decay<InnerAction>::type> WithoutArgs(
+    InnerAction&& action) {
   return {std::forward<InnerAction>(action)};
 }
 
-// Creates an action that returns 'value'.  'value' is passed by value
-// instead of const reference - otherwise Return("string literal")
-// will trigger a compiler error about using array as initializer.
+// Creates an action that returns a value.
+//
+// The returned type can be used with a mock function returning a non-void,
+// non-reference type U as follows:
+//
+//  *  If R is convertible to U and U is move-constructible, then the action can
+//     be used with WillOnce.
+//
+//  *  If const R& is convertible to U and U is copy-constructible, then the
+//     action can be used with both WillOnce and WillRepeatedly.
+//
+// The mock expectation contains the R value from which the U return value is
+// constructed (a move/copy of the argument to Return). This means that the R
+// value will survive at least until the mock object's expectations are cleared
+// or the mock object is destroyed, meaning that U can safely be a
+// reference-like type such as std::string_view:
+//
+//     // The mock function returns a view of a copy of the string fed to
+//     // Return. The view is valid even after the action is performed.
+//     MockFunction<std::string_view()> mock;
+//     EXPECT_CALL(mock, Call).WillOnce(Return(std::string("taco")));
+//     const std::string_view result = mock.AsStdFunction()();
+//     EXPECT_EQ("taco", result);
+//
 template <typename R>
 internal::ReturnAction<R> Return(R value) {
   return internal::ReturnAction<R>(std::move(value));
@@ -1273,6 +1877,8 @@ inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
   return internal::ReturnRefOfCopyAction<R>(x);
 }
 
+// DEPRECATED: use Return(x) directly with WillOnce.
+//
 // Modifies the parent action (a Return() action) to perform a move of the
 // argument instead of a copy.
 // Return(ByMove()) actions can only be executed once and will assert this
@@ -1319,7 +1925,7 @@ internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
 
 // Creates an action that sets a pointer referent to a given value.
 template <typename T1, typename T2>
-PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+PolymorphicAction<internal::AssignAction<T1, T2>> Assign(T1* ptr, T2 val) {
   return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
 }
 
@@ -1327,8 +1933,8 @@ PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
 
 // Creates an action that sets errno and returns the appropriate error.
 template <typename T>
-PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
-SetErrnoAndReturn(int errval, T result) {
+PolymorphicAction<internal::SetErrnoAndReturnAction<T>> SetErrnoAndReturn(
+    int errval, T result) {
   return MakePolymorphicAction(
       internal::SetErrnoAndReturnAction<T>(errval, result));
 }
@@ -1482,7 +2088,8 @@ struct ExcessiveArg {};
 
 // Builds an implementation of an Action<> for some particular signature, using
 // a class defined by an ACTION* macro.
-template <typename F, typename Impl> struct ActionImpl;
+template <typename F, typename Impl>
+struct ActionImpl;
 
 template <typename Impl>
 struct ImplBase {
@@ -1502,7 +2109,7 @@ struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
   using args_type = std::tuple<Args...>;
 
   ActionImpl() = default;  // Only defined if appropriate for Base.
-  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }
+  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} {}
 
   R operator()(Args&&... arg) const {
     static constexpr size_t kMaxArgs =
@@ -1521,12 +2128,14 @@ struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
     // args_type get passed, followed by a dummy of unspecified type for the
     // remainder up to 10 explicit args.
     static constexpr ExcessiveArg kExcessArg{};
-    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
-        /*function_type=*/function_type, /*return_type=*/R,
-        /*args_type=*/args_type,
-        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
-        /*args=*/args, std::get<arg_id>(args)...,
-        ((void)excess_id, kExcessArg)...);
+    return static_cast<const Impl&>(*this)
+        .template gmock_PerformImpl<
+            /*function_type=*/function_type, /*return_type=*/R,
+            /*args_type=*/args_type,
+            /*argN_type=*/
+            typename std::tuple_element<arg_id, args_type>::type...>(
+            /*args=*/args, std::get<arg_id>(args)...,
+            ((void)excess_id, kExcessArg)...);
   }
 };
 
@@ -1545,7 +2154,7 @@ template <typename F, typename Impl>
 
 #define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
   , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                 \
   const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
       GMOCK_INTERNAL_ARG_UNUSED, , 10)
 
@@ -1584,42 +2193,47 @@ template <typename F, typename Impl>
 #define GMOCK_ACTION_FIELD_PARAMS_(params) \
   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
 
-#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  class full_name {                                                           \
-   public:                                                                    \
-    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
-        : impl_(std::make_shared<gmock_Impl>(                                 \
-                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
-    full_name(const full_name&) = default;                                    \
-    full_name(full_name&&) noexcept = default;                                \
-    template <typename F>                                                     \
-    operator ::testing::Action<F>() const {                                   \
-      return ::testing::internal::MakeAction<F>(impl_);                       \
-    }                                                                         \
-   private:                                                                   \
-    class gmock_Impl {                                                        \
-     public:                                                                  \
-      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
-          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
-      template <typename function_type, typename return_type,                 \
-                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
-      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
-      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
-    };                                                                        \
-    std::shared_ptr<const gmock_Impl> impl_;                                  \
-  };                                                                          \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
-      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
-    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
-        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
-  }                                                                           \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  template <typename function_type, typename return_type, typename args_type, \
-            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
-  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
-  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+#define GMOCK_INTERNAL_ACTION(name, full_name, params)                         \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
+  class full_name {                                                            \
+   public:                                                                     \
+    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))               \
+        : impl_(std::make_shared<gmock_Impl>(                                  \
+              GMOCK_ACTION_GVALUE_PARAMS_(params))) {}                         \
+    full_name(const full_name&) = default;                                     \
+    full_name(full_name&&) noexcept = default;                                 \
+    template <typename F>                                                      \
+    operator ::testing::Action<F>() const {                                    \
+      return ::testing::internal::MakeAction<F>(impl_);                        \
+    }                                                                          \
+                                                                               \
+   private:                                                                    \
+    class gmock_Impl {                                                         \
+     public:                                                                   \
+      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))            \
+          : GMOCK_ACTION_INIT_PARAMS_(params) {}                               \
+      template <typename function_type, typename return_type,                  \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
+      GMOCK_ACTION_FIELD_PARAMS_(params)                                       \
+    };                                                                         \
+    std::shared_ptr<const gmock_Impl> impl_;                                   \
+  };                                                                           \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_;        \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                              \
+    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                       \
+        GMOCK_ACTION_GVALUE_PARAMS_(params));                                  \
+  }                                                                            \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
+  template <typename function_type, typename return_type, typename args_type,  \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
+  return_type                                                                  \
+  full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::gmock_PerformImpl( \
+      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
 
 }  // namespace internal
 
@@ -1627,12 +2241,13 @@ template <typename F, typename Impl>
 #define ACTION(name)                                                          \
   class name##Action {                                                        \
    public:                                                                    \
-   explicit name##Action() noexcept {}                                        \
-   name##Action(const name##Action&) noexcept {}                              \
+    explicit name##Action() noexcept {}                                       \
+    name##Action(const name##Action&) noexcept {}                             \
     template <typename F>                                                     \
     operator ::testing::Action<F>() const {                                   \
       return ::testing::internal::MakeAction<F, gmock_Impl>();                \
     }                                                                         \
+                                                                              \
    private:                                                                   \
     class gmock_Impl {                                                        \
      public:                                                                  \
@@ -1681,7 +2296,7 @@ template <typename F, typename Impl>
 }  // namespace testing
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/googletest/googlemock/include/gmock/gmock-cardinalities.h b/googletest/googlemock/include/gmock/gmock-cardinalities.h
index fc7f803a7a6515c21e3fbf9b505b0a76e8b9c670..b6ab648e50a649257120e62fdc404e8e5ba2c1d9 100644
--- a/googletest/googlemock/include/gmock/gmock-cardinalities.h
+++ b/googletest/googlemock/include/gmock/gmock-cardinalities.h
@@ -27,21 +27,23 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements some commonly used cardinalities.  More
 // cardinalities can be defined by the user implementing the
 // CardinalityInterface interface if necessary.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
 
 #include <limits.h>
+
 #include <memory>
 #include <ostream>  // NOLINT
+
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
 
@@ -116,7 +118,7 @@ class GTEST_API_ Cardinality {
   // cardinality, i.e. exceed the maximum number of allowed calls.
   bool IsOverSaturatedByCallCount(int call_count) const {
     return impl_->IsSaturatedByCallCount(call_count) &&
-        !impl_->IsSatisfiedByCallCount(call_count);
+           !impl_->IsSatisfiedByCallCount(call_count);
   }
 
   // Describes self to an ostream
diff --git a/googletest/googlemock/include/gmock/gmock-function-mocker.h b/googletest/googlemock/include/gmock/gmock-function-mocker.h
index 0fc6f6f3f13ccdaf94a4d055783879a57dcf8dc5..9edfd9d52a401c44cc7d13afa1c5f52b82b64d6b 100644
--- a/googletest/googlemock/include/gmock/gmock-function-mocker.h
+++ b/googletest/googlemock/include/gmock/gmock-function-mocker.h
@@ -31,10 +31,11 @@
 //
 // This file implements MOCK_METHOD.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
 
 #include <type_traits>  // IWYU pragma: keep
 #include <utility>      // IWYU pragma: keep
@@ -64,6 +65,39 @@ struct ThisRefAdjuster {
   }
 };
 
+constexpr bool PrefixOf(const char* a, const char* b) {
+  return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
+}
+
+template <int N, int M>
+constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
+  return N <= M && internal::PrefixOf(prefix, str);
+}
+
+template <int N, int M>
+constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
+  return N <= M && internal::PrefixOf(suffix, str + M - N);
+}
+
+template <int N, int M>
+constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
+  return N == M && internal::PrefixOf(a, b);
+}
+
+template <int N>
+constexpr bool ValidateSpec(const char (&spec)[N]) {
+  return internal::Equals("const", spec) ||
+         internal::Equals("override", spec) ||
+         internal::Equals("final", spec) ||
+         internal::Equals("noexcept", spec) ||
+         (internal::StartsWith("noexcept(", spec) &&
+          internal::EndsWith(")", spec)) ||
+         internal::Equals("ref(&)", spec) ||
+         internal::Equals("ref(&&)", spec) ||
+         (internal::StartsWith("Calltype(", spec) &&
+          internal::EndsWith(")", spec));
+}
+
 }  // namespace internal
 
 // The style guide prohibits "using" statements in a namespace scope
@@ -74,8 +108,11 @@ struct ThisRefAdjuster {
 using internal::FunctionMocker;
 }  // namespace testing
 
-#define MOCK_METHOD(...) \
-  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
+#define MOCK_METHOD(...)                                               \
+  GMOCK_INTERNAL_WARNING_PUSH()                                        \
+  GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function")    \
+  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) \
+  GMOCK_INTERNAL_WARNING_POP()
 
 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
@@ -86,17 +123,18 @@ using internal::FunctionMocker;
 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
   GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
 
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \
-  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \
-  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \
-  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \
-      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \
-  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \
-  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \
-      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \
-      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \
-      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \
-      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)  \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                   \
+      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));        \
+  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                  \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                         \
+      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),  \
+      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \
+      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                             \
+      GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec),                             \
+      GMOCK_INTERNAL_GET_REF_SPEC(_Spec),                                  \
       (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
 
 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
@@ -166,11 +204,11 @@ using internal::FunctionMocker;
             GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
   }                                                                            \
   mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
-      GMOCK_MOCKER_(_N, _Constness, _MethodName)
+  GMOCK_MOCKER_(_N, _Constness, _MethodName)
 
 #define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
 
-// Five Valid modifiers.
+// Valid modifiers.
 #define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
   GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
 
@@ -189,6 +227,14 @@ using internal::FunctionMocker;
       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
       _elem, )
 
+#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple)
+
+#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem)          \
+  GMOCK_PP_IF(                                                          \
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
+
 #define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
 
@@ -196,19 +242,25 @@ using internal::FunctionMocker;
   GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
               GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
 
-#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)
-
-#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \
-  static_assert(                                                          \
-      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \
-       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \
-      GMOCK_PP_STRINGIZE(                                                 \
+#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \
+  static_assert(                                                     \
+      ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)),  \
+      "Token \'" GMOCK_PP_STRINGIZE(                                 \
+          _elem) "\' cannot be recognized as a valid specification " \
+                 "modifier. Is a ',' missing?");
+#else
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)                 \
+  static_assert(                                                               \
+      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +         \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) +      \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +         \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) +      \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +           \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \
+      GMOCK_PP_STRINGIZE(                                                      \
           _elem) " cannot be recognized as a valid specification modifier.");
+#endif  // GMOCK_INTERNAL_STRICT_SPEC_ASSERT
 
 // Modifiers implementation.
 #define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
@@ -238,26 +290,12 @@ using internal::FunctionMocker;
 
 #define GMOCK_INTERNAL_UNPACK_ref(x) x
 
-#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \
-  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \
-              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
-  (_elem)
-
-// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
-// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows
-// maybe they can be simplified somehow.
-#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
-  GMOCK_INTERNAL_IS_CALLTYPE_I(          \
-      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
-#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg)
+#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem)
 
-#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
-  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \
-      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
-#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
-  GMOCK_PP_IDENTITY _arg
+#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype ,
 
-#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype
+#define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__
 
 // Note: The use of `identity_t` here allows _Ret to represent return types that
 // would normally need to be specified in a different way. For example, a method
@@ -326,6 +364,8 @@ using internal::FunctionMocker;
 #define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
 #define MOCK_METHOD10(m, ...) \
   GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
+#define MOCK_METHOD11(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, , m, 11, __VA_ARGS__)
 
 #define MOCK_CONST_METHOD0(m, ...) \
   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
@@ -476,4 +516,4 @@ using internal::FunctionMocker;
 #define GMOCK_MOCKER_(arity, constness, Method) \
   GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
diff --git a/googletest/googlemock/include/gmock/gmock-matchers.h b/googletest/googlemock/include/gmock/gmock-matchers.h
index 86be9c176ebcaf8e8e373626d851f4be2f4687c9..9e634f7f1c47b267c2e2ddf5392445cb393ab669 100644
--- a/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // The MATCHER* family of macros can be used in a namespace scope to
@@ -241,7 +240,7 @@
 //
 // To learn more about using these macros, please search for 'MATCHER'
 // on
-// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+// https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md
 //
 // This file also implements some commonly used argument matchers.  More
 // matchers can be defined by the user implementing the
@@ -250,7 +249,8 @@
 // See googletest/include/gtest/gtest-matchers.h for the definition of class
 // Matcher, class MatcherInterface, and others.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
@@ -258,6 +258,7 @@
 #include <algorithm>
 #include <cmath>
 #include <initializer_list>
+#include <ios>
 #include <iterator>
 #include <limits>
 #include <memory>
@@ -313,7 +314,9 @@ class StringMatchResultListener : public MatchResultListener {
  private:
   ::std::stringstream ss_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+  StringMatchResultListener(const StringMatchResultListener&) = delete;
+  StringMatchResultListener& operator=(const StringMatchResultListener&) =
+      delete;
 };
 
 // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
@@ -396,7 +399,7 @@ class MatcherCastImpl {
 // is already a Matcher.  This only compiles when type T can be
 // statically converted to type U.
 template <typename T, typename U>
-class MatcherCastImpl<T, Matcher<U> > {
+class MatcherCastImpl<T, Matcher<U>> {
  public:
   static Matcher<T> Cast(const Matcher<U>& source_matcher) {
     return Matcher<T>(new Impl(source_matcher));
@@ -450,7 +453,7 @@ class MatcherCastImpl<T, Matcher<U> > {
 // This even more specialized version is used for efficiently casting
 // a matcher to its own type.
 template <typename T>
-class MatcherCastImpl<T, Matcher<T> > {
+class MatcherCastImpl<T, Matcher<T>> {
  public:
   static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
 };
@@ -533,19 +536,18 @@ inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
                 "T must be implicitly convertible to U");
   // Enforce that we are not converting a non-reference type T to a reference
   // type U.
-  GTEST_COMPILE_ASSERT_(
-      std::is_reference<T>::value || !std::is_reference<U>::value,
-      cannot_convert_non_reference_arg_to_reference);
+  static_assert(std::is_reference<T>::value || !std::is_reference<U>::value,
+                "cannot convert non reference arg to reference");
   // In case both T and U are arithmetic types, enforce that the
   // conversion is not lossy.
   typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
   typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
   constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
   constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
-  GTEST_COMPILE_ASSERT_(
+  static_assert(
       kTIsOther || kUIsOther ||
-      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
-      conversion_of_arithmetic_types_must_be_lossless);
+          (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+      "conversion of arithmetic types must be lossless");
   return MatcherCast<T>(matcher);
 }
 
@@ -678,9 +680,9 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
                   const ValueTuple& value_tuple) {
   // Makes sure that matcher_tuple and value_tuple have the same
   // number of fields.
-  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
-                            std::tuple_size<ValueTuple>::value,
-                        matcher_and_value_have_different_numbers_of_fields);
+  static_assert(std::tuple_size<MatcherTuple>::value ==
+                    std::tuple_size<ValueTuple>::value,
+                "matcher and value have different numbers of fields");
   return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
                                                                   value_tuple);
 }
@@ -689,8 +691,7 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
 // is no failure, nothing will be streamed to os.
 template <typename MatcherTuple, typename ValueTuple>
 void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
-                                const ValueTuple& values,
-                                ::std::ostream* os) {
+                                const ValueTuple& values, ::std::ostream* os) {
   TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
       matchers, values, os);
 }
@@ -714,14 +715,14 @@ class TransformTupleValuesHelper {
  private:
   template <typename Tup, size_t kRemainingSize>
   struct IterateOverTuple {
-    OutIter operator() (Func f, const Tup& t, OutIter out) const {
+    OutIter operator()(Func f, const Tup& t, OutIter out) const {
       *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
       return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
     }
   };
   template <typename Tup>
   struct IterateOverTuple<Tup, 0> {
-    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
+    OutIter operator()(Func /* f */, const Tup& /* t */, OutIter out) const {
       return out;
     }
   };
@@ -767,9 +768,7 @@ class IsNullMatcher {
   }
 
   void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "isn't NULL";
-  }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NULL"; }
 };
 
 // Implements the polymorphic NotNull() matcher, which matches any raw or smart
@@ -783,9 +782,7 @@ class NotNullMatcher {
   }
 
   void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is NULL";
-  }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
 };
 
 // Ref(variable) matches any argument that is a reference to
@@ -871,8 +868,7 @@ inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
 // String comparison for narrow or wide strings that can have embedded NUL
 // characters.
 template <typename StringType>
-bool CaseInsensitiveStringEquals(const StringType& s1,
-                                 const StringType& s2) {
+bool CaseInsensitiveStringEquals(const StringType& s1, const StringType& s2) {
   // Are the heads equal?
   if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
     return false;
@@ -933,8 +929,8 @@ class StrEqualityMatcher {
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
     const StringType s2(s);
-    const bool eq = case_sensitive_ ? s2 == string_ :
-        CaseInsensitiveStringEquals(s2, string_);
+    const bool eq = case_sensitive_ ? s2 == string_
+                                    : CaseInsensitiveStringEquals(s2, string_);
     return expect_eq_ == eq;
   }
 
@@ -1021,8 +1017,7 @@ class HasSubstrMatcher {
 template <typename StringType>
 class StartsWithMatcher {
  public:
-  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
-  }
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {}
 
 #if GTEST_INTERNAL_HAS_STRING_VIEW
   bool MatchAndExplain(const internal::StringView& s,
@@ -1053,7 +1048,7 @@ class StartsWithMatcher {
                        MatchResultListener* /* listener */) const {
     const StringType& s2(s);
     return s2.length() >= prefix_.length() &&
-        s2.substr(0, prefix_.length()) == prefix_;
+           s2.substr(0, prefix_.length()) == prefix_;
   }
 
   void DescribeTo(::std::ostream* os) const {
@@ -1107,7 +1102,7 @@ class EndsWithMatcher {
                        MatchResultListener* /* listener */) const {
     const StringType& s2(s);
     return s2.length() >= suffix_.length() &&
-        s2.substr(s2.length() - suffix_.length()) == suffix_;
+           s2.substr(s2.length() - suffix_.length()) == suffix_;
   }
 
   void DescribeTo(::std::ostream* os) const {
@@ -1124,6 +1119,45 @@ class EndsWithMatcher {
   const StringType suffix_;
 };
 
+// Implements the polymorphic WhenBase64Unescaped(matcher) matcher, which can be
+// used as a Matcher<T> as long as T can be converted to a string.
+class WhenBase64UnescapedMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  explicit WhenBase64UnescapedMatcher(
+      const Matcher<const std::string&>& internal_matcher)
+      : internal_matcher_(internal_matcher) {}
+
+  // Matches anything that can convert to std::string.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* listener) const {
+    const std::string s2(s);  // NOLINT (needed for working with string_view).
+    std::string unescaped;
+    if (!internal::Base64Unescape(s2, &unescaped)) {
+      if (listener != nullptr) {
+        *listener << "is not a valid base64 escaped string";
+      }
+      return false;
+    }
+    return MatchPrintAndExplain(unescaped, internal_matcher_, listener);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "matches after Base64Unescape ";
+    internal_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not match after Base64Unescape ";
+    internal_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const std::string&> internal_matcher_;
+};
+
 // Implements a matcher that compares the two fields of a 2-tuple
 // using one of the ==, <=, <, etc, operators.  The two fields being
 // compared don't have to have the same type.
@@ -1197,8 +1231,7 @@ class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
 template <typename T>
 class NotMatcherImpl : public MatcherInterface<const T&> {
  public:
-  explicit NotMatcherImpl(const Matcher<T>& matcher)
-      : matcher_(matcher) {}
+  explicit NotMatcherImpl(const Matcher<T>& matcher) : matcher_(matcher) {}
 
   bool MatchAndExplain(const T& x,
                        MatchResultListener* listener) const override {
@@ -1242,7 +1275,7 @@ class NotMatcher {
 template <typename T>
 class AllOfMatcherImpl : public MatcherInterface<const T&> {
  public:
-  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
+  explicit AllOfMatcherImpl(std::vector<Matcher<T>> matchers)
       : matchers_(std::move(matchers)) {}
 
   void DescribeTo(::std::ostream* os) const override {
@@ -1293,7 +1326,7 @@ class AllOfMatcherImpl : public MatcherInterface<const T&> {
   }
 
  private:
-  const std::vector<Matcher<T> > matchers_;
+  const std::vector<Matcher<T>> matchers_;
 };
 
 // VariadicMatcher is used for the variadic implementation of
@@ -1316,14 +1349,14 @@ class VariadicMatcher {
   // all of the provided matchers (Matcher1, Matcher2, ...) can match.
   template <typename T>
   operator Matcher<T>() const {
-    std::vector<Matcher<T> > values;
+    std::vector<Matcher<T>> values;
     CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
     return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
   }
 
  private:
   template <typename T, size_t I>
-  void CreateVariadicMatcher(std::vector<Matcher<T> >* values,
+  void CreateVariadicMatcher(std::vector<Matcher<T>>* values,
                              std::integral_constant<size_t, I>) const {
     values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
     CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
@@ -1331,7 +1364,7 @@ class VariadicMatcher {
 
   template <typename T>
   void CreateVariadicMatcher(
-      std::vector<Matcher<T> >*,
+      std::vector<Matcher<T>>*,
       std::integral_constant<size_t, sizeof...(Args)>) const {}
 
   std::tuple<Args...> matchers_;
@@ -1347,7 +1380,7 @@ using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
 template <typename T>
 class AnyOfMatcherImpl : public MatcherInterface<const T&> {
  public:
-  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
+  explicit AnyOfMatcherImpl(std::vector<Matcher<T>> matchers)
       : matchers_(std::move(matchers)) {}
 
   void DescribeTo(::std::ostream* os) const override {
@@ -1398,13 +1431,35 @@ class AnyOfMatcherImpl : public MatcherInterface<const T&> {
   }
 
  private:
-  const std::vector<Matcher<T> > matchers_;
+  const std::vector<Matcher<T>> matchers_;
 };
 
 // AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
 template <typename... Args>
 using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
 
+// ConditionalMatcher is the implementation of Conditional(cond, m1, m2)
+template <typename MatcherTrue, typename MatcherFalse>
+class ConditionalMatcher {
+ public:
+  ConditionalMatcher(bool condition, MatcherTrue matcher_true,
+                     MatcherFalse matcher_false)
+      : condition_(condition),
+        matcher_true_(std::move(matcher_true)),
+        matcher_false_(std::move(matcher_false)) {}
+
+  template <typename T>
+  operator Matcher<T>() const {  // NOLINT(runtime/explicit)
+    return condition_ ? SafeMatcherCast<T>(matcher_true_)
+                      : SafeMatcherCast<T>(matcher_false_);
+  }
+
+ private:
+  bool condition_;
+  MatcherTrue matcher_true_;
+  MatcherFalse matcher_false_;
+};
+
 // Wrapper for implementation of Any/AllOfArray().
 template <template <class> class MatcherImpl, typename T>
 class SomeOfArrayMatcher {
@@ -1454,8 +1509,7 @@ class TrulyMatcher {
     // We cannot write 'return !!predicate_(x);' as that doesn't work
     // when predicate_(x) returns a class convertible to bool but
     // having no operator!().
-    if (predicate_(x))
-      return true;
+    if (predicate_(x)) return true;
     *listener << "didn't satisfy the given predicate";
     return false;
   }
@@ -1563,8 +1617,8 @@ class PredicateFormatterFromMatcher {
 // used for implementing ASSERT_THAT() and EXPECT_THAT().
 // Implementation detail: 'matcher' is received by-value to force decaying.
 template <typename M>
-inline PredicateFormatterFromMatcher<M>
-MakePredicateFormatterFromMatcher(M matcher) {
+inline PredicateFormatterFromMatcher<M> MakePredicateFormatterFromMatcher(
+    M matcher) {
   return PredicateFormatterFromMatcher<M>(std::move(matcher));
 }
 
@@ -1579,9 +1633,7 @@ class IsNanMatcher {
   }
 
   void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "isn't NaN";
-  }
+  void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; }
 };
 
 // Implements the polymorphic floating point equality matcher, which matches
@@ -1597,9 +1649,8 @@ class FloatingEqMatcher {
   // equality comparisons between NANs will always return false.  We specify a
   // negative max_abs_error_ term to indicate that ULP-based approximation will
   // be used for comparison.
-  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
-    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
-  }
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan)
+      : expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {}
 
   // Constructor that supports a user-specified max_abs_error that will be used
   // for comparison instead of ULP-based approximation.  The max absolute
@@ -1661,8 +1712,8 @@ class FloatingEqMatcher {
       // os->precision() returns the previously set precision, which we
       // store to restore the ostream to its original configuration
       // after outputting.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
+      const ::std::streamsize old_precision =
+          os->precision(::std::numeric_limits<FloatType>::digits10 + 2);
       if (FloatingPoint<FloatType>(expected_).is_nan()) {
         if (nan_eq_nan_) {
           *os << "is NaN";
@@ -1680,8 +1731,8 @@ class FloatingEqMatcher {
 
     void DescribeNegationTo(::std::ostream* os) const override {
       // As before, get original precision.
-      const ::std::streamsize old_precision = os->precision(
-          ::std::numeric_limits<FloatType>::digits10 + 2);
+      const ::std::streamsize old_precision =
+          os->precision(::std::numeric_limits<FloatType>::digits10 + 2);
       if (FloatingPoint<FloatType>(expected_).is_nan()) {
         if (nan_eq_nan_) {
           *os << "isn't NaN";
@@ -1699,9 +1750,7 @@ class FloatingEqMatcher {
     }
 
    private:
-    bool HasMaxAbsError() const {
-      return max_abs_error_ >= 0;
-    }
+    bool HasMaxAbsError() const { return max_abs_error_ >= 0; }
 
     const FloatType expected_;
     const bool nan_eq_nan_;
@@ -1773,9 +1822,8 @@ class FloatingEq2Matcher {
   template <typename Tuple>
   class Impl : public MatcherInterface<Tuple> {
    public:
-    Impl(FloatType max_abs_error, bool nan_eq_nan) :
-        max_abs_error_(max_abs_error),
-        nan_eq_nan_(nan_eq_nan) {}
+    Impl(FloatType max_abs_error, bool nan_eq_nan)
+        : max_abs_error_(max_abs_error), nan_eq_nan_(nan_eq_nan) {}
 
     bool MatchAndExplain(Tuple args,
                          MatchResultListener* listener) const override {
@@ -1951,9 +1999,7 @@ class WhenDynamicCastToMatcherBase {
  protected:
   const Matcher<To> matcher_;
 
-  static std::string GetToName() {
-    return GetTypeName<To>();
-  }
+  static std::string GetToName() { return GetTypeName<To>(); }
 
  private:
   static void GetCastTypeDescription(::std::ostream* os) {
@@ -2090,7 +2136,7 @@ class PropertyMatcher {
   }
 
   template <typename T>
-  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
     return MatchAndExplainImpl(
         typename std::is_pointer<typename std::remove_const<T>::type>::type(),
         value, listener);
@@ -2142,16 +2188,16 @@ struct CallableTraits {
 
 // Specialization for function pointers.
 template <typename ArgType, typename ResType>
-struct CallableTraits<ResType(*)(ArgType)> {
+struct CallableTraits<ResType (*)(ArgType)> {
   typedef ResType ResultType;
-  typedef ResType(*StorageType)(ArgType);
+  typedef ResType (*StorageType)(ArgType);
 
-  static void CheckIsValid(ResType(*f)(ArgType)) {
+  static void CheckIsValid(ResType (*f)(ArgType)) {
     GTEST_CHECK_(f != nullptr)
         << "NULL function pointer is passed into ResultOf().";
   }
   template <typename T>
-  static ResType Invoke(ResType(*f)(ArgType), T arg) {
+  static ResType Invoke(ResType (*f)(ArgType), T arg) {
     return (*f)(arg);
   }
 };
@@ -2162,13 +2208,21 @@ template <typename Callable, typename InnerMatcher>
 class ResultOfMatcher {
  public:
   ResultOfMatcher(Callable callable, InnerMatcher matcher)
-      : callable_(std::move(callable)), matcher_(std::move(matcher)) {
+      : ResultOfMatcher(/*result_description=*/"", std::move(callable),
+                        std::move(matcher)) {}
+
+  ResultOfMatcher(const std::string& result_description, Callable callable,
+                  InnerMatcher matcher)
+      : result_description_(result_description),
+        callable_(std::move(callable)),
+        matcher_(std::move(matcher)) {
     CallableTraits<Callable>::CheckIsValid(callable_);
   }
 
   template <typename T>
   operator Matcher<T>() const {
-    return Matcher<T>(new Impl<const T&>(callable_, matcher_));
+    return Matcher<T>(
+        new Impl<const T&>(result_description_, callable_, matcher_));
   }
 
  private:
@@ -2181,21 +2235,36 @@ class ResultOfMatcher {
 
    public:
     template <typename M>
-    Impl(const CallableStorageType& callable, const M& matcher)
-        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {}
+    Impl(const std::string& result_description,
+         const CallableStorageType& callable, const M& matcher)
+        : result_description_(result_description),
+          callable_(callable),
+          matcher_(MatcherCast<ResultType>(matcher)) {}
 
     void DescribeTo(::std::ostream* os) const override {
-      *os << "is mapped by the given callable to a value that ";
+      if (result_description_.empty()) {
+        *os << "is mapped by the given callable to a value that ";
+      } else {
+        *os << "whose " << result_description_ << " ";
+      }
       matcher_.DescribeTo(os);
     }
 
     void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "is mapped by the given callable to a value that ";
+      if (result_description_.empty()) {
+        *os << "is mapped by the given callable to a value that ";
+      } else {
+        *os << "whose " << result_description_ << " ";
+      }
       matcher_.DescribeNegationTo(os);
     }
 
     bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
-      *listener << "which is mapped by the given callable to ";
+      if (result_description_.empty()) {
+        *listener << "which is mapped by the given callable to ";
+      } else {
+        *listener << "whose " << result_description_ << " is ";
+      }
       // Cannot pass the return value directly to MatchPrintAndExplain, which
       // takes a non-const reference as argument.
       // Also, specifying template argument explicitly is needed because T could
@@ -2206,6 +2275,7 @@ class ResultOfMatcher {
     }
 
    private:
+    const std::string result_description_;
     // Functors often define operator() as non-const method even though
     // they are actually stateless. But we need to use them even when
     // 'this' is a const pointer. It's the user's responsibility not to
@@ -2215,6 +2285,7 @@ class ResultOfMatcher {
     const Matcher<ResultType> matcher_;
   };  // class Impl
 
+  const std::string result_description_;
   const CallableStorageType callable_;
   const InnerMatcher matcher_;
 };
@@ -2224,8 +2295,7 @@ template <typename SizeMatcher>
 class SizeIsMatcher {
  public:
   explicit SizeIsMatcher(const SizeMatcher& size_matcher)
-       : size_matcher_(size_matcher) {
-  }
+      : size_matcher_(size_matcher) {}
 
   template <typename Container>
   operator Matcher<Container>() const {
@@ -2240,11 +2310,11 @@ class SizeIsMatcher {
         : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
 
     void DescribeTo(::std::ostream* os) const override {
-      *os << "size ";
+      *os << "has a size that ";
       size_matcher_.DescribeTo(os);
     }
     void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "size ";
+      *os << "has a size that ";
       size_matcher_.DescribeNegationTo(os);
     }
 
@@ -2253,8 +2323,8 @@ class SizeIsMatcher {
       SizeType size = container.size();
       StringMatchResultListener size_listener;
       const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
-      *listener
-          << "whose size " << size << (result ? " matches" : " doesn't match");
+      *listener << "whose size " << size
+                << (result ? " matches" : " doesn't match");
       PrintIfNotEmpty(size_listener.str(), listener->stream());
       return result;
     }
@@ -2283,8 +2353,9 @@ class BeginEndDistanceIsMatcher {
   template <typename Container>
   class Impl : public MatcherInterface<Container> {
    public:
-    typedef internal::StlContainerView<
-        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        Container)>
+        ContainerView;
     typedef typename std::iterator_traits<
         typename ContainerView::type::const_iterator>::difference_type
         DistanceType;
@@ -2364,18 +2435,15 @@ class ContainerEqMatcher {
     typedef internal::StlContainerView<
         typename std::remove_const<LhsContainer>::type>
         LhsView;
-    typedef typename LhsView::type LhsStlContainer;
     StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
-    if (lhs_stl_container == expected_)
-      return true;
+    if (lhs_stl_container == expected_) return true;
 
     ::std::ostream* const os = listener->stream();
     if (os != nullptr) {
       // Something is different. Check for extra values first.
       bool printed_header = false;
-      for (typename LhsStlContainer::const_iterator it =
-               lhs_stl_container.begin();
-           it != lhs_stl_container.end(); ++it) {
+      for (auto it = lhs_stl_container.begin(); it != lhs_stl_container.end();
+           ++it) {
         if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
             expected_.end()) {
           if (printed_header) {
@@ -2390,11 +2458,10 @@ class ContainerEqMatcher {
 
       // Now check for missing values.
       bool printed_header2 = false;
-      for (typename StlContainer::const_iterator it = expected_.begin();
-           it != expected_.end(); ++it) {
-        if (internal::ArrayAwareFind(
-                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
-            lhs_stl_container.end()) {
+      for (auto it = expected_.begin(); it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(lhs_stl_container.begin(),
+                                     lhs_stl_container.end(),
+                                     *it) == lhs_stl_container.end()) {
           if (printed_header2) {
             *os << ", ";
           } else {
@@ -2417,7 +2484,9 @@ class ContainerEqMatcher {
 // A comparator functor that uses the < operator to compare two values.
 struct LessComparator {
   template <typename T, typename U>
-  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
+  bool operator()(const T& lhs, const U& rhs) const {
+    return lhs < rhs;
+  }
 };
 
 // Implements WhenSortedBy(comparator, container_matcher).
@@ -2436,14 +2505,16 @@ class WhenSortedByMatcher {
   template <typename LhsContainer>
   class Impl : public MatcherInterface<LhsContainer> {
    public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        LhsContainer)>
+        LhsView;
     typedef typename LhsView::type LhsStlContainer;
     typedef typename LhsView::const_reference LhsStlContainerReference;
     // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
     // so that we can match associative containers.
-    typedef typename RemoveConstFromKey<
-        typename LhsStlContainer::value_type>::type LhsValue;
+    typedef
+        typename RemoveConstFromKey<typename LhsStlContainer::value_type>::type
+            LhsValue;
 
     Impl(const Comparator& comparator, const ContainerMatcher& matcher)
         : comparator_(comparator), matcher_(matcher) {}
@@ -2463,8 +2534,8 @@ class WhenSortedByMatcher {
       LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
       ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
                                                lhs_stl_container.end());
-      ::std::sort(
-           sorted_container.begin(), sorted_container.end(), comparator_);
+      ::std::sort(sorted_container.begin(), sorted_container.end(),
+                  comparator_);
 
       if (!listener->IsInterested()) {
         // If the listener is not interested, we do not need to
@@ -2477,8 +2548,8 @@ class WhenSortedByMatcher {
       *listener << " when sorted";
 
       StringMatchResultListener inner_listener;
-      const bool match = matcher_.MatchAndExplain(sorted_container,
-                                                  &inner_listener);
+      const bool match =
+          matcher_.MatchAndExplain(sorted_container, &inner_listener);
       PrintIfNotEmpty(inner_listener.str(), listener->stream());
       return match;
     }
@@ -2487,7 +2558,8 @@ class WhenSortedByMatcher {
     const Comparator comparator_;
     const Matcher<const ::std::vector<LhsValue>&> matcher_;
 
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+    Impl(const Impl&) = delete;
+    Impl& operator=(const Impl&) = delete;
   };
 
  private:
@@ -2501,9 +2573,9 @@ class WhenSortedByMatcher {
 // container and the RHS container respectively.
 template <typename TupleMatcher, typename RhsContainer>
 class PointwiseMatcher {
-  GTEST_COMPILE_ASSERT_(
+  static_assert(
       !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
-      use_UnorderedPointwise_with_hash_tables);
+      "use UnorderedPointwise with hash tables");
 
  public:
   typedef internal::StlContainerView<RhsContainer> RhsView;
@@ -2522,9 +2594,9 @@ class PointwiseMatcher {
 
   template <typename LhsContainer>
   operator Matcher<LhsContainer>() const {
-    GTEST_COMPILE_ASSERT_(
+    static_assert(
         !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
-        use_UnorderedPointwise_with_hash_tables);
+        "use UnorderedPointwise with hash tables");
 
     return Matcher<LhsContainer>(
         new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
@@ -2533,8 +2605,9 @@ class PointwiseMatcher {
   template <typename LhsContainer>
   class Impl : public MatcherInterface<LhsContainer> {
    public:
-    typedef internal::StlContainerView<
-         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef internal::StlContainerView<GTEST_REMOVE_REFERENCE_AND_CONST_(
+        LhsContainer)>
+        LhsView;
     typedef typename LhsView::type LhsStlContainer;
     typedef typename LhsView::const_reference LhsStlContainerReference;
     typedef typename LhsStlContainer::value_type LhsValue;
@@ -2574,14 +2647,14 @@ class PointwiseMatcher {
         return false;
       }
 
-      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
-      typename RhsStlContainer::const_iterator right = rhs_.begin();
+      auto left = lhs_stl_container.begin();
+      auto right = rhs_.begin();
       for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
         if (listener->IsInterested()) {
           StringMatchResultListener inner_listener;
           // Create InnerMatcherArg as a temporarily object to avoid it outlives
           // *left and *right. Dereference or the conversion to `const T&` may
-          // return temp objects, e.g for vector<bool>.
+          // return temp objects, e.g. for vector<bool>.
           if (!mono_tuple_matcher_.MatchAndExplain(
                   InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
                                   ImplicitCast_<const RhsValue&>(*right)),
@@ -2628,18 +2701,17 @@ class QuantifierMatcherImpl : public MatcherInterface<Container> {
   template <typename InnerMatcher>
   explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
       : inner_matcher_(
-           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+            testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
 
   // Checks whether:
   // * All elements in the container match, if all_elements_should_match.
   // * Any element in the container matches, if !all_elements_should_match.
-  bool MatchAndExplainImpl(bool all_elements_should_match,
-                           Container container,
+  bool MatchAndExplainImpl(bool all_elements_should_match, Container container,
                            MatchResultListener* listener) const {
     StlContainerReference stl_container = View::ConstReference(container);
     size_t i = 0;
-    for (typename StlContainer::const_iterator it = stl_container.begin();
-         it != stl_container.end(); ++it, ++i) {
+    for (auto it = stl_container.begin(); it != stl_container.end();
+         ++it, ++i) {
       StringMatchResultListener inner_listener;
       const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
 
@@ -2653,6 +2725,54 @@ class QuantifierMatcherImpl : public MatcherInterface<Container> {
     return all_elements_should_match;
   }
 
+  bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    std::vector<size_t> match_elements;
+    for (auto it = stl_container.begin(); it != stl_container.end();
+         ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+      if (matches) {
+        match_elements.push_back(i);
+      }
+    }
+    if (listener->IsInterested()) {
+      if (match_elements.empty()) {
+        *listener << "has no element that matches";
+      } else if (match_elements.size() == 1) {
+        *listener << "whose element #" << match_elements[0] << " matches";
+      } else {
+        *listener << "whose elements (";
+        std::string sep = "";
+        for (size_t e : match_elements) {
+          *listener << sep << e;
+          sep = ", ";
+        }
+        *listener << ") match";
+      }
+    }
+    StringMatchResultListener count_listener;
+    if (count_matcher.MatchAndExplain(match_elements.size(), &count_listener)) {
+      *listener << " and whose match quantity of " << match_elements.size()
+                << " matches";
+      PrintIfNotEmpty(count_listener.str(), listener->stream());
+      return true;
+    } else {
+      if (match_elements.empty()) {
+        *listener << " and";
+      } else {
+        *listener << " but";
+      }
+      *listener << " whose match quantity of " << match_elements.size()
+                << " does not match";
+      PrintIfNotEmpty(count_listener.str(), listener->stream());
+      return false;
+    }
+  }
+
  protected:
   const Matcher<const Element&> inner_matcher_;
 };
@@ -2709,6 +2829,58 @@ class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
   }
 };
 
+// Implements Contains(element_matcher).Times(n) for the given argument type
+// Container.
+template <typename Container>
+class ContainsTimesMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsTimesMatcherImpl(InnerMatcher inner_matcher,
+                                    Matcher<size_t> count_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher),
+        count_matcher_(std::move(count_matcher)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "quantity of elements that match ";
+    this->inner_matcher_.DescribeTo(os);
+    *os << " ";
+    count_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "quantity of elements that match ";
+    this->inner_matcher_.DescribeTo(os);
+    *os << " ";
+    count_matcher_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(count_matcher_, container, listener);
+  }
+
+ private:
+  const Matcher<size_t> count_matcher_;
+};
+
+// Implements polymorphic Contains(element_matcher).Times(n).
+template <typename M>
+class ContainsTimesMatcher {
+ public:
+  explicit ContainsTimesMatcher(M m, Matcher<size_t> count_matcher)
+      : inner_matcher_(m), count_matcher_(std::move(count_matcher)) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {  // NOLINT
+    return Matcher<Container>(new ContainsTimesMatcherImpl<const Container&>(
+        inner_matcher_, count_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+  const Matcher<size_t> count_matcher_;
+};
+
 // Implements polymorphic Contains(element_matcher).
 template <typename M>
 class ContainsMatcher {
@@ -2716,11 +2888,15 @@ class ContainsMatcher {
   explicit ContainsMatcher(M m) : inner_matcher_(m) {}
 
   template <typename Container>
-  operator Matcher<Container>() const {
+  operator Matcher<Container>() const {  // NOLINT
     return Matcher<Container>(
         new ContainsMatcherImpl<const Container&>(inner_matcher_));
   }
 
+  ContainsTimesMatcher<M> Times(Matcher<size_t> count_matcher) const {
+    return ContainsTimesMatcher<M>(inner_matcher_, std::move(count_matcher));
+  }
+
  private:
   const M inner_matcher_;
 };
@@ -2732,7 +2908,7 @@ class EachMatcher {
   explicit EachMatcher(M m) : inner_matcher_(m) {}
 
   template <typename Container>
-  operator Matcher<Container>() const {
+  operator Matcher<Container>() const {  // NOLINT
     return Matcher<Container>(
         new EachMatcherImpl<const Container&>(inner_matcher_));
   }
@@ -2778,8 +2954,7 @@ class KeyMatcherImpl : public MatcherInterface<PairType> {
   template <typename InnerMatcher>
   explicit KeyMatcherImpl(InnerMatcher inner_matcher)
       : inner_matcher_(
-          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
-  }
+            testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {}
 
   // Returns true if and only if 'key_value.first' (the key) matches the inner
   // matcher.
@@ -2884,8 +3059,7 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
       : first_matcher_(
             testing::SafeMatcherCast<const FirstType&>(first_matcher)),
         second_matcher_(
-            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
-  }
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {}
 
   // Describes what this matcher does.
   void DescribeTo(::std::ostream* os) const override {
@@ -2963,7 +3137,7 @@ class PairMatcher {
       : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
 
   template <typename PairType>
-  operator Matcher<PairType> () const {
+  operator Matcher<PairType>() const {
     return Matcher<PairType>(
         new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
   }
@@ -3062,6 +3236,21 @@ auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
   const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
   return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
 }
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<17>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<18>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<19>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s);
+}
 #endif  // defined(__cpp_structured_bindings)
 
 template <size_t I, typename T>
@@ -3128,8 +3317,8 @@ class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
     std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
 
     VariadicExpand(
-        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
-                                        std::get<I>(tuple), &inner_listener[I])
+        {failed_pos == ~size_t{}&& !std::get<I>(matchers_).MatchAndExplain(
+                           std::get<I>(tuple), &inner_listener[I])
              ? failed_pos = I
              : 0 ...});
     if (failed_pos != ~size_t{}) {
@@ -3235,7 +3424,7 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
     // explanations[i] is the explanation of the element at index i.
     ::std::vector<std::string> explanations(count());
     StlContainerReference stl_container = View::ConstReference(container);
-    typename StlContainer::const_iterator it = stl_container.begin();
+    auto it = stl_container.begin();
     size_t exam_pos = 0;
     bool mismatch_found = false;  // Have we found a mismatched element yet?
 
@@ -3312,7 +3501,7 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
 
   size_t count() const { return matchers_.size(); }
 
-  ::std::vector<Matcher<const Element&> > matchers_;
+  ::std::vector<Matcher<const Element&>> matchers_;
 };
 
 // Connectivity matrix of (elements X matchers), in element-major order.
@@ -3324,8 +3513,7 @@ class GTEST_API_ MatchMatrix {
   MatchMatrix(size_t num_elements, size_t num_matchers)
       : num_elements_(num_elements),
         num_matchers_(num_matchers),
-        matched_(num_elements_* num_matchers_, 0) {
-  }
+        matched_(num_elements_ * num_matchers_, 0) {}
 
   size_t LhsSize() const { return num_elements_; }
   size_t RhsSize() const { return num_matchers_; }
@@ -3364,8 +3552,7 @@ typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
 
 // Returns a maximum bipartite matching for the specified graph 'g'.
 // The matching is represented as a vector of {element, matcher} pairs.
-GTEST_API_ ElementMatcherPairs
-FindMaxBipartiteMatching(const MatchMatrix& g);
+GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g);
 
 struct UnorderedMatcherRequire {
   enum Flags {
@@ -3402,9 +3589,7 @@ class GTEST_API_ UnorderedElementsAreMatcherImplBase {
   bool FindPairing(const MatchMatrix& matrix,
                    MatchResultListener* listener) const;
 
-  MatcherDescriberVec& matcher_describers() {
-    return matcher_describers_;
-  }
+  MatcherDescriberVec& matcher_describers() { return matcher_describers_; }
 
   static Message Elements(size_t n) {
     return Message() << n << " element" << (n == 1 ? "" : "s");
@@ -3428,7 +3613,6 @@ class UnorderedElementsAreMatcherImpl
   typedef internal::StlContainerView<RawContainer> View;
   typedef typename View::type StlContainer;
   typedef typename View::const_reference StlContainerReference;
-  typedef typename StlContainer::const_iterator StlContainerConstIterator;
   typedef typename StlContainer::value_type Element;
 
   template <typename InputIter>
@@ -3461,23 +3645,6 @@ class UnorderedElementsAreMatcherImpl
         AnalyzeElements(stl_container.begin(), stl_container.end(),
                         &element_printouts, listener);
 
-    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
-      return true;
-    }
-
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      if (matrix.LhsSize() != matrix.RhsSize()) {
-        // The element count doesn't match.  If the container is empty,
-        // there's no need to explain anything as Google Mock already
-        // prints the empty container. Otherwise we just need to show
-        // how many elements there actually are.
-        if (matrix.LhsSize() != 0 && listener->IsInterested()) {
-          *listener << "which has " << Elements(matrix.LhsSize());
-        }
-        return false;
-      }
-    }
-
     return VerifyMatchMatrix(element_printouts, matrix, listener) &&
            FindPairing(matrix, listener);
   }
@@ -3511,7 +3678,7 @@ class UnorderedElementsAreMatcherImpl
     return matrix;
   }
 
-  ::std::vector<Matcher<const Element&> > matchers_;
+  ::std::vector<Matcher<const Element&>> matchers_;
 };
 
 // Functor for use in TransformTuple.
@@ -3536,7 +3703,7 @@ class UnorderedElementsAreMatcher {
     typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type View;
     typedef typename View::value_type Element;
-    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    typedef ::std::vector<Matcher<const Element&>> MatcherVec;
     MatcherVec matchers;
     matchers.reserve(::std::tuple_size<MatcherTuple>::value);
     TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
@@ -3559,15 +3726,15 @@ class ElementsAreMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    GTEST_COMPILE_ASSERT_(
+    static_assert(
         !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
             ::std::tuple_size<MatcherTuple>::value < 2,
-        use_UnorderedElementsAre_with_hash_tables);
+        "use UnorderedElementsAre with hash tables");
 
     typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type View;
     typedef typename View::value_type Element;
-    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    typedef ::std::vector<Matcher<const Element&>> MatcherVec;
     MatcherVec matchers;
     matchers.reserve(::std::tuple_size<MatcherTuple>::value);
     TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
@@ -3610,9 +3777,9 @@ class ElementsAreArrayMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    GTEST_COMPILE_ASSERT_(
+    static_assert(
         !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
-        use_UnorderedElementsAreArray_with_hash_tables);
+        "use UnorderedElementsAreArray with hash tables");
 
     return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
         matchers_.begin(), matchers_.end()));
@@ -3702,9 +3869,9 @@ BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
 // 'negation' is false; otherwise returns the description of the
 // negation of the matcher.  'param_values' contains a list of strings
 // that are the print-out of the matcher's parameters.
-GTEST_API_ std::string FormatMatcherDescription(bool negation,
-                                                const char* matcher_name,
-                                                const Strings& param_values);
+GTEST_API_ std::string FormatMatcherDescription(
+    bool negation, const char* matcher_name,
+    const std::vector<const char*>& param_names, const Strings& param_values);
 
 // Implements a matcher that checks the value of a optional<> type variable.
 template <typename ValueMatcher>
@@ -3932,7 +4099,12 @@ class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
     const char* sep = "";
     // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
     (void)sep;
-    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
+    // The static_cast to void is needed to silence Clang's -Wcomma warning.
+    // This pattern looks suspiciously like we may have mismatched parentheses
+    // and may have been trying to use the first operation of the comma operator
+    // as a member of the array, so Clang warns that we may have made a mistake.
+    const char* dummy[] = {
+        "", (static_cast<void>(*os << sep << "#" << k), sep = ", ")...};
     (void)dummy;
     *os << ") ";
   }
@@ -3981,26 +4153,26 @@ ElementsAreArray(Iter first, Iter last) {
 }
 
 template <typename T>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T* pointer, size_t count) {
+inline auto ElementsAreArray(const T* pointer, size_t count)
+    -> decltype(ElementsAreArray(pointer, pointer + count)) {
   return ElementsAreArray(pointer, pointer + count);
 }
 
 template <typename T, size_t N>
-inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
-    const T (&array)[N]) {
+inline auto ElementsAreArray(const T (&array)[N])
+    -> decltype(ElementsAreArray(array, N)) {
   return ElementsAreArray(array, N);
 }
 
 template <typename Container>
-inline internal::ElementsAreArrayMatcher<typename Container::value_type>
-ElementsAreArray(const Container& container) {
+inline auto ElementsAreArray(const Container& container)
+    -> decltype(ElementsAreArray(container.begin(), container.end())) {
   return ElementsAreArray(container.begin(), container.end());
 }
 
 template <typename T>
-inline internal::ElementsAreArrayMatcher<T>
-ElementsAreArray(::std::initializer_list<T> xs) {
+inline auto ElementsAreArray(::std::initializer_list<T> xs)
+    -> decltype(ElementsAreArray(xs.begin(), xs.end())) {
   return ElementsAreArray(xs.begin(), xs.end());
 }
 
@@ -4027,14 +4199,14 @@ UnorderedElementsAreArray(Iter first, Iter last) {
 }
 
 template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T* pointer, size_t count) {
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    const T* pointer, size_t count) {
   return UnorderedElementsAreArray(pointer, pointer + count);
 }
 
 template <typename T, size_t N>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(const T (&array)[N]) {
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    const T (&array)[N]) {
   return UnorderedElementsAreArray(array, N);
 }
 
@@ -4046,8 +4218,8 @@ UnorderedElementsAreArray(const Container& container) {
 }
 
 template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T>
-UnorderedElementsAreArray(::std::initializer_list<T> xs) {
+inline internal::UnorderedElementsAreArrayMatcher<T> UnorderedElementsAreArray(
+    ::std::initializer_list<T> xs) {
   return UnorderedElementsAreArray(xs.begin(), xs.end());
 }
 
@@ -4081,14 +4253,14 @@ Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
 }
 
 // Creates a polymorphic matcher that matches any NULL pointer.
-inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
+inline PolymorphicMatcher<internal::IsNullMatcher> IsNull() {
   return MakePolymorphicMatcher(internal::IsNullMatcher());
 }
 
 // Creates a polymorphic matcher that matches any non-NULL pointer.
 // This is convenient as Not(NULL) doesn't compile (the compiler
 // thinks that that expression is comparing a pointer with an integer).
-inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
+inline PolymorphicMatcher<internal::NotNullMatcher> NotNull() {
   return MakePolymorphicMatcher(internal::NotNullMatcher());
 }
 
@@ -4119,8 +4291,8 @@ inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
 // Creates a matcher that matches any double argument approximately equal to
 // rhs, up to the specified max absolute error bound, where two NANs are
 // considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<double> DoubleNear(
-    double rhs, double max_abs_error) {
+inline internal::FloatingEqMatcher<double> DoubleNear(double rhs,
+                                                      double max_abs_error) {
   return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
 }
 
@@ -4147,8 +4319,8 @@ inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
 // Creates a matcher that matches any float argument approximately equal to
 // rhs, up to the specified max absolute error bound, where two NANs are
 // considered unequal.  The max absolute error bound must be non-negative.
-inline internal::FloatingEqMatcher<float> FloatNear(
-    float rhs, float max_abs_error) {
+inline internal::FloatingEqMatcher<float> FloatNear(float rhs,
+                                                    float max_abs_error) {
   return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
 }
 
@@ -4176,7 +4348,7 @@ inline internal::PointeeMatcher<InnerMatcher> Pointee(
 // If To is a reference and the cast fails, this matcher returns false
 // immediately.
 template <typename To>
-inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To>>
 WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
   return MakePolymorphicMatcher(
       internal::WhenDynamicCastToMatcher<To>(inner_matcher));
@@ -4188,12 +4360,10 @@ WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
 //   Field(&Foo::number, Ge(5))
 // matches a Foo object x if and only if x.number >= 5.
 template <typename Class, typename FieldType, typename FieldMatcher>
-inline PolymorphicMatcher<
-  internal::FieldMatcher<Class, FieldType> > Field(
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(
     FieldType Class::*field, const FieldMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::FieldMatcher<Class, FieldType>(
-          field, MatcherCast<const FieldType&>(matcher)));
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
+      field, MatcherCast<const FieldType&>(matcher)));
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   Field(&Foo::bar, m)
@@ -4203,7 +4373,7 @@ inline PolymorphicMatcher<
 // Same as Field() but also takes the name of the field to provide better error
 // messages.
 template <typename Class, typename FieldType, typename FieldMatcher>
-inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType>> Field(
     const std::string& field_name, FieldType Class::*field,
     const FieldMatcher& matcher) {
   return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
@@ -4216,7 +4386,7 @@ inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
 // matches a Foo object x if and only if x.str() starts with "hi".
 template <typename Class, typename PropertyType, typename PropertyMatcher>
 inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const> >
+    Class, PropertyType, PropertyType (Class::*)() const>>
 Property(PropertyType (Class::*property)() const,
          const PropertyMatcher& matcher) {
   return MakePolymorphicMatcher(
@@ -4233,7 +4403,7 @@ Property(PropertyType (Class::*property)() const,
 // better error messages.
 template <typename Class, typename PropertyType, typename PropertyMatcher>
 inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const> >
+    Class, PropertyType, PropertyType (Class::*)() const>>
 Property(const std::string& property_name,
          PropertyType (Class::*property)() const,
          const PropertyMatcher& matcher) {
@@ -4246,8 +4416,8 @@ Property(const std::string& property_name,
 // The same as above but for reference-qualified member functions.
 template <typename Class, typename PropertyType, typename PropertyMatcher>
 inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const &> >
-Property(PropertyType (Class::*property)() const &,
+    Class, PropertyType, PropertyType (Class::*)() const&>>
+Property(PropertyType (Class::*property)() const&,
          const PropertyMatcher& matcher) {
   return MakePolymorphicMatcher(
       internal::PropertyMatcher<Class, PropertyType,
@@ -4258,9 +4428,9 @@ Property(PropertyType (Class::*property)() const &,
 // Three-argument form for reference-qualified member functions.
 template <typename Class, typename PropertyType, typename PropertyMatcher>
 inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const &> >
+    Class, PropertyType, PropertyType (Class::*)() const&>>
 Property(const std::string& property_name,
-         PropertyType (Class::*property)() const &,
+         PropertyType (Class::*property)() const&,
          const PropertyMatcher& matcher) {
   return MakePolymorphicMatcher(
       internal::PropertyMatcher<Class, PropertyType,
@@ -4279,15 +4449,25 @@ Property(const std::string& property_name,
 template <typename Callable, typename InnerMatcher>
 internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
     Callable callable, InnerMatcher matcher) {
+  return internal::ResultOfMatcher<Callable, InnerMatcher>(std::move(callable),
+                                                           std::move(matcher));
+}
+
+// Same as ResultOf() above, but also takes a description of the `callable`
+// result to provide better error messages.
+template <typename Callable, typename InnerMatcher>
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
+    const std::string& result_description, Callable callable,
+    InnerMatcher matcher) {
   return internal::ResultOfMatcher<Callable, InnerMatcher>(
-      std::move(callable), std::move(matcher));
+      result_description, std::move(callable), std::move(matcher));
 }
 
 // String matchers.
 
 // Matches a string equal to str.
 template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrEq(
     const internal::StringLike<T>& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
@@ -4295,7 +4475,7 @@ PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
 
 // Matches a string not equal to str.
 template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrNe(
     const internal::StringLike<T>& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
@@ -4303,7 +4483,7 @@ PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
 
 // Matches a string equal to str, ignoring case.
 template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseEq(
     const internal::StringLike<T>& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
@@ -4311,7 +4491,7 @@ PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
 
 // Matches a string not equal to str, ignoring case.
 template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string>> StrCaseNe(
     const internal::StringLike<T>& str) {
   return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
       std::string(str), false, false));
@@ -4320,7 +4500,7 @@ PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
 // Creates a matcher that matches any string, std::string, or C string
 // that contains the given substring.
 template <typename T = std::string>
-PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
+PolymorphicMatcher<internal::HasSubstrMatcher<std::string>> HasSubstr(
     const internal::StringLike<T>& substring) {
   return MakePolymorphicMatcher(
       internal::HasSubstrMatcher<std::string>(std::string(substring)));
@@ -4328,7 +4508,7 @@ PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
 
 // Matches a string that starts with 'prefix' (case-sensitive).
 template <typename T = std::string>
-PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
+PolymorphicMatcher<internal::StartsWithMatcher<std::string>> StartsWith(
     const internal::StringLike<T>& prefix) {
   return MakePolymorphicMatcher(
       internal::StartsWithMatcher<std::string>(std::string(prefix)));
@@ -4336,7 +4516,7 @@ PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
 
 // Matches a string that ends with 'suffix' (case-sensitive).
 template <typename T = std::string>
-PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
+PolymorphicMatcher<internal::EndsWithMatcher<std::string>> EndsWith(
     const internal::StringLike<T>& suffix) {
   return MakePolymorphicMatcher(
       internal::EndsWithMatcher<std::string>(std::string(suffix)));
@@ -4346,50 +4526,50 @@ PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
 // Wide string matchers.
 
 // Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq(
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrEq(
     const std::wstring& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::wstring>(str, true, true));
 }
 
 // Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe(
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrNe(
     const std::wstring& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::wstring>(str, false, true));
 }
 
 // Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
-StrCaseEq(const std::wstring& str) {
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseEq(
+    const std::wstring& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::wstring>(str, true, false));
 }
 
 // Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
-StrCaseNe(const std::wstring& str) {
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> StrCaseNe(
+    const std::wstring& str) {
   return MakePolymorphicMatcher(
       internal::StrEqualityMatcher<std::wstring>(str, false, false));
 }
 
 // Creates a matcher that matches any ::wstring, std::wstring, or C wide string
 // that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr(
+inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasSubstr(
     const std::wstring& substring) {
   return MakePolymorphicMatcher(
       internal::HasSubstrMatcher<std::wstring>(substring));
 }
 
 // Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
-StartsWith(const std::wstring& prefix) {
+inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> StartsWith(
+    const std::wstring& prefix) {
   return MakePolymorphicMatcher(
       internal::StartsWithMatcher<std::wstring>(prefix));
 }
 
 // Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
+inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsWith(
     const std::wstring& suffix) {
   return MakePolymorphicMatcher(
       internal::EndsWithMatcher<std::wstring>(suffix));
@@ -4484,8 +4664,8 @@ inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
 // predicate.  The predicate can be any unary function or functor
 // whose return type can be implicitly converted to bool.
 template <typename Predicate>
-inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
-Truly(Predicate pred) {
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate>> Truly(
+    Predicate pred) {
   return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
 }
 
@@ -4496,8 +4676,8 @@ Truly(Predicate pred) {
 //   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
 //   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
 template <typename SizeMatcher>
-inline internal::SizeIsMatcher<SizeMatcher>
-SizeIs(const SizeMatcher& size_matcher) {
+inline internal::SizeIsMatcher<SizeMatcher> SizeIs(
+    const SizeMatcher& size_matcher) {
   return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
 }
 
@@ -4507,8 +4687,8 @@ SizeIs(const SizeMatcher& size_matcher) {
 // do not implement size(). The container must provide const_iterator (with
 // valid iterator_traits), begin() and end().
 template <typename DistanceMatcher>
-inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
-BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher> BeginEndDistanceIs(
+    const DistanceMatcher& distance_matcher) {
   return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
 }
 
@@ -4517,8 +4697,8 @@ BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
 // values that are included in one container but not the other. (Duplicate
 // values and order differences are not explained.)
 template <typename Container>
-inline PolymorphicMatcher<internal::ContainerEqMatcher<
-    typename std::remove_const<Container>::type>>
+inline PolymorphicMatcher<
+    internal::ContainerEqMatcher<typename std::remove_const<Container>::type>>
 ContainerEq(const Container& rhs) {
   return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
 }
@@ -4526,9 +4706,8 @@ ContainerEq(const Container& rhs) {
 // Returns a matcher that matches a container that, when sorted using
 // the given comparator, matches container_matcher.
 template <typename Comparator, typename ContainerMatcher>
-inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
-WhenSortedBy(const Comparator& comparator,
-             const ContainerMatcher& container_matcher) {
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher> WhenSortedBy(
+    const Comparator& comparator, const ContainerMatcher& container_matcher) {
   return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
       comparator, container_matcher);
 }
@@ -4538,9 +4717,9 @@ WhenSortedBy(const Comparator& comparator,
 template <typename ContainerMatcher>
 inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
 WhenSorted(const ContainerMatcher& container_matcher) {
-  return
-      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
-          internal::LessComparator(), container_matcher);
+  return internal::WhenSortedByMatcher<internal::LessComparator,
+                                       ContainerMatcher>(
+      internal::LessComparator(), container_matcher);
 }
 
 // Matches an STL-style container or a native array that contains the
@@ -4557,15 +4736,13 @@ Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
                                                              rhs);
 }
 
-
 // Supports the Pointwise(m, {a, b, c}) syntax.
 template <typename TupleMatcher, typename T>
-inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
+inline internal::PointwiseMatcher<TupleMatcher, std::vector<T>> Pointwise(
     const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
   return Pointwise(tuple_matcher, std::vector<T>(rhs));
 }
 
-
 // UnorderedPointwise(pair_matcher, rhs) matches an STL-style
 // container or a native array that contains the same number of
 // elements as in rhs, where in some permutation of the container, its
@@ -4594,28 +4771,25 @@ UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
       RhsView::ConstReference(rhs_container);
 
   // Create a matcher for each element in rhs_container.
-  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
-  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
-       it != rhs_stl_container.end(); ++it) {
-    matchers.push_back(
-        internal::MatcherBindSecond(tuple2_matcher, *it));
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second>> matchers;
+  for (auto it = rhs_stl_container.begin(); it != rhs_stl_container.end();
+       ++it) {
+    matchers.push_back(internal::MatcherBindSecond(tuple2_matcher, *it));
   }
 
   // Delegate the work to UnorderedElementsAreArray().
   return UnorderedElementsAreArray(matchers);
 }
 
-
 // Supports the UnorderedPointwise(m, {a, b, c}) syntax.
 template <typename Tuple2Matcher, typename T>
 inline internal::UnorderedElementsAreArrayMatcher<
-    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T>>
 UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
                    std::initializer_list<T> rhs) {
   return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
 }
 
-
 // Matches an STL-style container or a native array that contains at
 // least one element matching the given value or matcher.
 //
@@ -4625,7 +4799,7 @@ UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
 //   page_ids.insert(1);
 //   EXPECT_THAT(page_ids, Contains(1));
 //   EXPECT_THAT(page_ids, Contains(Gt(2)));
-//   EXPECT_THAT(page_ids, Not(Contains(4)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));  // See below for Times(0)
 //
 //   ::std::map<int, size_t> page_lengths;
 //   page_lengths[1] = 100;
@@ -4634,6 +4808,19 @@ UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
 //
 //   const char* user_ids[] = { "joe", "mike", "tom" };
 //   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+//
+// The matcher supports a modifier `Times` that allows to check for arbitrary
+// occurrences including testing for absence with Times(0).
+//
+// Examples:
+//   ::std::vector<int> ids;
+//   ids.insert(1);
+//   ids.insert(1);
+//   ids.insert(3);
+//   EXPECT_THAT(ids, Contains(1).Times(2));      // 1 occurs 2 times
+//   EXPECT_THAT(ids, Contains(2).Times(0));      // 2 is not present
+//   EXPECT_THAT(ids, Contains(3).Times(Ge(1)));  // 3 occurs at least once
+
 template <typename M>
 inline internal::ContainsMatcher<M> Contains(M matcher) {
   return internal::ContainsMatcher<M>(matcher);
@@ -4760,7 +4947,7 @@ inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
 // Matches an STL-style container or a native array that contains only
 // elements matching the given value or matcher.
 //
-// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
+// Each(m) is semantically equivalent to `Not(Contains(Not(m)))`. Only
 // the messages are different.
 //
 // Examples:
@@ -4803,13 +4990,25 @@ inline internal::KeyMatcher<M> Key(M inner_matcher) {
 // to match a std::map<int, string> that contains exactly one element whose key
 // is >= 5 and whose value equals "foo".
 template <typename FirstMatcher, typename SecondMatcher>
-inline internal::PairMatcher<FirstMatcher, SecondMatcher>
-Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
-  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
-      first_matcher, second_matcher);
+inline internal::PairMatcher<FirstMatcher, SecondMatcher> Pair(
+    FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(first_matcher,
+                                                            second_matcher);
 }
 
 namespace no_adl {
+// Conditional() creates a matcher that conditionally uses either the first or
+// second matcher provided. For example, we could create an `equal if, and only
+// if' matcher using the Conditional wrapper as follows:
+//
+//   EXPECT_THAT(result, Conditional(condition, Eq(expected), Ne(expected)));
+template <typename MatcherTrue, typename MatcherFalse>
+internal::ConditionalMatcher<MatcherTrue, MatcherFalse> Conditional(
+    bool condition, MatcherTrue matcher_true, MatcherFalse matcher_false) {
+  return internal::ConditionalMatcher<MatcherTrue, MatcherFalse>(
+      condition, std::move(matcher_true), std::move(matcher_false));
+}
+
 // FieldsAre(matchers...) matches piecewise the fields of compatible structs.
 // These include those that support `get<I>(obj)`, and when structured bindings
 // are enabled any class that supports them.
@@ -4836,6 +5035,14 @@ inline internal::AddressMatcher<InnerMatcher> Address(
     const InnerMatcher& inner_matcher) {
   return internal::AddressMatcher<InnerMatcher>(inner_matcher);
 }
+
+// Matches a base64 escaped string, when the unescaped string matches the
+// internal matcher.
+template <typename MatcherType>
+internal::WhenBase64UnescapedMatcher WhenBase64Unescaped(
+    const MatcherType& internal_matcher) {
+  return internal::WhenBase64UnescapedMatcher(internal_matcher);
+}
 }  // namespace no_adl
 
 // Returns a predicate that is satisfied by anything that matches the
@@ -4854,8 +5061,8 @@ inline bool Value(const T& value, M matcher) {
 // Matches the value against the given matcher and explains the match
 // result to listener.
 template <typename T, typename M>
-inline bool ExplainMatchResult(
-    M matcher, const T& value, MatchResultListener* listener) {
+inline bool ExplainMatchResult(M matcher, const T& value,
+                               MatchResultListener* listener) {
   return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
 }
 
@@ -4865,7 +5072,8 @@ inline bool ExplainMatchResult(
 //
 // MATCHER_P(XAndYThat, matcher,
 //           "X that " + DescribeMatcher<int>(matcher, negation) +
-//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
+//               (negation ? " or" : " and") + " Y that " +
+//               DescribeMatcher<double>(matcher, negation)) {
 //   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
 //          ExplainMatchResult(matcher, arg.y(), result_listener);
 // }
@@ -5014,7 +5222,9 @@ internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
 //
 //   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
 template <typename InnerMatcher>
-inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) {
+  return matcher;
+}
 
 // Returns a matcher that matches the value of an optional<> type variable.
 // The matcher implementation only uses '!arg' and requires that the optional<>
@@ -5032,7 +5242,7 @@ inline internal::OptionalMatcher<ValueMatcher> Optional(
 
 // Returns a matcher that matches the value of a absl::any type variable.
 template <typename T>
-PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
+PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T>> AnyWith(
     const Matcher<const T&>& matcher) {
   return MakePolymorphicMatcher(
       internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
@@ -5043,7 +5253,7 @@ PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
 // functions.
 // It is compatible with std::variant.
 template <typename T>
-PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith(
+PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T>> VariantWith(
     const Matcher<const T&>& matcher) {
   return MakePolymorphicMatcher(
       internal::variant_matcher::VariantMatcher<T>(matcher));
@@ -5072,7 +5282,8 @@ class WithWhatMatcherImpl {
 
   template <typename Err>
   bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
-    *listener << "which contains .what() that ";
+    *listener << "which contains .what() (of value = " << err.what()
+              << ") that ";
     return matcher_.MatchAndExplain(err.what(), listener);
   }
 
@@ -5222,12 +5433,14 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
 // tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
 // succeed if and only if the value matches the matcher.  If the assertion
 // fails, the value and the description of the matcher will be printed.
-#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
-    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
-#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
-    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
-
-// MATCHER* macroses itself are listed below.
+#define ASSERT_THAT(value, matcher) \
+  ASSERT_PRED_FORMAT1(              \
+      ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+#define EXPECT_THAT(value, matcher) \
+  EXPECT_PRED_FORMAT1(              \
+      ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+
+// MATCHER* macros itself are listed below.
 #define MATCHER(name, description)                                             \
   class name##Matcher                                                          \
       : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
@@ -5248,16 +5461,23 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
                                                                                \
      private:                                                                  \
       ::std::string FormatDescription(bool negation) const {                   \
+        /* NOLINTNEXTLINE readability-redundant-string-init */                 \
         ::std::string gmock_description = (description);                       \
         if (!gmock_description.empty()) {                                      \
           return gmock_description;                                            \
         }                                                                      \
         return ::testing::internal::FormatMatcherDescription(negation, #name,  \
-                                                             {});              \
+                                                             {}, {});          \
       }                                                                        \
     };                                                                         \
   };                                                                           \
-  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \
+  inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH()                           \
+      GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function")               \
+          GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function")    \
+              name                                                             \
+              GMOCK_INTERNAL_WARNING_POP()() {                                 \
+    return {};                                                                 \
+  }                                                                            \
   template <typename arg_type>                                                 \
   bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
       const arg_type& arg,                                                     \
@@ -5265,33 +5485,41 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
       const
 
 #define MATCHER_P(name, p0, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0))
-#define MATCHER_P2(name, p0, p1, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1))
-#define MATCHER_P3(name, p0, p1, p2, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2))
-#define MATCHER_P4(name, p0, p1, p2, p3, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3))
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0))
+#define MATCHER_P2(name, p0, p1, description)                            \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (#p0, #p1), \
+                         (p0, p1))
+#define MATCHER_P3(name, p0, p1, p2, description)                             \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (#p0, #p1, #p2), \
+                         (p0, p1, p2))
+#define MATCHER_P4(name, p0, p1, p2, p3, description)        \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, \
+                         (#p0, #p1, #p2, #p3), (p0, p1, p2, p3))
 #define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
-                         (p0, p1, p2, p3, p4))
+                         (#p0, #p1, #p2, #p3, #p4), (p0, p1, p2, p3, p4))
 #define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
+                         (#p0, #p1, #p2, #p3, #p4, #p5),      \
                          (p0, p1, p2, p3, p4, p5))
 #define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6),     \
                          (p0, p1, p2, p3, p4, p5, p6))
 #define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7),    \
                          (p0, p1, p2, p3, p4, p5, p6, p7))
 #define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8),   \
                          (p0, p1, p2, p3, p4, p5, p6, p7, p8))
 #define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
   GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
+                         (#p0, #p1, #p2, #p3, #p4, #p5, #p6, #p7, #p8, #p9),   \
                          (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
 
-#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \
+#define GMOCK_INTERNAL_MATCHER(name, full_name, description, arg_names, args)  \
   template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
   class full_name : public ::testing::internal::MatcherBaseImpl<               \
                         full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
@@ -5320,7 +5548,7 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
           return gmock_description;                                            \
         }                                                                      \
         return ::testing::internal::FormatMatcherDescription(                  \
-            negation, #name,                                                   \
+            negation, #name, {GMOCK_PP_REMOVE_PARENS(arg_names)},              \
             ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
                 ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
                     GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
diff --git a/googletest/googlemock/include/gmock/gmock-more-actions.h b/googletest/googlemock/include/gmock/gmock-more-actions.h
index fd293358a28ef3643ef8224d3a7bd47213eee3cf..148ac017210cecce46d789219267360f6989e1aa 100644
--- a/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ b/googletest/googlemock/include/gmock/gmock-more-actions.h
@@ -27,12 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements some commonly used variadic actions.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
@@ -129,170 +129,207 @@
 
 // Declares the template parameters.
 #define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
-#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) kind0 name0, kind1 name1
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, name1) \
+  kind0 name0, kind1 name1
 #define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) kind0 name0, kind1 name1, kind2 name2
+                                                  kind2, name2)               \
+  kind0 name0, kind1 name1, kind2 name2
 #define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3
-#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
-    kind2 name2, kind3 name3, kind4 name4
+                                                  kind2, name2, kind3, name3) \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4) \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4
 #define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
-#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
-    kind5 name5, kind6 name6
-#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
-    kind4 name4, kind5 name5, kind6 name6, kind7 name7
-#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
-    kind8 name8
-#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
-    kind6 name6, kind7 name7, kind8 name8, kind9 name9
+                                                  kind2, name2, kind3, name3, \
+                                                  kind4, name4, kind5, name5) \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6)                                           \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4,        \
+      kind5 name5, kind6 name6
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7)                             \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4,        \
+      kind5 name5, kind6 name6, kind7 name7
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7, kind8, name8)               \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4,        \
+      kind5 name5, kind6 name6, kind7 name7, kind8 name8
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(                       \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7, kind8, name8, kind9, name9) \
+  kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4,        \
+      kind5 name5, kind6 name6, kind7 name7, kind8 name8, kind9 name9
 
 // Lists the template parameters.
 #define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
-#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) name0, name1
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, name1) \
+  name0, name1
 #define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) name0, name1, name2
+                                                  kind2, name2)               \
+  name0, name1, name2
 #define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) name0, name1, name2, name3
-#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
-    name4
+                                                  kind2, name2, kind3, name3) \
+  name0, name1, name2, name3
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4) \
+  name0, name1, name2, name3, name4
 #define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
-    name2, name3, name4, name5
-#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) name0, name1, name2, name3, name4, name5, name6
-#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
-#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
-    name6, name7, name8
-#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
-    name3, name4, name5, name6, name7, name8, name9
+                                                  kind2, name2, kind3, name3, \
+                                                  kind4, name4, kind5, name5) \
+  name0, name1, name2, name3, name4, name5
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6)                                           \
+  name0, name1, name2, name3, name4, name5, name6
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7)                             \
+  name0, name1, name2, name3, name4, name5, name6, name7
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(                        \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7, kind8, name8)               \
+  name0, name1, name2, name3, name4, name5, name6, name7, name8
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(                       \
+    kind0, name0, kind1, name1, kind2, name2, kind3, name3, kind4, name4, \
+    kind5, name5, kind6, name6, kind7, name7, kind8, name8, kind9, name9) \
+  name0, name1, name2, name3, name4, name5, name6, name7, name8, name9
 
 // Declares the types of value parameters.
 #define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
 #define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
-    typename p0##_type, typename p1##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
-    typename p0##_type, typename p1##_type, typename p2##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) \
+  , typename p0##_type, typename p1##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) \
+  , typename p0##_type, typename p1##_type, typename p2##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \
+  , typename p0##_type, typename p1##_type, typename p2##_type,     \
+      typename p3##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  , typename p0##_type, typename p1##_type, typename p2##_type,         \
+      typename p3##_type, typename p4##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \
+  , typename p0##_type, typename p1##_type, typename p2##_type,             \
+      typename p3##_type, typename p4##_type, typename p5##_type
 #define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type
+                                                    p6)                     \
+  , typename p0##_type, typename p1##_type, typename p2##_type,             \
+      typename p3##_type, typename p4##_type, typename p5##_type,           \
+      typename p6##_type
 #define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type
+                                                    p6, p7)                 \
+  , typename p0##_type, typename p1##_type, typename p2##_type,             \
+      typename p3##_type, typename p4##_type, typename p5##_type,           \
+      typename p6##_type, typename p7##_type
 #define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type, typename p8##_type
+                                                    p6, p7, p8)             \
+  , typename p0##_type, typename p1##_type, typename p2##_type,             \
+      typename p3##_type, typename p4##_type, typename p5##_type,           \
+      typename p6##_type, typename p7##_type, typename p8##_type
 #define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
-    typename p2##_type, typename p3##_type, typename p4##_type, \
-    typename p5##_type, typename p6##_type, typename p7##_type, \
-    typename p8##_type, typename p9##_type
+                                                     p6, p7, p8, p9)         \
+  , typename p0##_type, typename p1##_type, typename p2##_type,              \
+      typename p3##_type, typename p4##_type, typename p5##_type,            \
+      typename p6##_type, typename p7##_type, typename p8##_type,            \
+      typename p9##_type
 
 // Initializes the value parameters.
-#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
-    ()
-#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
-    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
-#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
-    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1))
-#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
-#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS() ()
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0) \
+  (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1) \
+  (p0##_type gmock_p0, p1##_type gmock_p1)             \
+      : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1))
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)     \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2) \
+      : p0(::std::move(gmock_p0)),                             \
+        p1(::std::move(gmock_p1)),                             \
+        p2(::std::move(gmock_p2))
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+   p3##_type gmock_p3)                                         \
+      : p0(::std::move(gmock_p0)),                             \
+        p1(::std::move(gmock_p1)),                             \
+        p2(::std::move(gmock_p2)),                             \
         p3(::std::move(gmock_p3))
-#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
-#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,     \
+   p3##_type gmock_p3, p4##_type gmock_p4)                         \
+      : p0(::std::move(gmock_p0)),                                 \
+        p1(::std::move(gmock_p1)),                                 \
+        p2(::std::move(gmock_p2)),                                 \
+        p3(::std::move(gmock_p3)),                                 \
+        p4(::std::move(gmock_p4))
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,         \
+   p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)         \
+      : p0(::std::move(gmock_p0)),                                     \
+        p1(::std::move(gmock_p1)),                                     \
+        p2(::std::move(gmock_p2)),                                     \
+        p3(::std::move(gmock_p3)),                                     \
+        p4(::std::move(gmock_p4)),                                     \
         p5(::std::move(gmock_p5))
-#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
-#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,             \
+   p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5,             \
+   p6##_type gmock_p6)                                                     \
+      : p0(::std::move(gmock_p0)),                                         \
+        p1(::std::move(gmock_p1)),                                         \
+        p2(::std::move(gmock_p2)),                                         \
+        p3(::std::move(gmock_p3)),                                         \
+        p4(::std::move(gmock_p4)),                                         \
+        p5(::std::move(gmock_p5)),                                         \
+        p6(::std::move(gmock_p6))
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,                 \
+   p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5,                 \
+   p6##_type gmock_p6, p7##_type gmock_p7)                                     \
+      : p0(::std::move(gmock_p0)),                                             \
+        p1(::std::move(gmock_p1)),                                             \
+        p2(::std::move(gmock_p2)),                                             \
+        p3(::std::move(gmock_p3)),                                             \
+        p4(::std::move(gmock_p4)),                                             \
+        p5(::std::move(gmock_p5)),                                             \
+        p6(::std::move(gmock_p6)),                                             \
         p7(::std::move(gmock_p7))
-#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
-        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \
+                                               p8)                             \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,                 \
+   p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5,                 \
+   p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)                 \
+      : p0(::std::move(gmock_p0)),                                             \
+        p1(::std::move(gmock_p1)),                                             \
+        p2(::std::move(gmock_p2)),                                             \
+        p3(::std::move(gmock_p3)),                                             \
+        p4(::std::move(gmock_p4)),                                             \
+        p5(::std::move(gmock_p5)),                                             \
+        p6(::std::move(gmock_p6)),                                             \
+        p7(::std::move(gmock_p7)),                                             \
+        p8(::std::move(gmock_p8))
 #define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
-        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
-        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
+                                                p7, p8, p9)                 \
+  (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2,              \
+   p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5,              \
+   p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8,              \
+   p9##_type gmock_p9)                                                      \
+      : p0(::std::move(gmock_p0)),                                          \
+        p1(::std::move(gmock_p1)),                                          \
+        p2(::std::move(gmock_p2)),                                          \
+        p3(::std::move(gmock_p3)),                                          \
+        p4(::std::move(gmock_p4)),                                          \
+        p5(::std::move(gmock_p5)),                                          \
+        p6(::std::move(gmock_p6)),                                          \
+        p7(::std::move(gmock_p7)),                                          \
+        p8(::std::move(gmock_p8)),                                          \
         p9(::std::move(gmock_p9))
 
 // Defines the copy constructor
 #define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
-    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
+  {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
 #define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
 #define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
 #define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
@@ -307,30 +344,71 @@
 // Declares the fields for storing the value parameters.
 #define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
 #define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
-#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
-    p1##_type p1;
-#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
-    p1##_type p1; p2##_type p2;
-#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
-    p1##_type p1; p2##_type p2; p3##_type p3;
-#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
-#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5;
-#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6;
-#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6; p7##_type p7;
-#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) \
+  p0##_type p0;                                        \
+  p1##_type p1;
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) \
+  p0##_type p0;                                            \
+  p1##_type p1;                                            \
+  p2##_type p2;
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \
+  p0##_type p0;                                                \
+  p1##_type p1;                                                \
+  p2##_type p2;                                                \
+  p3##_type p3;
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  p0##_type p0;                                                    \
+  p1##_type p1;                                                    \
+  p2##_type p2;                                                    \
+  p3##_type p3;                                                    \
+  p4##_type p4;
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \
+  p0##_type p0;                                                        \
+  p1##_type p1;                                                        \
+  p2##_type p2;                                                        \
+  p3##_type p3;                                                        \
+  p4##_type p4;                                                        \
+  p5##_type p5;
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \
+  p0##_type p0;                                                            \
+  p1##_type p1;                                                            \
+  p2##_type p2;                                                            \
+  p3##_type p3;                                                            \
+  p4##_type p4;                                                            \
+  p5##_type p5;                                                            \
+  p6##_type p6;
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \
+  p0##_type p0;                                                                \
+  p1##_type p1;                                                                \
+  p2##_type p2;                                                                \
+  p3##_type p3;                                                                \
+  p4##_type p4;                                                                \
+  p5##_type p5;                                                                \
+  p6##_type p6;                                                                \
+  p7##_type p7;
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \
+                                               p8)                             \
+  p0##_type p0;                                                                \
+  p1##_type p1;                                                                \
+  p2##_type p2;                                                                \
+  p3##_type p3;                                                                \
+  p4##_type p4;                                                                \
+  p5##_type p5;                                                                \
+  p6##_type p6;                                                                \
+  p7##_type p7;                                                                \
+  p8##_type p8;
 #define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
-    p9##_type p9;
+                                                p7, p8, p9)                 \
+  p0##_type p0;                                                             \
+  p1##_type p1;                                                             \
+  p2##_type p2;                                                             \
+  p3##_type p3;                                                             \
+  p4##_type p4;                                                             \
+  p5##_type p5;                                                             \
+  p6##_type p6;                                                             \
+  p7##_type p7;                                                             \
+  p8##_type p8;                                                             \
+  p9##_type p9;
 
 // Lists the value parameters.
 #define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
@@ -338,72 +416,78 @@
 #define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
 #define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
 #define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
-#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
-    p2, p3, p4
-#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
-    p1, p2, p3, p4, p5
-#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0, p1, p2, p3, p4, p5, p6
-#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0, p1, p2, p3, p4, p5, p6, p7
-#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  p0, p1, p2, p3, p4
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \
+  p0, p1, p2, p3, p4, p5
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \
+  p0, p1, p2, p3, p4, p5, p6
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \
+  p0, p1, p2, p3, p4, p5, p6, p7
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \
+                                               p8)                             \
+  p0, p1, p2, p3, p4, p5, p6, p7, p8
 #define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
+                                                p7, p8, p9)                 \
+  p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
 
 // Lists the value parameter types.
 #define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
 #define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
-    p1##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
-    p1##_type, p2##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    p0##_type, p1##_type, p2##_type, p3##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) \
+  , p0##_type, p1##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) \
+  , p0##_type, p1##_type, p2##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \
+  , p0##_type, p1##_type, p2##_type, p3##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
 #define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
-    p6##_type
+                                                    p6)                     \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type
 #define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type
+                                                    p6, p7)                 \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type,       \
+      p6##_type, p7##_type
 #define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type
+                                                    p6, p7, p8)             \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type,       \
+      p6##_type, p7##_type, p8##_type
 #define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
+                                                     p6, p7, p8, p9)         \
+  , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type,        \
+      p6##_type, p7##_type, p8##_type, p9##_type
 
 // Declares the value parameters.
 #define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
 #define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
-#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
-    p1##_type p1
-#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
-    p1##_type p1, p2##_type p2
-#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
-    p1##_type p1, p2##_type p2, p3##_type p3
-#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
-#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5
-#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6
-#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6, p7##_type p7
-#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) \
+  p0##_type p0, p1##_type p1
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) \
+  p0##_type p0, p1##_type p1, p2##_type p2
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)  \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+      p5##_type p5
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4,    \
+      p5##_type p5, p6##_type p6
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7) \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4,        \
+      p5##_type p5, p6##_type p6, p7##_type p7
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, \
+                                               p8)                             \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4,        \
+      p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
 #define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
-    p9##_type p9
+                                                p7, p8, p9)                 \
+  p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4,     \
+      p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, p9##_type p9
 
 // The suffix of the class template implementing the action template.
 #define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
@@ -415,40 +499,43 @@
 #define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
 #define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
 #define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) P8
+                                                p7)                         \
+  P8
 #define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) P9
+                                                p7, p8)                     \
+  P9
 #define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) P10
+                                                 p7, p8, p9)                 \
+  P10
 
 // The name of the class template implementing the action template.
-#define GMOCK_ACTION_CLASS_(name, value_params)\
-    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
+#define GMOCK_ACTION_CLASS_(name, value_params) \
+  GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
 
 #define ACTION_TEMPLATE(name, template_params, value_params)                   \
   template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
   class GMOCK_ACTION_CLASS_(name, value_params) {                              \
    public:                                                                     \
     explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
         GMOCK_INTERNAL_DECL_##value_params)                                    \
         GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
-                    = default; ,                                               \
+                    = default;                                                 \
+                    ,                                                          \
                     : impl_(std::make_shared<gmock_Impl>(                      \
-                                GMOCK_INTERNAL_LIST_##value_params)) { })      \
-    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
-        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
-        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
-    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
-        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
-        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
-    template <typename F>                                                      \
-    operator ::testing::Action<F>() const {                                    \
+                        GMOCK_INTERNAL_LIST_##value_params)){})                \
+            GMOCK_ACTION_CLASS_(name, value_params)(const GMOCK_ACTION_CLASS_( \
+                name, value_params) &) noexcept GMOCK_INTERNAL_DEFN_COPY_      \
+        ##value_params GMOCK_ACTION_CLASS_(name, value_params)(                \
+            GMOCK_ACTION_CLASS_(name, value_params) &&) noexcept               \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params template <typename F>          \
+        operator ::testing::Action<F>() const {                                \
       return GMOCK_PP_IF(                                                      \
           GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
-                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
-                      (::testing::internal::MakeAction<F>(impl_)));            \
+          (::testing::internal::MakeAction<F, gmock_Impl>()),                  \
+          (::testing::internal::MakeAction<F>(impl_)));                        \
     }                                                                          \
+                                                                               \
    private:                                                                    \
     class gmock_Impl {                                                         \
      public:                                                                   \
@@ -458,34 +545,35 @@
       return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
       GMOCK_INTERNAL_DEFN_##value_params                                       \
     };                                                                         \
-    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
-                , std::shared_ptr<const gmock_Impl> impl_;)                    \
+    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), ,      \
+                std::shared_ptr<const gmock_Impl> impl_;)                      \
   };                                                                           \
   template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  GMOCK_ACTION_CLASS_(name, value_params)<                                     \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
-          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \
+                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
+  GMOCK_ACTION_CLASS_(                                                         \
+      name, value_params)<GMOCK_INTERNAL_LIST_##template_params                \
+                              GMOCK_INTERNAL_LIST_TYPE_##value_params>         \
+      name(GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;         \
   template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
-          GMOCK_INTERNAL_DECL_##value_params) {                                \
-    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
-        GMOCK_INTERNAL_LIST_##template_params                                  \
-        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
-            GMOCK_INTERNAL_LIST_##value_params);                               \
+                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
+  inline GMOCK_ACTION_CLASS_(                                                  \
+      name, value_params)<GMOCK_INTERNAL_LIST_##template_params                \
+                              GMOCK_INTERNAL_LIST_TYPE_##value_params>         \
+  name(GMOCK_INTERNAL_DECL_##value_params) {                                   \
+    return GMOCK_ACTION_CLASS_(                                                \
+        name, value_params)<GMOCK_INTERNAL_LIST_##template_params              \
+                                GMOCK_INTERNAL_LIST_TYPE_##value_params>(      \
+        GMOCK_INTERNAL_LIST_##value_params);                                   \
   }                                                                            \
   template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
   template <typename function_type, typename return_type, typename args_type,  \
             GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
-  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+  return_type GMOCK_ACTION_CLASS_(                                             \
+      name, value_params)<GMOCK_INTERNAL_LIST_##template_params                \
+                              GMOCK_INTERNAL_LIST_TYPE_##value_params>::       \
+      gmock_Impl::gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_)  \
+          const
 
 namespace testing {
 
@@ -495,8 +583,8 @@ namespace testing {
 // is expanded and macro expansion cannot contain #pragma.  Therefore
 // we suppress them here.
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #endif
 
 namespace internal {
@@ -512,7 +600,8 @@ auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
 
 template <std::size_t index, typename... Params>
 struct InvokeArgumentAction {
-  template <typename... Args>
+  template <typename... Args,
+            typename = typename std::enable_if<(index < sizeof...(Args))>::type>
   auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
       std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
       std::declval<const Params&>()...)) {
@@ -565,7 +654,7 @@ InvokeArgument(Params&&... params) {
 }
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 }  // namespace testing
diff --git a/googletest/googlemock/include/gmock/gmock-more-matchers.h b/googletest/googlemock/include/gmock/gmock-more-matchers.h
index dfc77e359c726bd771c18ba2d98454ac3d35dd13..d9a92107380fb8a981805d30c0a922f6ad7fbd2f 100644
--- a/googletest/googlemock/include/gmock/gmock-more-matchers.h
+++ b/googletest/googlemock/include/gmock/gmock-more-matchers.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements some matchers that depend on gmock-matchers.h.
@@ -35,11 +34,15 @@
 // Note that tests are implemented in gmock-matchers_test.cc rather than
 // gmock-more-matchers-test.cc.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
 
+#include <ostream>
+#include <string>
+
 #include "gmock/gmock-matchers.h"
 
 namespace testing {
@@ -47,23 +50,51 @@ namespace testing {
 // Silence C4100 (unreferenced formal
 // parameter) for MSVC
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #if (_MSC_VER == 1900)
 // and silence C4800 (C4800: 'int *const ': forcing value
 // to bool 'true' or 'false') for MSVC 14
-# pragma warning(disable:4800)
-  #endif
+#pragma warning(disable : 4800)
+#endif
 #endif
 
-// Defines a matcher that matches an empty container. The container must
-// support both size() and empty(), which all STL-like containers provide.
-MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
-  if (arg.empty()) {
-    return true;
+namespace internal {
+
+// Implements the polymorphic IsEmpty matcher, which
+// can be used as a Matcher<T> as long as T is either a container that defines
+// empty() and size() (e.g. std::vector or std::string), or a C-style string.
+class IsEmptyMatcher {
+ public:
+  // Matches anything that defines empty() and size().
+  template <typename MatcheeContainerType>
+  bool MatchAndExplain(const MatcheeContainerType& c,
+                       MatchResultListener* listener) const {
+    if (c.empty()) {
+      return true;
+    }
+    *listener << "whose size is " << c.size();
+    return false;
+  }
+
+  // Matches C-style strings.
+  bool MatchAndExplain(const char* s, MatchResultListener* listener) const {
+    return MatchAndExplain(std::string(s), listener);
   }
-  *result_listener << "whose size is " << arg.size();
-  return false;
+
+  // Describes what this matcher matches.
+  void DescribeTo(std::ostream* os) const { *os << "is empty"; }
+
+  void DescribeNegationTo(std::ostream* os) const { *os << "isn't empty"; }
+};
+
+}  // namespace internal
+
+// Creates a polymorphic matcher that matches an empty container or C-style
+// string. The container must support both size() and empty(), which all
+// STL-like containers provide.
+inline PolymorphicMatcher<internal::IsEmptyMatcher> IsEmpty() {
+  return MakePolymorphicMatcher(internal::IsEmptyMatcher());
 }
 
 // Define a matcher that matches a value that evaluates in boolean
@@ -83,10 +114,9 @@ MATCHER(IsFalse, negation ? "is true" : "is false") {
 }
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-
 }  // namespace testing
 
 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/googletest/googlemock/include/gmock/gmock-nice-strict.h b/googletest/googlemock/include/gmock/gmock-nice-strict.h
index b03b770c757af1bc4c1099f544d984a4e8fdbc14..4f0eb35db72ada705bee4b6ac19926f0598003c1 100644
--- a/googletest/googlemock/include/gmock/gmock-nice-strict.h
+++ b/googletest/googlemock/include/gmock/gmock-nice-strict.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Implements class templates NiceMock, NaggyMock, and StrictMock.
 //
 // Given a mock class MockFoo that is created using Google Mock,
@@ -58,11 +57,13 @@
 // In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
 // supported.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
 
+#include <cstdint>
 #include <type_traits>
 
 #include "gmock/gmock-spec-builders.h"
@@ -109,25 +110,37 @@ constexpr bool HasStrictnessModifier() {
 template <typename Base>
 class NiceMockImpl {
  public:
-  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
+  NiceMockImpl() {
+    ::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this));
+  }
 
-  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+  ~NiceMockImpl() {
+    ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
+  }
 };
 
 template <typename Base>
 class NaggyMockImpl {
  public:
-  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
+  NaggyMockImpl() {
+    ::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this));
+  }
 
-  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+  ~NaggyMockImpl() {
+    ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
+  }
 };
 
 template <typename Base>
 class StrictMockImpl {
  public:
-  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
+  StrictMockImpl() {
+    ::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this));
+  }
 
-  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+  ~StrictMockImpl() {
+    ::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
+  }
 };
 
 }  // namespace internal
@@ -169,7 +182,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
   }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+  NiceMock(const NiceMock&) = delete;
+  NiceMock& operator=(const NiceMock&) = delete;
 };
 
 template <class MockClass>
@@ -210,7 +224,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
   }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+  NaggyMock(const NaggyMock&) = delete;
+  NaggyMock& operator=(const NaggyMock&) = delete;
 };
 
 template <class MockClass>
@@ -251,7 +266,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
   }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+  StrictMock(const StrictMock&) = delete;
+  StrictMock& operator=(const StrictMock&) = delete;
 };
 
 #undef GTEST_INTERNAL_EMPTY_BASE_CLASS
diff --git a/googletest/googlemock/include/gmock/gmock-spec-builders.h b/googletest/googlemock/include/gmock/gmock-spec-builders.h
index 41323c1cc03c298a7d9ba6101efa6476e2ef5dac..4e498d8f54f272b2d50de534a7b320a2cc369dbc 100644
--- a/googletest/googlemock/include/gmock/gmock-spec-builders.h
+++ b/googletest/googlemock/include/gmock/gmock-spec-builders.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements the ON_CALL() and EXPECT_CALL() macros.
@@ -56,20 +55,24 @@
 // where all clauses are optional, and .InSequence()/.After()/
 // .WillOnce() can appear any number of times.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
 
+#include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
+#include <ostream>
 #include <set>
 #include <sstream>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
+
 #include "gmock/gmock-actions.h"
 #include "gmock/gmock-cardinalities.h"
 #include "gmock/gmock-matchers.h"
@@ -78,7 +81,7 @@
 #include "gtest/gtest.h"
 
 #if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>  // NOLINT
+#include <stdexcept>  // NOLINT
 #endif
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
@@ -97,13 +100,15 @@ class ExpectationSet;
 namespace internal {
 
 // Implements a mock function.
-template <typename F> class FunctionMocker;
+template <typename F>
+class FunctionMocker;
 
 // Base class for expectations.
 class ExpectationBase;
 
 // Implements an expectation.
-template <typename F> class TypedExpectation;
+template <typename F>
+class TypedExpectation;
 
 // Helper class for testing the Expectation class template.
 class ExpectationTester;
@@ -129,9 +134,6 @@ class NaggyMockImpl;
 // calls to ensure the integrity of the mock objects' states.
 GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
 
-// Untyped base class for ActionResultHolder<R>.
-class UntypedActionResultHolderBase;
-
 // Abstract base class of FunctionMocker.  This is the
 // type-agnostic part of the function mocker interface.  Its pure
 // virtual methods are implemented by FunctionMocker.
@@ -154,27 +156,12 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // responsibility to guarantee the correctness of the arguments'
   // types.
 
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      void* untyped_args, const std::string& call_description) const = 0;
-
-  // Performs the given action with the given arguments and returns
-  // the action's result.
-  // L = *
-  virtual UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, void* untyped_args) const = 0;
-
   // Writes a message that the call is uninteresting (i.e. neither
   // explicitly expected nor explicitly unexpected) to the given
   // ostream.
-  virtual void UntypedDescribeUninterestingCall(
-      const void* untyped_args,
-      ::std::ostream* os) const
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+  virtual void UntypedDescribeUninterestingCall(const void* untyped_args,
+                                                ::std::ostream* os) const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
 
   // Returns the expectation that matches the given function arguments
   // (or NULL is there's no match); when a match is found,
@@ -183,10 +170,9 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // is_excessive is modified to indicate whether the call exceeds the
   // expected number.
   virtual const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args,
-      const void** untyped_action, bool* is_excessive,
+      const void* untyped_args, const void** untyped_action, bool* is_excessive,
       ::std::ostream* what, ::std::ostream* why)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
 
   // Prints the given function arguments to the ostream.
   virtual void UntypedPrintArgs(const void* untyped_args,
@@ -196,8 +182,7 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // this information in the global mock registry.  Will be called
   // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
   // method.
-  void RegisterOwner(const void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+  void RegisterOwner(const void* mock_obj) GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 
   // Sets the mock object this mock method belongs to, and sets the
   // name of the mock function.  Will be called upon each invocation
@@ -208,20 +193,11 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // Returns the mock object this mock method belongs to.  Must be
   // called after RegisterOwner() or SetOwnerAndName() has been
   // called.
-  const void* MockObject() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+  const void* MockObject() const GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 
   // Returns the name of this mock method.  Must be called after
   // SetOwnerAndName() has been called.
-  const char* Name() const
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
-
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.  The caller is responsible for deleting the
-  // result.
-  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+  const char* Name() const GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 
  protected:
   typedef std::vector<const void*> UntypedOnCallSpecs;
@@ -430,29 +406,28 @@ class GTEST_API_ Mock {
 
   // Tells Google Mock to allow uninteresting calls on the given mock
   // object.
-  static void AllowUninterestingCalls(const void* mock_obj)
+  static void AllowUninterestingCalls(uintptr_t mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Tells Google Mock to warn the user about uninteresting calls on
   // the given mock object.
-  static void WarnUninterestingCalls(const void* mock_obj)
+  static void WarnUninterestingCalls(uintptr_t mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Tells Google Mock to fail uninteresting calls on the given mock
   // object.
-  static void FailUninterestingCalls(const void* mock_obj)
+  static void FailUninterestingCalls(uintptr_t mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Tells Google Mock the given mock object is being destroyed and
   // its entry in the call-reaction table should be removed.
-  static void UnregisterCallReaction(const void* mock_obj)
+  static void UnregisterCallReaction(uintptr_t mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Returns the reaction Google Mock will have on uninteresting calls
   // made on the given mock object.
   static internal::CallReaction GetReactionOnUninterestingCalls(
-      const void* mock_obj)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+      const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Verifies that all expectations on the given mock object have been
   // satisfied.  Reports one or more Google Test non-fatal failures
@@ -465,17 +440,16 @@ class GTEST_API_ Mock {
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
 
   // Registers a mock object and a mock method it owns.
-  static void Register(
-      const void* mock_obj,
-      internal::UntypedFunctionMockerBase* mocker)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  static void Register(const void* mock_obj,
+                       internal::UntypedFunctionMockerBase* mocker)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Tells Google Mock where in the source code mock_obj is used in an
   // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
   // information helps the user identify which object it is.
-  static void RegisterUseByOnCallOrExpectCall(
-      const void* mock_obj, const char* file, int line)
-          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  static void RegisterUseByOnCallOrExpectCall(const void* mock_obj,
+                                              const char* file, int line)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Unregisters a mock method; removes the owning mock object from
   // the registry when the last mock method associated with it has
@@ -632,7 +606,6 @@ class ExpectationSet {
   Expectation::Set expectations_;
 };
 
-
 // Sequence objects are used by a user to specify the relative order
 // in which the expectations should match.  They are copyable (we rely
 // on the compiler-defined copy constructor and assignment operator).
@@ -678,11 +651,13 @@ class GTEST_API_ InSequence {
  public:
   InSequence();
   ~InSequence();
+
  private:
   bool sequence_created_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
-} GTEST_ATTRIBUTE_UNUSED_;
+  InSequence(const InSequence&) = delete;
+  InSequence& operator=(const InSequence&) = delete;
+};
 
 namespace internal {
 
@@ -732,6 +707,12 @@ class GTEST_API_ ExpectationBase {
   // describes it to the ostream.
   virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
 
+  // Do not rely on this for correctness.
+  // This is only for making human-readable test output easier to understand.
+  void UntypedDescription(std::string description) {
+    description_ = std::move(description);
+  }
+
  protected:
   friend class ::testing::Expectation;
   friend class UntypedFunctionMockerBase;
@@ -784,40 +765,38 @@ class GTEST_API_ ExpectationBase {
   // the current thread.
 
   // Retires all pre-requisites of this expectation.
-  void RetireAllPreRequisites()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+  void RetireAllPreRequisites() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
 
   // Returns true if and only if this expectation is retired.
-  bool is_retired() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  bool is_retired() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return retired_;
   }
 
   // Retires this expectation.
-  void Retire()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  void Retire() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     retired_ = true;
   }
 
+  // Returns a human-readable description of this expectation.
+  // Do not rely on this for correctness. It is only for human readability.
+  const std::string& GetDescription() const { return description_; }
+
   // Returns true if and only if this expectation is satisfied.
-  bool IsSatisfied() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  bool IsSatisfied() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsSatisfiedByCallCount(call_count_);
   }
 
   // Returns true if and only if this expectation is saturated.
-  bool IsSaturated() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  bool IsSaturated() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsSaturatedByCallCount(call_count_);
   }
 
   // Returns true if and only if this expectation is over-saturated.
-  bool IsOverSaturated() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  bool IsOverSaturated() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsOverSaturatedByCallCount(call_count_);
   }
@@ -832,15 +811,13 @@ class GTEST_API_ ExpectationBase {
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
 
   // Returns the number this expectation has been invoked.
-  int call_count() const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  int call_count() const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return call_count_;
   }
 
   // Increments the number this expectation has been invoked.
-  void IncrementCallCount()
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  void IncrementCallCount() GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     call_count_++;
   }
@@ -849,8 +826,7 @@ class GTEST_API_ ExpectationBase {
   // WillRepeatedly() clauses) against the cardinality if this hasn't
   // been done before.  Prints a warning if there are too many or too
   // few actions.
-  void CheckActionCountIfNotDone() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
+  void CheckActionCountIfNotDone() const GTEST_LOCK_EXCLUDED_(mutex_);
 
   friend class ::testing::Sequence;
   friend class ::testing::internal::ExpectationTester;
@@ -863,12 +839,13 @@ class GTEST_API_ ExpectationBase {
 
   // This group of fields are part of the spec and won't change after
   // an EXPECT_CALL() statement finishes.
-  const char* file_;          // The file that contains the expectation.
-  int line_;                  // The line number of the expectation.
+  const char* file_;               // The file that contains the expectation.
+  int line_;                       // The line number of the expectation.
   const std::string source_text_;  // The EXPECT_CALL(...) source text.
+  std::string description_;        // User-readable name for the expectation.
   // True if and only if the cardinality is specified explicitly.
   bool cardinality_specified_;
-  Cardinality cardinality_;            // The cardinality of the expectation.
+  Cardinality cardinality_;  // The cardinality of the expectation.
   // The immediate pre-requisites (i.e. expectations that must be
   // satisfied before this expectation can be matched) of this
   // expectation.  We use std::shared_ptr in the set because we want an
@@ -887,12 +864,18 @@ class GTEST_API_ ExpectationBase {
   bool retires_on_saturation_;
   Clause last_clause_;
   mutable bool action_count_checked_;  // Under mutex_.
-  mutable Mutex mutex_;  // Protects action_count_checked_.
-};  // class ExpectationBase
+  mutable Mutex mutex_;                // Protects action_count_checked_.
+};                                     // class ExpectationBase
 
-// Impements an expectation for the given function type.
 template <typename F>
-class TypedExpectation : public ExpectationBase {
+class TypedExpectation;
+
+// Implements an expectation for the given function type.
+template <typename R, typename... Args>
+class TypedExpectation<R(Args...)> : public ExpectationBase {
+ private:
+  using F = R(Args...);
+
  public:
   typedef typename Function<F>::ArgumentTuple ArgumentTuple;
   typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
@@ -938,6 +921,13 @@ class TypedExpectation : public ExpectationBase {
     return *this;
   }
 
+  // Do not rely on this for correctness.
+  // This is only for making human-readable test output easier to understand.
+  TypedExpectation& Description(std::string name) {
+    ExpectationBase::UntypedDescription(std::move(name));
+    return *this;
+  }
+
   // Implements the .Times() clause.
   TypedExpectation& Times(const Cardinality& a_cardinality) {
     ExpectationBase::UntypedTimes(a_cardinality);
@@ -945,9 +935,7 @@ class TypedExpectation : public ExpectationBase {
   }
 
   // Implements the .Times() clause.
-  TypedExpectation& Times(int n) {
-    return Times(Exactly(n));
-  }
+  TypedExpectation& Times(int n) { return Times(Exactly(n)); }
 
   // Implements the .InSequence() clause.
   TypedExpectation& InSequence(const Sequence& s) {
@@ -1007,14 +995,31 @@ class TypedExpectation : public ExpectationBase {
     return After(s1, s2, s3, s4).After(s5);
   }
 
-  // Implements the .WillOnce() clause.
-  TypedExpectation& WillOnce(const Action<F>& action) {
+  // Preferred, type-safe overload: consume anything that can be directly
+  // converted to a OnceAction, except for Action<F> objects themselves.
+  TypedExpectation& WillOnce(OnceAction<F> once_action) {
+    // Call the overload below, smuggling the OnceAction as a copyable callable.
+    // We know this is safe because a WillOnce action will not be called more
+    // than once.
+    return WillOnce(Action<F>(ActionAdaptor{
+        std::make_shared<OnceAction<F>>(std::move(once_action)),
+    }));
+  }
+
+  // Fallback overload: accept Action<F> objects and those actions that define
+  // `operator Action<F>` but not `operator OnceAction<F>`.
+  //
+  // This is templated in order to cause the overload above to be preferred
+  // when the input is convertible to either type.
+  template <int&... ExplicitArgumentBarrier, typename = void>
+  TypedExpectation& WillOnce(Action<F> action) {
     ExpectSpecProperty(last_clause_ <= kWillOnce,
                        ".WillOnce() cannot appear after "
                        ".WillRepeatedly() or .RetiresOnSaturation().");
     last_clause_ = kWillOnce;
 
-    untyped_actions_.push_back(new Action<F>(action));
+    untyped_actions_.push_back(new Action<F>(std::move(action)));
+
     if (!cardinality_specified()) {
       set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
     }
@@ -1062,9 +1067,7 @@ class TypedExpectation : public ExpectationBase {
 
   // Returns the matchers for the arguments as specified inside the
   // EXPECT_CALL() macro.
-  const ArgumentMatcherTuple& matchers() const {
-    return matchers_;
-  }
+  const ArgumentMatcherTuple& matchers() const { return matchers_; }
 
   // Returns the matcher specified by the .With() clause.
   const Matcher<const ArgumentTuple&>& extra_matcher() const {
@@ -1088,6 +1091,16 @@ class TypedExpectation : public ExpectationBase {
   template <typename Function>
   friend class FunctionMocker;
 
+  // An adaptor that turns a OneAction<F> into something compatible with
+  // Action<F>. Must be called at most once.
+  struct ActionAdaptor {
+    std::shared_ptr<OnceAction<R(Args...)>> once_action;
+
+    R operator()(Args&&... args) const {
+      return std::move(*once_action).Call(std::forward<Args>(args)...);
+    }
+  };
+
   // Returns an Expectation object that references and co-owns this
   // expectation.
   Expectation GetHandle() override { return owner_->GetHandleOf(this); }
@@ -1119,10 +1132,8 @@ class TypedExpectation : public ExpectationBase {
 
   // Describes the result of matching the arguments against this
   // expectation to the given ostream.
-  void ExplainMatchResultTo(
-      const ArgumentTuple& args,
-      ::std::ostream* os) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  void ExplainMatchResultTo(const ArgumentTuple& args, ::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
 
     if (is_retired()) {
@@ -1181,9 +1192,9 @@ class TypedExpectation : public ExpectationBase {
       ::std::stringstream ss;
       DescribeLocationTo(&ss);
       ss << "Actions ran out in " << source_text() << "...\n"
-         << "Called " << count << " times, but only "
-         << action_count << " WillOnce()"
-         << (action_count == 1 ? " is" : "s are") << " specified - ";
+         << "Called " << count << " times, but only " << action_count
+         << " WillOnce()" << (action_count == 1 ? " is" : "s are")
+         << " specified - ";
       mocker->DescribeDefaultActionTo(args, &ss);
       Log(kWarning, ss.str(), 1);
     }
@@ -1207,10 +1218,15 @@ class TypedExpectation : public ExpectationBase {
                                          ::std::ostream* why)
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
+    const ::std::string& expectation_description = GetDescription();
     if (IsSaturated()) {
       // We have an excessive call.
       IncrementCallCount();
-      *what << "Mock function called more times than expected - ";
+      *what << "Mock function ";
+      if (!expectation_description.empty()) {
+        *what << "\"" << expectation_description << "\" ";
+      }
+      *what << "called more times than expected - ";
       mocker->DescribeDefaultActionTo(args, what);
       DescribeCallCountTo(why);
 
@@ -1225,7 +1241,11 @@ class TypedExpectation : public ExpectationBase {
     }
 
     // Must be done after IncrementCount()!
-    *what << "Mock function call matches " << source_text() <<"...\n";
+    *what << "Mock function ";
+    if (!expectation_description.empty()) {
+      *what << "\"" << expectation_description << "\" ";
+    }
+    *what << "call matches " << source_text() << "...\n";
     return &(GetCurrentAction(mocker, args));
   }
 
@@ -1236,7 +1256,8 @@ class TypedExpectation : public ExpectationBase {
   Matcher<const ArgumentTuple&> extra_matcher_;
   Action<F> repeated_action_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+  TypedExpectation(const TypedExpectation&) = delete;
+  TypedExpectation& operator=(const TypedExpectation&) = delete;
 };  // class TypedExpectation
 
 // A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
@@ -1258,8 +1279,8 @@ template <typename F>
 class MockSpec {
  public:
   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-  typedef typename internal::Function<F>::ArgumentMatcherTuple
-      ArgumentMatcherTuple;
+  typedef
+      typename internal::Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
 
   // Constructs a MockSpec object, given the function mocker object
   // that the spec is associated with.
@@ -1269,8 +1290,9 @@ class MockSpec {
 
   // Adds a new default action spec to the function mocker and returns
   // the newly created spec.
-  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
-      const char* file, int line, const char* obj, const char* call) {
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(const char* file,
+                                                      int line, const char* obj,
+                                                      const char* call) {
     LogWithLocation(internal::kInfo, file, line,
                     std::string("ON_CALL(") + obj + ", " + call + ") invoked");
     return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
@@ -1278,13 +1300,14 @@ class MockSpec {
 
   // Adds a new expectation spec to the function mocker and returns
   // the newly created spec.
-  internal::TypedExpectation<F>& InternalExpectedAt(
-      const char* file, int line, const char* obj, const char* call) {
+  internal::TypedExpectation<F>& InternalExpectedAt(const char* file, int line,
+                                                    const char* obj,
+                                                    const char* call) {
     const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
                                   call + ")");
     LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
-    return function_mocker_->AddNewExpectation(
-        file, line, source_text, matchers_);
+    return function_mocker_->AddNewExpectation(file, line, source_text,
+                                               matchers_);
   }
 
   // This operator overload is used to swallow the superfluous parameter list
@@ -1317,9 +1340,7 @@ template <typename T>
 class ReferenceOrValueWrapper {
  public:
   // Constructs a wrapper from the given value/reference.
-  explicit ReferenceOrValueWrapper(T value)
-      : value_(std::move(value)) {
-  }
+  explicit ReferenceOrValueWrapper(T value) : value_(std::move(value)) {}
 
   // Unwraps and returns the underlying value/reference, exactly as
   // originally passed. The behavior of calling this more than once on
@@ -1330,9 +1351,7 @@ class ReferenceOrValueWrapper {
   // Always returns a const reference (more precisely,
   // const std::add_lvalue_reference<T>::type). The behavior of calling this
   // after calling Unwrap on the same object is unspecified.
-  const T& Peek() const {
-    return value_;
-  }
+  const T& Peek() const { return value_; }
 
  private:
   T value_;
@@ -1346,8 +1365,7 @@ class ReferenceOrValueWrapper<T&> {
   // Workaround for debatable pass-by-reference lint warning (c-library-team
   // policy precludes NOLINT in this context)
   typedef T& reference;
-  explicit ReferenceOrValueWrapper(reference ref)
-      : value_ptr_(&ref) {}
+  explicit ReferenceOrValueWrapper(reference ref) : value_ptr_(&ref) {}
   T& Unwrap() { return *value_ptr_; }
   const T& Peek() const { return *value_ptr_; }
 
@@ -1355,102 +1373,27 @@ class ReferenceOrValueWrapper<T&> {
   T* value_ptr_;
 };
 
-// C++ treats the void type specially.  For example, you cannot define
-// a void-typed variable or pass a void value to a function.
-// ActionResultHolder<T> holds a value of type T, where T must be a
-// copyable type or void (T doesn't need to be default-constructable).
-// It hides the syntactic difference between void and other types, and
-// is used to unify the code for invoking both void-returning and
-// non-void-returning mock functions.
-
-// Untyped base class for ActionResultHolder<T>.
-class UntypedActionResultHolderBase {
- public:
-  virtual ~UntypedActionResultHolderBase() {}
-
-  // Prints the held value as an action's result to os.
-  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
-};
-
-// This generic definition is used when T is not void.
+// Prints the held value as an action's result to os.
 template <typename T>
-class ActionResultHolder : public UntypedActionResultHolderBase {
- public:
-  // Returns the held value. Must not be called more than once.
-  T Unwrap() {
-    return result_.Unwrap();
-  }
-
-  // Prints the held value as an action's result to os.
-  void PrintAsActionResult(::std::ostream* os) const override {
-    *os << "\n          Returns: ";
-    // T may be a reference type, so we don't use UniversalPrint().
-    UniversalPrinter<T>::Print(result_.Peek(), os);
-  }
+void PrintAsActionResult(const T& result, std::ostream& os) {
+  os << "\n          Returns: ";
+  // T may be a reference type, so we don't use UniversalPrint().
+  UniversalPrinter<T>::Print(result, &os);
+}
 
-  // Performs the given mock function's default action and returns the
-  // result in a new-ed ActionResultHolder.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMocker<F>* func_mocker,
-      typename Function<F>::ArgumentTuple&& args,
-      const std::string& call_description) {
-    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
-        std::move(args), call_description)));
-  }
-
-  // Performs the given action and returns the result in a new-ed
-  // ActionResultHolder.
-  template <typename F>
-  static ActionResultHolder* PerformAction(
-      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
-    return new ActionResultHolder(
-        Wrapper(action.Perform(std::move(args))));
-  }
-
- private:
-  typedef ReferenceOrValueWrapper<T> Wrapper;
-
-  explicit ActionResultHolder(Wrapper result)
-      : result_(std::move(result)) {
-  }
-
-  Wrapper result_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
-};
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+GTEST_API_ void ReportUninterestingCall(CallReaction reaction,
+                                        const std::string& msg);
 
-// Specialization for T = void.
-template <>
-class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+// A generic RAII type that runs a user-provided function in its destructor.
+class Cleanup final {
  public:
-  void Unwrap() { }
-
-  void PrintAsActionResult(::std::ostream* /* os */) const override {}
-
-  // Performs the given mock function's default action and returns ownership
-  // of an empty ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformDefaultAction(
-      const FunctionMocker<F>* func_mocker,
-      typename Function<F>::ArgumentTuple&& args,
-      const std::string& call_description) {
-    func_mocker->PerformDefaultAction(std::move(args), call_description);
-    return new ActionResultHolder;
-  }
-
-  // Performs the given action and returns ownership of an empty
-  // ActionResultHolder*.
-  template <typename F>
-  static ActionResultHolder* PerformAction(
-      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
-    action.Perform(std::move(args));
-    return new ActionResultHolder;
-  }
+  explicit Cleanup(std::function<void()> f) : f_(std::move(f)) {}
+  ~Cleanup() { f_(); }
 
  private:
-  ActionResultHolder() {}
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+  std::function<void()> f_;
 };
 
 template <typename F>
@@ -1495,14 +1438,12 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // Returns the ON_CALL spec that matches this mock function with the
   // given arguments; returns NULL if no matching ON_CALL is found.
   // L = *
-  const OnCallSpec<F>* FindOnCallSpec(
-      const ArgumentTuple& args) const {
-    for (UntypedOnCallSpecs::const_reverse_iterator it
-             = untyped_on_call_specs_.rbegin();
+  const OnCallSpec<F>* FindOnCallSpec(const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it =
+             untyped_on_call_specs_.rbegin();
          it != untyped_on_call_specs_.rend(); ++it) {
       const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
-      if (spec->Matches(args))
-        return spec;
+      if (spec->Matches(args)) return spec;
     }
 
     return nullptr;
@@ -1510,15 +1451,14 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
 
   // Performs the default action of this mock function on the given
   // arguments and returns the result. Asserts (or throws if
-  // exceptions are enabled) with a helpful call descrption if there
+  // exceptions are enabled) with a helpful call description if there
   // is no valid return value. This method doesn't depend on the
   // mutable state of this object, and thus can be called concurrently
   // without locking.
   // L = *
   Result PerformDefaultAction(ArgumentTuple&& args,
                               const std::string& call_description) const {
-    const OnCallSpec<F>* const spec =
-        this->FindOnCallSpec(args);
+    const OnCallSpec<F>* const spec = this->FindOnCallSpec(args);
     if (spec != nullptr) {
       return spec->GetAction().Perform(std::move(args));
     }
@@ -1536,32 +1476,6 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
     return DefaultValue<Result>::Get();
   }
 
-  // Performs the default action with the given arguments and returns
-  // the action's result.  The call description string will be used in
-  // the error message to describe the call in the case the default
-  // action fails.  The caller is responsible for deleting the result.
-  // L = *
-  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      void* untyped_args,  // must point to an ArgumentTuple
-      const std::string& call_description) const override {
-    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformDefaultAction(this, std::move(*args),
-                                              call_description);
-  }
-
-  // Performs the given action with the given arguments and returns
-  // the action's result.  The caller is responsible for deleting the
-  // result.
-  // L = *
-  UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, void* untyped_args) const override {
-    // Make a copy of the action before performing it, in case the
-    // action deletes the mock object (and thus deletes itself).
-    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
-    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformAction(action, std::move(*args));
-  }
-
   // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
   // clears the ON_CALL()s set on this mock function.
   void ClearDefaultActionsLocked() override
@@ -1579,8 +1493,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
     untyped_on_call_specs_.swap(specs_to_delete);
 
     g_gmock_mutex.Unlock();
-    for (UntypedOnCallSpecs::const_iterator it =
-             specs_to_delete.begin();
+    for (UntypedOnCallSpecs::const_iterator it = specs_to_delete.begin();
          it != specs_to_delete.end(); ++it) {
       delete static_cast<const OnCallSpec<F>*>(*it);
     }
@@ -1594,10 +1507,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // arguments.  This function can be safely called from multiple
   // threads concurrently.
   Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    ArgumentTuple tuple(std::forward<Args>(args)...);
-    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
-        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
-    return holder->Unwrap();
+    return InvokeWith(ArgumentTuple(std::forward<Args>(args)...));
   }
 
   MockSpec<F> With(Matcher<Args>... m) {
@@ -1608,13 +1518,10 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   template <typename Function>
   friend class MockSpec;
 
-  typedef ActionResultHolder<Result> ResultHolder;
-
   // Adds and returns a default action spec for this mock function.
-  OnCallSpec<F>& AddNewOnCallSpec(
-      const char* file, int line,
-      const ArgumentMatcherTuple& m)
-          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  OnCallSpec<F>& AddNewOnCallSpec(const char* file, int line,
+                                  const ArgumentMatcherTuple& m)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
     Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
     OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
     untyped_on_call_specs_.push_back(on_call_spec);
@@ -1644,7 +1551,8 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   }
 
  private:
-  template <typename Func> friend class TypedExpectation;
+  template <typename Func>
+  friend class TypedExpectation;
 
   // Some utilities needed for implementing UntypedInvokeWith().
 
@@ -1728,9 +1636,8 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
 
   // Returns the expectation that matches the arguments, or NULL if no
   // expectation matches them.
-  TypedExpectation<F>* FindMatchingExpectationLocked(
-      const ArgumentTuple& args) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  TypedExpectation<F>* FindMatchingExpectationLocked(const ArgumentTuple& args)
+      const GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     // See the definition of untyped_expectations_ for why access to
     // it is unprotected here.
@@ -1747,11 +1654,10 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   }
 
   // Returns a message that the arguments don't match any expectation.
-  void FormatUnexpectedCallMessageLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* os,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  void FormatUnexpectedCallMessageLocked(const ArgumentTuple& args,
+                                         ::std::ostream* os,
+                                         ::std::ostream* why) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     *os << "\nUnexpected mock function call - ";
     DescribeDefaultActionTo(args, os);
@@ -1760,15 +1666,14 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
 
   // Prints a list of expectations that have been tried against the
   // current mock function call.
-  void PrintTriedExpectationsLocked(
-      const ArgumentTuple& args,
-      ::std::ostream* why) const
-          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  void PrintTriedExpectationsLocked(const ArgumentTuple& args,
+                                    ::std::ostream* why) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     const size_t count = untyped_expectations_.size();
     *why << "Google Mock tried the following " << count << " "
-         << (count == 1 ? "expectation, but it didn't match" :
-             "expectations, but none matched")
+         << (count == 1 ? "expectation, but it didn't match"
+                        : "expectations, but none matched")
          << ":\n";
     for (size_t i = 0; i < count; i++) {
       TypedExpectation<F>* const expectation =
@@ -1783,11 +1688,177 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
       expectation->DescribeCallCountTo(why);
     }
   }
+
+  // Performs the given action (or the default if it's null) with the given
+  // arguments and returns the action's result.
+  // L = *
+  R PerformAction(const void* untyped_action, ArgumentTuple&& args,
+                  const std::string& call_description) const {
+    if (untyped_action == nullptr) {
+      return PerformDefaultAction(std::move(args), call_description);
+    }
+
+    // Make a copy of the action before performing it, in case the
+    // action deletes the mock object (and thus deletes itself).
+    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
+    return action.Perform(std::move(args));
+  }
+
+  // Is it possible to store an object of the supplied type in a local variable
+  // for the sake of printing it, then return it on to the caller?
+  template <typename T>
+  using can_print_result = internal::conjunction<
+      // void can't be stored as an object (and we also don't need to print it).
+      internal::negation<std::is_void<T>>,
+      // Non-moveable types can't be returned on to the user, so there's no way
+      // for us to intercept and print them.
+      std::is_move_constructible<T>>;
+
+  // Perform the supplied action, printing the result to os.
+  template <typename T = R,
+            typename std::enable_if<can_print_result<T>::value, int>::type = 0>
+  R PerformActionAndPrintResult(const void* const untyped_action,
+                                ArgumentTuple&& args,
+                                const std::string& call_description,
+                                std::ostream& os) {
+    R result = PerformAction(untyped_action, std::move(args), call_description);
+
+    PrintAsActionResult(result, os);
+    return std::forward<R>(result);
+  }
+
+  // An overload for when it's not possible to print the result. In this case we
+  // simply perform the action.
+  template <typename T = R,
+            typename std::enable_if<
+                internal::negation<can_print_result<T>>::value, int>::type = 0>
+  R PerformActionAndPrintResult(const void* const untyped_action,
+                                ArgumentTuple&& args,
+                                const std::string& call_description,
+                                std::ostream&) {
+    return PerformAction(untyped_action, std::move(args), call_description);
+  }
+
+  // Returns the result of invoking this mock function with the given
+  // arguments. This function can be safely called from multiple
+  // threads concurrently.
+  R InvokeWith(ArgumentTuple&& args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 };  // class FunctionMocker
 
-// Reports an uninteresting call (whose description is in msg) in the
-// manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
+// Calculates the result of invoking this mock function with the given
+// arguments, prints it, and returns it.
+template <typename R, typename... Args>
+R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // See the definition of untyped_expectations_ for why access to it
+  // is unprotected here.
+  if (untyped_expectations_.size() == 0) {
+    // No expectation is set on this mock method - we have an
+    // uninteresting call.
+
+    // We must get Google Mock's reaction on uninteresting calls
+    // made on this mock object BEFORE performing the action,
+    // because the action may DELETE the mock object and make the
+    // following expression meaningless.
+    const CallReaction reaction =
+        Mock::GetReactionOnUninterestingCalls(MockObject());
+
+    // True if and only if we need to print this call's arguments and return
+    // value.  This definition must be kept in sync with
+    // the behavior of ReportUninterestingCall().
+    const bool need_to_report_uninteresting_call =
+        // If the user allows this uninteresting call, we print it
+        // only when they want informational messages.
+        reaction == kAllow ? LogIsVisible(kInfo) :
+                           // If the user wants this to be a warning, we print
+                           // it only when they want to see warnings.
+            reaction == kWarn
+            ? LogIsVisible(kWarning)
+            :
+            // Otherwise, the user wants this to be an error, and we
+            // should always print detailed information in the error.
+            true;
+
+    if (!need_to_report_uninteresting_call) {
+      // Perform the action without printing the call information.
+      return this->PerformDefaultAction(
+          std::move(args), "Function call: " + std::string(Name()));
+    }
+
+    // Warns about the uninteresting call.
+    ::std::stringstream ss;
+    this->UntypedDescribeUninterestingCall(&args, &ss);
+
+    // Perform the action, print the result, and then report the uninteresting
+    // call.
+    //
+    // We use RAII to do the latter in case R is void or a non-moveable type. In
+    // either case we can't assign it to a local variable.
+    const Cleanup report_uninteresting_call(
+        [&] { ReportUninterestingCall(reaction, ss.str()); });
+
+    return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
+  }
+
+  bool is_excessive = false;
+  ::std::stringstream ss;
+  ::std::stringstream why;
+  ::std::stringstream loc;
+  const void* untyped_action = nullptr;
+
+  // The UntypedFindMatchingExpectation() function acquires and
+  // releases g_gmock_mutex.
+
+  const ExpectationBase* const untyped_expectation =
+      this->UntypedFindMatchingExpectation(&args, &untyped_action,
+                                           &is_excessive, &ss, &why);
+  const bool found = untyped_expectation != nullptr;
+
+  // True if and only if we need to print the call's arguments
+  // and return value.
+  // This definition must be kept in sync with the uses of Expect()
+  // and Log() in this function.
+  const bool need_to_report_call =
+      !found || is_excessive || LogIsVisible(kInfo);
+  if (!need_to_report_call) {
+    // Perform the action without printing the call information.
+    return PerformAction(untyped_action, std::move(args), "");
+  }
+
+  ss << "    Function call: " << Name();
+  this->UntypedPrintArgs(&args, &ss);
+
+  // In case the action deletes a piece of the expectation, we
+  // generate the message beforehand.
+  if (found && !is_excessive) {
+    untyped_expectation->DescribeLocationTo(&loc);
+  }
+
+  // Perform the action, print the result, and then fail or log in whatever way
+  // is appropriate.
+  //
+  // We use RAII to do the latter in case R is void or a non-moveable type. In
+  // either case we can't assign it to a local variable.
+  const Cleanup handle_failures([&] {
+    ss << "\n" << why.str();
+
+    if (!found) {
+      // No expectation matches this call - reports a failure.
+      Expect(false, nullptr, -1, ss.str());
+    } else if (is_excessive) {
+      // We had an upper-bound violation and the failure message is in ss.
+      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
+             ss.str());
+    } else {
+      // We had an expected call and the matching expectation is
+      // described in ss.
+      Log(kInfo, loc.str() + ss.str(), 2);
+    }
+  });
+
+  return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
+                                     ss);
+}
 
 }  // namespace internal
 
@@ -1952,7 +2023,9 @@ using internal::MockSpec;
 //   // Expects a call to const MockFoo::Bar().
 //   EXPECT_CALL(Const(foo), Bar());
 template <typename T>
-inline const T& Const(const T& x) { return x; }
+inline const T& Const(const T& x) {
+  return x;
+}
 
 // Constructs an Expectation object that references and co-owns exp.
 inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
diff --git a/googletest/googlemock/include/gmock/gmock.h b/googletest/googlemock/include/gmock/gmock.h
index 12469bc466ebdfede2b8736be0f6f6c67277ebfc..568c8c71d78578ffab629c3634fea890c5accfd6 100644
--- a/googletest/googlemock/include/gmock/gmock.h
+++ b/googletest/googlemock/include/gmock/gmock.h
@@ -27,13 +27,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This is the main header file a user should include.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
 
@@ -64,14 +61,15 @@
 #include "gmock/gmock-more-matchers.h"
 #include "gmock/gmock-nice-strict.h"
 #include "gmock/internal/gmock-internal-utils.h"
-
-namespace testing {
+#include "gmock/internal/gmock-port.h"
 
 // Declares Google Mock flags that we want a user to use programmatically.
 GMOCK_DECLARE_bool_(catch_leaked_mocks);
 GMOCK_DECLARE_string_(verbose);
 GMOCK_DECLARE_int32_(default_mock_behavior);
 
+namespace testing {
+
 // Initializes Google Mock.  This must be called before running the
 // tests.  In particular, it parses the command line for the flags
 // that Google Mock recognizes.  Whenever a Google Mock flag is seen,
diff --git a/googletest/googlemock/include/gmock/internal/custom/README.md b/googletest/googlemock/include/gmock/internal/custom/README.md
index f6c93f616d62414bc599efa06cd76742eb9977b8..9c4874fd0cb31e89682088eb1a91cc7a43857bee 100644
--- a/googletest/googlemock/include/gmock/internal/custom/README.md
+++ b/googletest/googlemock/include/gmock/internal/custom/README.md
@@ -14,3 +14,5 @@ The following macros can be defined:
 *   `GMOCK_DEFINE_bool_(name, default_val, doc)`
 *   `GMOCK_DEFINE_int32_(name, default_val, doc)`
 *   `GMOCK_DEFINE_string_(name, default_val, doc)`
+*   `GMOCK_FLAG_GET(flag_name)`
+*   `GMOCK_FLAG_SET(flag_name, value)`
diff --git a/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
index 63f899962e39eeba01adc70cea5bdc03da8fde89..bbcad31c76efa9a05a9acb4032f73f6fd656b42e 100644
--- a/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
+++ b/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
@@ -1,4 +1,5 @@
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h b/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
index 638429488e216831d68b08c6be526feb51a910a4..bb7dcbaa4cb20035c897d55ba5e58f8c5d4c9cb3 100644
--- a/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
+++ b/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
@@ -26,10 +26,11 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // Injection point for custom user configurations. See README for details
-//
-// GOOGLETEST_CM0002 DO NOT DELETE
+
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
diff --git a/googletest/googlemock/include/gmock/internal/custom/gmock-port.h b/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
index 14378692aefe4dbb3f5a17d0393d9a5f39e01ba7..f055f7506b82ec481b295881a2c3f7f1b0a685e4 100644
--- a/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
+++ b/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
@@ -26,12 +26,13 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // Injection point for custom user configurations. See README for details
 //
 // ** Custom implementation starts here **
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h b/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
index 317544a7daf5da7ba9a28db1e991f071ef762960..36ab8e26a8a237472cf1982bec5586182e58e7d8 100644
--- a/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -27,22 +27,25 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file defines some utilities useful for implementing Google
 // Mock.  They are subject to change without notice, so please DO NOT
 // USE THEM IN USER CODE.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
 
 #include <stdio.h>
+
 #include <ostream>  // NOLINT
 #include <string>
 #include <type_traits>
+#include <vector>
+
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
 
@@ -56,14 +59,15 @@ namespace internal {
 // Silence MSVC C4100 (unreferenced formal parameter) and
 // C4805('==': unsafe mix of type 'const int' and type 'const bool')
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-# pragma warning(disable:4805)
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#pragma warning(disable : 4805)
 #endif
 
 // Joins a vector of strings as if they are fields of a tuple; returns
 // the joined string.
-GTEST_API_ std::string JoinAsTuple(const Strings& fields);
+GTEST_API_ std::string JoinAsKeyValueTuple(
+    const std::vector<const char*>& names, const Strings& values);
 
 // Converts an identifier name to a space-separated list of lower-case
 // words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
@@ -78,9 +82,36 @@ template <typename Pointer>
 inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
   return p.get();
 }
+// This overload version is for std::reference_wrapper, which does not work with
+// the overload above, as it does not have an `element_type`.
+template <typename Element>
+inline const Element* GetRawPointer(const std::reference_wrapper<Element>& r) {
+  return &r.get();
+}
+
 // This overloaded version is for the raw pointer case.
 template <typename Element>
-inline Element* GetRawPointer(Element* p) { return p; }
+inline Element* GetRawPointer(Element* p) {
+  return p;
+}
+
+// Default definitions for all compilers.
+// NOTE: If you implement support for other compilers, make sure to avoid
+// unexpected overlaps.
+// (e.g., Clang also processes #pragma GCC, and clang-cl also handles _MSC_VER.)
+#define GMOCK_INTERNAL_WARNING_PUSH()
+#define GMOCK_INTERNAL_WARNING_CLANG(Level, Name)
+#define GMOCK_INTERNAL_WARNING_POP()
+
+#if defined(__clang__)
+#undef GMOCK_INTERNAL_WARNING_PUSH
+#define GMOCK_INTERNAL_WARNING_PUSH() _Pragma("clang diagnostic push")
+#undef GMOCK_INTERNAL_WARNING_CLANG
+#define GMOCK_INTERNAL_WARNING_CLANG(Level, Warning) \
+  _Pragma(GMOCK_PP_INTERNAL_STRINGIZE(clang diagnostic Level Warning))
+#undef GMOCK_INTERNAL_WARNING_POP
+#define GMOCK_INTERNAL_WARNING_POP() _Pragma("clang diagnostic pop")
+#endif
 
 // MSVC treats wchar_t as a native type usually, but treats it as the
 // same as unsigned short when the compiler option /Zc:wchar_t- is
@@ -89,7 +120,7 @@ inline Element* GetRawPointer(Element* p) { return p; }
 #if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
 // wchar_t is a typedef.
 #else
-# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#define GMOCK_WCHAR_T_IS_NATIVE_ 1
 #endif
 
 // In what follows, we use the term "kind" to indicate whether a type
@@ -97,18 +128,20 @@ inline Element* GetRawPointer(Element* p) { return p; }
 // or none of them.  This categorization is useful for determining
 // when a matcher argument type can be safely converted to another
 // type in the implementation of SafeMatcherCast.
-enum TypeKind {
-  kBool, kInteger, kFloatingPoint, kOther
-};
+enum TypeKind { kBool, kInteger, kFloatingPoint, kOther };
 
 // KindOf<T>::value is the kind of type T.
-template <typename T> struct KindOf {
+template <typename T>
+struct KindOf {
   enum { value = kOther };  // The default kind.
 };
 
 // This macro declares that the kind of 'type' is 'kind'.
 #define GMOCK_DECLARE_KIND_(type, kind) \
-  template <> struct KindOf<type> { enum { value = kind }; }
+  template <>                           \
+  struct KindOf<type> {                 \
+    enum { value = kind };              \
+  }
 
 GMOCK_DECLARE_KIND_(bool, kBool);
 
@@ -116,13 +149,13 @@ GMOCK_DECLARE_KIND_(bool, kBool);
 GMOCK_DECLARE_KIND_(char, kInteger);
 GMOCK_DECLARE_KIND_(signed char, kInteger);
 GMOCK_DECLARE_KIND_(unsigned char, kInteger);
-GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(short, kInteger);           // NOLINT
 GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
 GMOCK_DECLARE_KIND_(int, kInteger);
 GMOCK_DECLARE_KIND_(unsigned int, kInteger);
-GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(long, kInteger);                // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);       // NOLINT
+GMOCK_DECLARE_KIND_(long long, kInteger);           // NOLINT
 GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT
 
 #if GMOCK_WCHAR_T_IS_NATIVE_
@@ -137,7 +170,7 @@ GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
 #undef GMOCK_DECLARE_KIND_
 
 // Evaluates to the kind of 'type'.
-#define GMOCK_KIND_OF_(type) \
+#define GMOCK_KIND_OF_(type)                   \
   static_cast< ::testing::internal::TypeKind>( \
       ::testing::internal::KindOf<type>::value)
 
@@ -193,9 +226,7 @@ using LosslessArithmeticConvertible =
 class FailureReporterInterface {
  public:
   // The type of a failure (either non-fatal or fatal).
-  enum FailureType {
-    kNonfatal, kFatal
-  };
+  enum FailureType { kNonfatal, kFatal };
 
   virtual ~FailureReporterInterface() {}
 
@@ -215,8 +246,8 @@ GTEST_API_ FailureReporterInterface* GetFailureReporter();
 inline void Assert(bool condition, const char* file, int line,
                    const std::string& msg) {
   if (!condition) {
-    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
-                                        file, line, msg);
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal, file,
+                                        line, msg);
   }
 }
 inline void Assert(bool condition, const char* file, int line) {
@@ -237,10 +268,7 @@ inline void Expect(bool condition, const char* file, int line) {
 }
 
 // Severity level of a log.
-enum LogSeverity {
-  kInfo = 0,
-  kWarning = 1
-};
+enum LogSeverity { kInfo = 0, kWarning = 1 };
 
 // Valid values for the --gmock_verbose flag.
 
@@ -280,13 +308,6 @@ class WithoutMatchers {
 // Internal use only: access the singleton instance of WithoutMatchers.
 GTEST_API_ WithoutMatchers GetWithoutMatchers();
 
-// Disable MSVC warnings for infinite recursion, since in this case the
-// the recursion is unreachable.
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4717)
-#endif
-
 // Invalid<T>() is usable as an expression of type T, but will terminate
 // the program with an assertion failure if actually run.  This is useful
 // when a value of type T is needed for compilation, but the statement
@@ -295,15 +316,14 @@ GTEST_API_ WithoutMatchers GetWithoutMatchers();
 template <typename T>
 inline T Invalid() {
   Assert(false, "", -1, "Internal error: attempt to return invalid value");
-  // This statement is unreachable, and would never terminate even if it
-  // could be reached. It is provided only to placate compiler warnings
-  // about missing return statements.
+#if defined(__GNUC__) || defined(__clang__)
+  __builtin_unreachable();
+#elif defined(_MSC_VER)
+  __assume(0);
+#else
   return Invalid<T>();
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
 #endif
+}
 
 // Given a raw type (i.e. having no top-level reference or const
 // modifier) RawContainer that's either an STL-style container or a
@@ -381,7 +401,8 @@ class StlContainerView< ::std::tuple<ElementPointer, Size> > {
 
 // The following specialization prevents the user from instantiating
 // StlContainer with a reference type.
-template <typename T> class StlContainerView<T&>;
+template <typename T>
+class StlContainerView<T&>;
 
 // A type transform to remove constness from the first part of a pair.
 // Pairs like that are used as the value_type of associative containers,
@@ -402,17 +423,18 @@ struct RemoveConstFromKey<std::pair<const K, V> > {
 GTEST_API_ void IllegalDoDefault(const char* file, int line);
 
 template <typename F, typename Tuple, size_t... Idx>
-auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
-    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>)
+    -> decltype(std::forward<F>(f)(
+        std::get<Idx>(std::forward<Tuple>(args))...)) {
   return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
 }
 
 // Apply the function to a tuple of arguments.
 template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& args) -> decltype(
-    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-              MakeIndexSequence<std::tuple_size<
-                  typename std::remove_reference<Tuple>::type>::value>())) {
+auto Apply(F&& f, Tuple&& args) -> decltype(ApplyImpl(
+    std::forward<F>(f), std::forward<Tuple>(args),
+    MakeIndexSequence<std::tuple_size<
+        typename std::remove_reference<Tuple>::type>::value>())) {
   return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
                    MakeIndexSequence<std::tuple_size<
                        typename std::remove_reference<Tuple>::type>::value>());
@@ -449,8 +471,17 @@ struct Function<R(Args...)> {
 template <typename R, typename... Args>
 constexpr size_t Function<R(Args...)>::ArgumentCount;
 
+// Workaround for MSVC error C2039: 'type': is not a member of 'std'
+// when std::tuple_element is used.
+// See: https://github.com/google/googletest/issues/3931
+// Can be replaced with std::tuple_element_t in C++14.
+template <size_t I, typename T>
+using TupleElement = typename std::tuple_element<I, T>::type;
+
+bool Base64Unescape(const std::string& encoded, std::string* decoded);
+
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 }  // namespace internal
diff --git a/googletest/googlemock/include/gmock/internal/gmock-port.h b/googletest/googlemock/include/gmock/internal/gmock-port.h
index 367a44d366a7485cff9601ed1ff1ed39f354072e..bc18a25f348c32bcea02b033c9f10bdd10bdbb66 100644
--- a/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ b/googletest/googlemock/include/gmock/internal/gmock-port.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
 // Low-level types and utilities for porting Google Mock to various
 // platforms.  All macros ending with _ and symbols defined in an
 // internal namespace are subject to change without notice.  Code
@@ -35,7 +34,8 @@
 // end with _ are part of Google Mock's public API and can be used by
 // code outside Google Mock.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// IWYU pragma: private, include "gmock/gmock.h"
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
@@ -53,35 +53,87 @@
 // here, as Google Mock depends on Google Test.  Only add a utility
 // here if it's truly specific to Google Mock.
 
-#include "gtest/internal/gtest-port.h"
 #include "gmock/internal/custom/gmock-port.h"
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_HAS_ABSL
+#include "absl/flags/declare.h"
+#include "absl/flags/flag.h"
+#endif
 
 // For MS Visual C++, check the compiler version. At least VS 2015 is
 // required to compile Google Mock.
 #if defined(_MSC_VER) && _MSC_VER < 1900
-# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
+#error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
 #endif
 
 // Macro for referencing flags.  This is public as we want the user to
 // use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG_NAME_(name) gmock_##name
 #define GMOCK_FLAG(name) FLAGS_gmock_##name
 
-#if !defined(GMOCK_DECLARE_bool_)
+// Pick a command line flags implementation.
+#if GTEST_HAS_ABSL
+
+// Macros for defining flags.
+#define GMOCK_DEFINE_bool_(name, default_val, doc) \
+  ABSL_FLAG(bool, GMOCK_FLAG_NAME_(name), default_val, doc)
+#define GMOCK_DEFINE_int32_(name, default_val, doc) \
+  ABSL_FLAG(int32_t, GMOCK_FLAG_NAME_(name), default_val, doc)
+#define GMOCK_DEFINE_string_(name, default_val, doc) \
+  ABSL_FLAG(std::string, GMOCK_FLAG_NAME_(name), default_val, doc)
 
 // Macros for declaring flags.
-# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
-# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name)
-# define GMOCK_DECLARE_string_(name) \
-    extern GTEST_API_ ::std::string GMOCK_FLAG(name)
+#define GMOCK_DECLARE_bool_(name) \
+  ABSL_DECLARE_FLAG(bool, GMOCK_FLAG_NAME_(name))
+#define GMOCK_DECLARE_int32_(name) \
+  ABSL_DECLARE_FLAG(int32_t, GMOCK_FLAG_NAME_(name))
+#define GMOCK_DECLARE_string_(name) \
+  ABSL_DECLARE_FLAG(std::string, GMOCK_FLAG_NAME_(name))
+
+#define GMOCK_FLAG_GET(name) ::absl::GetFlag(GMOCK_FLAG(name))
+#define GMOCK_FLAG_SET(name, value) \
+  (void)(::absl::SetFlag(&GMOCK_FLAG(name), value))
+
+#else  // GTEST_HAS_ABSL
 
 // Macros for defining flags.
-# define GMOCK_DEFINE_bool_(name, default_val, doc) \
-    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
-# define GMOCK_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val)
-# define GMOCK_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
-
-#endif  // !defined(GMOCK_DECLARE_bool_)
+#define GMOCK_DEFINE_bool_(name, default_val, doc)  \
+  namespace testing {                               \
+  GTEST_API_ bool GMOCK_FLAG(name) = (default_val); \
+  }                                                 \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DEFINE_int32_(name, default_val, doc)    \
+  namespace testing {                                  \
+  GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val); \
+  }                                                    \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DEFINE_string_(name, default_val, doc)         \
+  namespace testing {                                        \
+  GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val); \
+  }                                                          \
+  static_assert(true, "no-op to require trailing semicolon")
+
+// Macros for declaring flags.
+#define GMOCK_DECLARE_bool_(name)          \
+  namespace testing {                      \
+  GTEST_API_ extern bool GMOCK_FLAG(name); \
+  }                                        \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DECLARE_int32_(name)            \
+  namespace testing {                         \
+  GTEST_API_ extern int32_t GMOCK_FLAG(name); \
+  }                                           \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GMOCK_DECLARE_string_(name)                 \
+  namespace testing {                               \
+  GTEST_API_ extern ::std::string GMOCK_FLAG(name); \
+  }                                                 \
+  static_assert(true, "no-op to require trailing semicolon")
+
+#define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
+#define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)
+
+#endif  // GTEST_HAS_ABSL
 
 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/googletest/googlemock/src/gmock-cardinalities.cc b/googletest/googlemock/src/gmock-cardinalities.cc
index 7463f4383233c315e128dc577a3c74cec23c8b34..92cde3484abf6bb52d1527cf8b1d4fa45ea2f4d7 100644
--- a/googletest/googlemock/src/gmock-cardinalities.cc
+++ b/googletest/googlemock/src/gmock-cardinalities.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements cardinalities.
@@ -35,9 +34,11 @@
 #include "gmock/gmock-cardinalities.h"
 
 #include <limits.h>
+
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
+
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gtest/gtest.h"
 
@@ -49,8 +50,7 @@ namespace {
 class BetweenCardinalityImpl : public CardinalityInterface {
  public:
   BetweenCardinalityImpl(int min, int max)
-      : min_(min >= 0 ? min : 0),
-        max_(max >= min_ ? max : min_) {
+      : min_(min >= 0 ? min : 0), max_(max >= min_ ? max : min_) {
     std::stringstream ss;
     if (min < 0) {
       ss << "The invocation lower bound must be >= 0, "
@@ -62,8 +62,7 @@ class BetweenCardinalityImpl : public CardinalityInterface {
       internal::Expect(false, __FILE__, __LINE__, ss.str());
     } else if (min > max) {
       ss << "The invocation upper bound (" << max
-         << ") must be >= the invocation lower bound (" << min
-         << ").";
+         << ") must be >= the invocation lower bound (" << min << ").";
       internal::Expect(false, __FILE__, __LINE__, ss.str());
     }
   }
@@ -87,7 +86,8 @@ class BetweenCardinalityImpl : public CardinalityInterface {
   const int min_;
   const int max_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
+  BetweenCardinalityImpl(const BetweenCardinalityImpl&) = delete;
+  BetweenCardinalityImpl& operator=(const BetweenCardinalityImpl&) = delete;
 };
 
 // Formats "n times" in a human-friendly way.
diff --git a/googletest/googlemock/src/gmock-internal-utils.cc b/googletest/googlemock/src/gmock-internal-utils.cc
index e5b547981d14d47fa49132d49cd3e950ae0c30fd..7bfff02a33ca78807ebace17005e34291ed5148f 100644
--- a/googletest/googlemock/src/gmock-internal-utils.cc
+++ b/googletest/googlemock/src/gmock-internal-utils.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file defines some utilities useful for implementing Google
@@ -37,8 +36,15 @@
 #include "gmock/internal/gmock-internal-utils.h"
 
 #include <ctype.h>
+
+#include <array>
+#include <cctype>
+#include <cstdint>
+#include <cstring>
 #include <ostream>  // NOLINT
 #include <string>
+#include <vector>
+
 #include "gmock/gmock.h"
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
@@ -48,21 +54,22 @@ namespace internal {
 
 // Joins a vector of strings as if they are fields of a tuple; returns
 // the joined string.
-GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
-  switch (fields.size()) {
-    case 0:
-      return "";
-    case 1:
-      return fields[0];
-    default:
-      std::string result = "(" + fields[0];
-      for (size_t i = 1; i < fields.size(); i++) {
-        result += ", ";
-        result += fields[i];
-      }
-      result += ")";
-      return result;
+GTEST_API_ std::string JoinAsKeyValueTuple(
+    const std::vector<const char*>& names, const Strings& values) {
+  GTEST_CHECK_(names.size() == values.size());
+  if (values.empty()) {
+    return "";
   }
+  const auto build_one = [&](const size_t i) {
+    return std::string(names[i]) + ": " + values[i];
+  };
+  std::string result = "(" + build_one(0);
+  for (size_t i = 1; i < values.size(); i++) {
+    result += ", ";
+    result += build_one(i);
+  }
+  result += ")";
+  return result;
 }
 
 // Converts an identifier name to a space-separated list of lower-case
@@ -76,12 +83,11 @@ GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
     // We don't care about the current locale as the input is
     // guaranteed to be a valid C++ identifier name.
     const bool starts_new_word = IsUpper(*p) ||
-        (!IsAlpha(prev_char) && IsLower(*p)) ||
-        (!IsDigit(prev_char) && IsDigit(*p));
+                                 (!IsAlpha(prev_char) && IsLower(*p)) ||
+                                 (!IsDigit(prev_char) && IsDigit(*p));
 
     if (IsAlNum(*p)) {
-      if (starts_new_word && result != "")
-        result += ' ';
+      if (starts_new_word && result != "") result += ' ';
       result += ToLower(*p);
     }
   }
@@ -95,12 +101,9 @@ class GoogleTestFailureReporter : public FailureReporterInterface {
  public:
   void ReportFailure(FailureType type, const char* file, int line,
                      const std::string& message) override {
-    AssertHelper(type == kFatal ?
-                 TestPartResult::kFatalFailure :
-                 TestPartResult::kNonFatalFailure,
-                 file,
-                 line,
-                 message.c_str()) = Message();
+    AssertHelper(type == kFatal ? TestPartResult::kFatalFailure
+                                : TestPartResult::kNonFatalFailure,
+                 file, line, message.c_str()) = Message();
     if (type == kFatal) {
       posix::Abort();
     }
@@ -126,10 +129,10 @@ static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
 // Returns true if and only if a log with the given severity is visible
 // according to the --gmock_verbose flag.
 GTEST_API_ bool LogIsVisible(LogSeverity severity) {
-  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
+  if (GMOCK_FLAG_GET(verbose) == kInfoVerbosity) {
     // Always show the log if --gmock_verbose=info.
     return true;
-  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
+  } else if (GMOCK_FLAG_GET(verbose) == kErrorVerbosity) {
     // Always hide it if --gmock_verbose=error.
     return false;
   } else {
@@ -148,8 +151,7 @@ GTEST_API_ bool LogIsVisible(LogSeverity severity) {
 // conservative.
 GTEST_API_ void Log(LogSeverity severity, const std::string& message,
                     int stack_frames_to_skip) {
-  if (!LogIsVisible(severity))
-    return;
+  if (!LogIsVisible(severity)) return;
 
   // Ensures that logs from different threads don't interleave.
   MutexLock l(&g_log_mutex);
@@ -178,8 +180,8 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
       std::cout << "\n";
     }
     std::cout << "Stack trace:\n"
-         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
-             ::testing::UnitTest::GetInstance(), actual_to_skip);
+              << ::testing::internal::GetCurrentOsStackTraceExceptTop(
+                     actual_to_skip);
   }
   std::cout << ::std::flush;
 }
@@ -196,5 +198,54 @@ GTEST_API_ void IllegalDoDefault(const char* file, int line) {
       "the variable in various places.");
 }
 
+constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
+  return *base64 == 0 ? static_cast<char>(65)
+         : *base64 == c
+             ? carry
+             : UnBase64Impl(c, base64 + 1, static_cast<char>(carry + 1));
+}
+
+template <size_t... I>
+constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
+                                             const char* const base64) {
+  return {{UnBase64Impl(static_cast<char>(I), base64, 0)...}};
+}
+
+constexpr std::array<char, 256> UnBase64(const char* const base64) {
+  return UnBase64Impl(MakeIndexSequence<256>{}, base64);
+}
+
+static constexpr char kBase64[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static constexpr std::array<char, 256> kUnBase64 = UnBase64(kBase64);
+
+bool Base64Unescape(const std::string& encoded, std::string* decoded) {
+  decoded->clear();
+  size_t encoded_len = encoded.size();
+  decoded->reserve(3 * (encoded_len / 4) + (encoded_len % 4));
+  int bit_pos = 0;
+  char dst = 0;
+  for (int src : encoded) {
+    if (std::isspace(src) || src == '=') {
+      continue;
+    }
+    char src_bin = kUnBase64[static_cast<size_t>(src)];
+    if (src_bin >= 64) {
+      decoded->clear();
+      return false;
+    }
+    if (bit_pos == 0) {
+      dst |= static_cast<char>(src_bin << 2);
+      bit_pos = 6;
+    } else {
+      dst |= static_cast<char>(src_bin >> (bit_pos - 2));
+      decoded->push_back(dst);
+      dst = static_cast<char>(src_bin << (10 - bit_pos));
+      bit_pos = (bit_pos + 6) % 8;
+    }
+  }
+  return true;
+}
+
 }  // namespace internal
 }  // namespace testing
diff --git a/googletest/googlemock/src/gmock-matchers.cc b/googletest/googlemock/src/gmock-matchers.cc
index dded437addbaabb7cc7f1972f6ebd1402fdfe1bc..5810b6aa391e9ec186b2420f1506c82f53d84232 100644
--- a/googletest/googlemock/src/gmock-matchers.cc
+++ b/googletest/googlemock/src/gmock-matchers.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements Matcher<const string&>, Matcher<string>, and
@@ -36,9 +35,11 @@
 #include "gmock/gmock-matchers.h"
 
 #include <string.h>
+
 #include <iostream>
 #include <sstream>
 #include <string>
+#include <vector>
 
 namespace testing {
 namespace internal {
@@ -48,11 +49,13 @@ namespace internal {
 // 'negation' is false; otherwise returns the description of the
 // negation of the matcher.  'param_values' contains a list of strings
 // that are the print-out of the matcher's parameters.
-GTEST_API_ std::string FormatMatcherDescription(bool negation,
-                                                const char* matcher_name,
-                                                const Strings& param_values) {
+GTEST_API_ std::string FormatMatcherDescription(
+    bool negation, const char* matcher_name,
+    const std::vector<const char*>& param_names, const Strings& param_values) {
   std::string result = ConvertIdentifierNameToWords(matcher_name);
-  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
+  if (param_values.size() >= 1) {
+    result += " " + JoinAsKeyValueTuple(param_names, param_values);
+  }
   return negation ? "not (" + result + ")" : result;
 }
 
@@ -367,6 +370,23 @@ void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
 bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
     const ::std::vector<std::string>& element_printouts,
     const MatchMatrix& matrix, MatchResultListener* listener) const {
+  if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
+    return true;
+  }
+
+  if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+    if (matrix.LhsSize() != matrix.RhsSize()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container. Otherwise we just need to show
+      // how many elements there actually are.
+      if (matrix.LhsSize() != 0 && listener->IsInterested()) {
+        *listener << "which has " << Elements(matrix.LhsSize());
+      }
+      return false;
+    }
+  }
+
   bool result = true;
   ::std::vector<char> element_matched(matrix.LhsSize(), 0);
   ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
diff --git a/googletest/googlemock/src/gmock-spec-builders.cc b/googletest/googlemock/src/gmock-spec-builders.cc
index c7266a3704b0e54425a28ce20de235c6ef6de709..ea821f855a2a44cb1ee6f33dec7d3bd6cf980e1b 100644
--- a/googletest/googlemock/src/gmock-spec-builders.cc
+++ b/googletest/googlemock/src/gmock-spec-builders.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements the spec builder syntax (ON_CALL and
@@ -42,6 +41,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "gmock/gmock.h"
@@ -49,15 +49,18 @@
 #include "gtest/internal/gtest-port.h"
 
 #if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
-# include <unistd.h>  // NOLINT
+#include <unistd.h>  // NOLINT
+#endif
+#if GTEST_OS_QURT
+#include <qurt_event.h>
 #endif
 
 // Silence C4800 (C4800: 'int *const ': forcing value
 // to bool 'true' or 'false') for MSVC 15
 #ifdef _MSC_VER
 #if _MSC_VER == 1900
-#  pragma warning(push)
-#  pragma warning(disable:4800)
+#pragma warning(push)
+#pragma warning(disable : 4800)
 #endif
 #endif
 
@@ -195,11 +198,12 @@ void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
 
   // Describes the state of the expectation (e.g. is it satisfied?
   // is it active?).
-  *os << " - " << (IsOverSaturated() ? "over-saturated" :
-                   IsSaturated() ? "saturated" :
-                   IsSatisfied() ? "satisfied" : "unsatisfied")
-      << " and "
-      << (is_retired() ? "retired" : "active");
+  *os << " - "
+      << (IsOverSaturated() ? "over-saturated"
+          : IsSaturated()   ? "saturated"
+          : IsSatisfied()   ? "satisfied"
+                            : "unsatisfied")
+      << " and " << (is_retired() ? "retired" : "active");
 }
 
 // Checks the action count (i.e. the number of WillOnce() and
@@ -242,13 +246,12 @@ void ExpectationBase::CheckActionCountIfNotDone() const
 
     ::std::stringstream ss;
     DescribeLocationTo(&ss);
-    ss << "Too " << (too_many ? "many" : "few")
-       << " actions specified in " << source_text() << "...\n"
+    ss << "Too " << (too_many ? "many" : "few") << " actions specified in "
+       << source_text() << "...\n"
        << "Expected to be ";
     cardinality().DescribeTo(&ss);
-    ss << ", but has " << (too_many ? "" : "only ")
-       << action_count << " WillOnce()"
-       << (action_count == 1 ? "" : "s");
+    ss << ", but has " << (too_many ? "" : "only ") << action_count
+       << " WillOnce()" << (action_count == 1 ? "" : "s");
     if (repeated_action_specified_) {
       ss << " and a WillRepeatedly()";
     }
@@ -264,10 +267,10 @@ void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
                        ".Times() cannot appear "
                        "more than once in an EXPECT_CALL().");
   } else {
-    ExpectSpecProperty(last_clause_ < kTimes,
-                       ".Times() cannot appear after "
-                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
-                       "or .RetiresOnSaturation().");
+    ExpectSpecProperty(
+        last_clause_ < kTimes,
+        ".Times() may only appear *before* .InSequence(), .WillOnce(), "
+        ".WillRepeatedly(), or .RetiresOnSaturation(), not after.");
   }
   last_clause_ = kTimes;
 
@@ -283,7 +286,7 @@ GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
 void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
   // Include a stack trace only if --gmock_verbose=info is specified.
   const int stack_frames_to_skip =
-      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
+      GMOCK_FLAG_GET(verbose) == kInfoVerbosity ? 3 : -1;
   switch (reaction) {
     case kAllow:
       Log(kInfo, msg, stack_frames_to_skip);
@@ -295,7 +298,7 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
               "call should not happen.  Do not suppress it by blindly adding "
               "an EXPECT_CALL() if you don't mean to enforce the call.  "
               "See "
-              "https://github.com/google/googletest/blob/master/docs/"
+              "https://github.com/google/googletest/blob/main/docs/"
               "gmock_cook_book.md#"
               "knowing-when-to-expect for details.\n",
           stack_frames_to_skip);
@@ -370,143 +373,12 @@ const char* UntypedFunctionMockerBase::Name() const
   return name;
 }
 
-// Calculates the result of invoking this mock function with the given
-// arguments, prints it, and returns it.  The caller is responsible
-// for deleting the result.
-UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
-    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  // See the definition of untyped_expectations_ for why access to it
-  // is unprotected here.
-  if (untyped_expectations_.size() == 0) {
-    // No expectation is set on this mock method - we have an
-    // uninteresting call.
-
-    // We must get Google Mock's reaction on uninteresting calls
-    // made on this mock object BEFORE performing the action,
-    // because the action may DELETE the mock object and make the
-    // following expression meaningless.
-    const CallReaction reaction =
-        Mock::GetReactionOnUninterestingCalls(MockObject());
-
-    // True if and only if we need to print this call's arguments and return
-    // value.  This definition must be kept in sync with
-    // the behavior of ReportUninterestingCall().
-    const bool need_to_report_uninteresting_call =
-        // If the user allows this uninteresting call, we print it
-        // only when they want informational messages.
-        reaction == kAllow ? LogIsVisible(kInfo) :
-                           // If the user wants this to be a warning, we print
-                           // it only when they want to see warnings.
-            reaction == kWarn
-                ? LogIsVisible(kWarning)
-                :
-                // Otherwise, the user wants this to be an error, and we
-                // should always print detailed information in the error.
-                true;
-
-    if (!need_to_report_uninteresting_call) {
-      // Perform the action without printing the call information.
-      return this->UntypedPerformDefaultAction(
-          untyped_args, "Function call: " + std::string(Name()));
-    }
-
-    // Warns about the uninteresting call.
-    ::std::stringstream ss;
-    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
-
-    // Calculates the function result.
-    UntypedActionResultHolderBase* const result =
-        this->UntypedPerformDefaultAction(untyped_args, ss.str());
-
-    // Prints the function result.
-    if (result != nullptr) result->PrintAsActionResult(&ss);
-
-    ReportUninterestingCall(reaction, ss.str());
-    return result;
-  }
-
-  bool is_excessive = false;
-  ::std::stringstream ss;
-  ::std::stringstream why;
-  ::std::stringstream loc;
-  const void* untyped_action = nullptr;
-
-  // The UntypedFindMatchingExpectation() function acquires and
-  // releases g_gmock_mutex.
-
-  const ExpectationBase* const untyped_expectation =
-      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
-                                           &is_excessive, &ss, &why);
-  const bool found = untyped_expectation != nullptr;
-
-  // True if and only if we need to print the call's arguments
-  // and return value.
-  // This definition must be kept in sync with the uses of Expect()
-  // and Log() in this function.
-  const bool need_to_report_call =
-      !found || is_excessive || LogIsVisible(kInfo);
-  if (!need_to_report_call) {
-    // Perform the action without printing the call information.
-    return untyped_action == nullptr
-               ? this->UntypedPerformDefaultAction(untyped_args, "")
-               : this->UntypedPerformAction(untyped_action, untyped_args);
-  }
-
-  ss << "    Function call: " << Name();
-  this->UntypedPrintArgs(untyped_args, &ss);
-
-  // In case the action deletes a piece of the expectation, we
-  // generate the message beforehand.
-  if (found && !is_excessive) {
-    untyped_expectation->DescribeLocationTo(&loc);
-  }
-
-  UntypedActionResultHolderBase* result = nullptr;
-
-  auto perform_action = [&] {
-    return untyped_action == nullptr
-               ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
-               : this->UntypedPerformAction(untyped_action, untyped_args);
-  };
-  auto handle_failures = [&] {
-    ss << "\n" << why.str();
-
-    if (!found) {
-      // No expectation matches this call - reports a failure.
-      Expect(false, nullptr, -1, ss.str());
-    } else if (is_excessive) {
-      // We had an upper-bound violation and the failure message is in ss.
-      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
-             ss.str());
-    } else {
-      // We had an expected call and the matching expectation is
-      // described in ss.
-      Log(kInfo, loc.str() + ss.str(), 2);
-    }
-  };
-#if GTEST_HAS_EXCEPTIONS
-  try {
-    result = perform_action();
-  } catch (...) {
-    handle_failures();
-    throw;
-  }
-#else
-  result = perform_action();
-#endif
-
-  if (result != nullptr) result->PrintAsActionResult(&ss);
-  handle_failures();
-  return result;
-}
-
 // Returns an Expectation object that references and co-owns exp,
 // which must be an expectation on this mock function.
 Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
   // See the definition of untyped_expectations_ for why access to it
   // is unprotected here.
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
+  for (UntypedExpectations::const_iterator it = untyped_expectations_.begin();
        it != untyped_expectations_.end(); ++it) {
     if (it->get() == exp) {
       return Expectation(*it);
@@ -526,8 +398,7 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
     GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
   g_gmock_mutex.AssertHeld();
   bool expectations_met = true;
-  for (UntypedExpectations::const_iterator it =
-           untyped_expectations_.begin();
+  for (UntypedExpectations::const_iterator it = untyped_expectations_.begin();
        it != untyped_expectations_.end(); ++it) {
     ExpectationBase* const untyped_expectation = it->get();
     if (untyped_expectation->IsOverSaturated()) {
@@ -538,15 +409,22 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
     } else if (!untyped_expectation->IsSatisfied()) {
       expectations_met = false;
       ::std::stringstream ss;
-      ss  << "Actual function call count doesn't match "
-          << untyped_expectation->source_text() << "...\n";
+
+      const ::std::string& expectation_name =
+          untyped_expectation->GetDescription();
+      ss << "Actual function ";
+      if (!expectation_name.empty()) {
+        ss << "\"" << expectation_name << "\" ";
+      }
+      ss << "call count doesn't match " << untyped_expectation->source_text()
+         << "...\n";
       // No need to show the source file location of the expectation
       // in the description, as the Expect() call that follows already
       // takes care of it.
       untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
       untyped_expectation->DescribeCallCountTo(&ss);
-      Expect(false, untyped_expectation->file(),
-             untyped_expectation->line(), ss.str());
+      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
+             ss.str());
     }
   }
 
@@ -567,7 +445,7 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
   return expectations_met;
 }
 
-CallReaction intToCallReaction(int mock_behavior) {
+static CallReaction intToCallReaction(int mock_behavior) {
   if (mock_behavior >= kAllow && mock_behavior <= kFail) {
     return static_cast<internal::CallReaction>(mock_behavior);
   }
@@ -613,8 +491,7 @@ class MockObjectRegistry {
   // object alive.  Therefore we report any living object as test
   // failure, unless the user explicitly asked us to ignore it.
   ~MockObjectRegistry() {
-    if (!GMOCK_FLAG(catch_leaked_mocks))
-      return;
+    if (!GMOCK_FLAG_GET(catch_leaked_mocks)) return;
 
     int leaked_count = 0;
     for (StateMap::const_iterator it = states_.begin(); it != states_.end();
@@ -634,7 +511,7 @@ class MockObjectRegistry {
                   << state.first_used_test << ")";
       }
       std::cout << " should be deleted but never is. Its address is @"
-           << it->first << ".";
+                << it->first << ".";
       leaked_count++;
     }
     if (leaked_count > 0) {
@@ -652,8 +529,12 @@ class MockObjectRegistry {
       // RUN_ALL_TESTS() has already returned when this destructor is
       // called.  Therefore we cannot use the normal Google Test
       // failure reporting mechanism.
+#if GTEST_OS_QURT
+      qurt_exception_raise_fatal();
+#else
       _exit(1);  // We cannot call exit() as it is not reentrant and
                  // may already have been called.
+#endif
     }
   }
 
@@ -668,57 +549,63 @@ MockObjectRegistry g_mock_object_registry;
 
 // Maps a mock object to the reaction Google Mock should have when an
 // uninteresting method is called.  Protected by g_gmock_mutex.
-std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
+std::unordered_map<uintptr_t, internal::CallReaction>&
+UninterestingCallReactionMap() {
+  static auto* map = new std::unordered_map<uintptr_t, internal::CallReaction>;
+  return *map;
+}
 
 // Sets the reaction Google Mock should have when an uninteresting
 // method of the given mock object is called.
-void SetReactionOnUninterestingCalls(const void* mock_obj,
+void SetReactionOnUninterestingCalls(uintptr_t mock_obj,
                                      internal::CallReaction reaction)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction[mock_obj] = reaction;
+  UninterestingCallReactionMap()[mock_obj] = reaction;
 }
 
 }  // namespace
 
 // Tells Google Mock to allow uninteresting calls on the given mock
 // object.
-void Mock::AllowUninterestingCalls(const void* mock_obj)
+void Mock::AllowUninterestingCalls(uintptr_t mock_obj)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
 }
 
 // Tells Google Mock to warn the user about uninteresting calls on the
 // given mock object.
-void Mock::WarnUninterestingCalls(const void* mock_obj)
+void Mock::WarnUninterestingCalls(uintptr_t mock_obj)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
 }
 
 // Tells Google Mock to fail uninteresting calls on the given mock
 // object.
-void Mock::FailUninterestingCalls(const void* mock_obj)
+void Mock::FailUninterestingCalls(uintptr_t mock_obj)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
 }
 
 // Tells Google Mock the given mock object is being destroyed and its
 // entry in the call-reaction table should be removed.
-void Mock::UnregisterCallReaction(const void* mock_obj)
+void Mock::UnregisterCallReaction(uintptr_t mock_obj)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   internal::MutexLock l(&internal::g_gmock_mutex);
-  g_uninteresting_call_reaction.erase(mock_obj);
+  UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj));
 }
 
 // Returns the reaction Google Mock will have on uninteresting calls
 // made on the given mock object.
 internal::CallReaction Mock::GetReactionOnUninterestingCalls(
-    const void* mock_obj)
-        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+    const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   internal::MutexLock l(&internal::g_gmock_mutex);
-  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
-      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
-      g_uninteresting_call_reaction[mock_obj];
+  return (UninterestingCallReactionMap().count(
+              reinterpret_cast<uintptr_t>(mock_obj)) == 0)
+             ? internal::intToCallReaction(
+                   GMOCK_FLAG_GET(default_mock_behavior))
+             : UninterestingCallReactionMap()[reinterpret_cast<uintptr_t>(
+                   mock_obj)];
 }
 
 // Tells Google Mock to ignore mock_obj when checking for leaked mock
@@ -873,8 +760,8 @@ Expectation::~Expectation() {}
 void Sequence::AddExpectation(const Expectation& expectation) const {
   if (*last_expectation_ != expectation) {
     if (last_expectation_->expectation_base() != nullptr) {
-      expectation.expectation_base()->immediate_prerequisites_
-          += *last_expectation_;
+      expectation.expectation_base()->immediate_prerequisites_ +=
+          *last_expectation_;
     }
     *last_expectation_ = expectation;
   }
@@ -903,6 +790,6 @@ InSequence::~InSequence() {
 
 #ifdef _MSC_VER
 #if _MSC_VER == 1900
-#  pragma warning(pop)
+#pragma warning(pop)
 #endif
 #endif
diff --git a/googletest/googlemock/src/gmock.cc b/googletest/googlemock/src/gmock.cc
index 7bcdb0ba2dfca27676a81dda7791ace699516e31..5025656a02a30a7258d90613ecf3e4bffd46f887 100644
--- a/googletest/googlemock/src/gmock.cc
+++ b/googletest/googlemock/src/gmock.cc
@@ -27,17 +27,15 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gmock/gmock.h"
-#include "gmock/internal/gmock-port.h"
 
-namespace testing {
+#include "gmock/internal/gmock-port.h"
 
 GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
                    "true if and only if Google Mock should report leaked "
                    "mock objects as failures.");
 
-GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
+GMOCK_DEFINE_string_(verbose, testing::internal::kWarningVerbosity,
                      "Controls how verbose Google Mock's output is."
                      "  Valid values:\n"
                      "  info    - prints all messages.\n"
@@ -51,6 +49,7 @@ GMOCK_DEFINE_int32_(default_mock_behavior, 1,
                     "  1 - by default, mocks act as NaggyMocks.\n"
                     "  2 - by default, mocks act as StrictMocks.");
 
+namespace testing {
 namespace internal {
 
 // Parses a string as a command line flag.  The string should have the
@@ -59,18 +58,18 @@ namespace internal {
 //
 // Returns the value of the flag, or NULL if the parsing failed.
 static const char* ParseGoogleMockFlagValue(const char* str,
-                                            const char* flag,
+                                            const char* flag_name,
                                             bool def_optional) {
   // str and flag must not be NULL.
-  if (str == nullptr || flag == nullptr) return nullptr;
+  if (str == nullptr || flag_name == nullptr) return nullptr;
 
   // The flag must start with "--gmock_".
-  const std::string flag_str = std::string("--gmock_") + flag;
-  const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+  const std::string flag_name_str = std::string("--gmock_") + flag_name;
+  const size_t flag_name_len = flag_name_str.length();
+  if (strncmp(str, flag_name_str.c_str(), flag_name_len) != 0) return nullptr;
 
   // Skips the flag name.
-  const char* flag_end = str + flag_len;
+  const char* flag_end = str + flag_name_len;
 
   // When def_optional is true, it's OK to not have a "=value" part.
   if (def_optional && (flag_end[0] == '\0')) {
@@ -91,10 +90,10 @@ static const char* ParseGoogleMockFlagValue(const char* str,
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
-                                    bool* value) {
+static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
+                                bool* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
@@ -110,10 +109,10 @@ static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
 template <typename String>
-static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
-                                      String* value) {
+static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
+                                String* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, false);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
@@ -123,17 +122,17 @@ static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
   return true;
 }
 
-static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
-                                   int32_t* value) {
+static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
+                                int32_t* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag_name, true);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
 
   // Sets *value to the value of the flag.
-  return ParseInt32(Message() << "The value of flag --" << flag,
-                    value_str, value);
+  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
+                    value);
 }
 
 // The internal implementation of InitGoogleMock().
@@ -152,11 +151,22 @@ void InitGoogleMockImpl(int* argc, CharType** argv) {
     const char* const arg = arg_string.c_str();
 
     // Do we see a Google Mock flag?
-    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
-                                &GMOCK_FLAG(catch_leaked_mocks)) ||
-        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
-        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
-                               &GMOCK_FLAG(default_mock_behavior))) {
+    bool found_gmock_flag = false;
+
+#define GMOCK_INTERNAL_PARSE_FLAG(flag_name)            \
+  if (!found_gmock_flag) {                              \
+    auto value = GMOCK_FLAG_GET(flag_name);             \
+    if (ParseGoogleMockFlag(arg, #flag_name, &value)) { \
+      GMOCK_FLAG_SET(flag_name, value);                 \
+      found_gmock_flag = true;                          \
+    }                                                   \
+  }
+
+    GMOCK_INTERNAL_PARSE_FLAG(catch_leaked_mocks)
+    GMOCK_INTERNAL_PARSE_FLAG(verbose)
+    GMOCK_INTERNAL_PARSE_FLAG(default_mock_behavior)
+
+    if (found_gmock_flag) {
       // Yes.  Shift the remainder of the argv list left by one.  Note
       // that argv has (*argc + 1) elements, the last one always being
       // NULL.  The following loop moves the trailing NULL element as
diff --git a/googletest/googlemock/src/gmock_main.cc b/googletest/googlemock/src/gmock_main.cc
index a98aaad807e9aa8b64aa82e6458ce3e8ad03d9ed..37c1ab4e8d25daa56f3daf70e91416c670a0680c 100644
--- a/googletest/googlemock/src/gmock_main.cc
+++ b/googletest/googlemock/src/gmock_main.cc
@@ -27,8 +27,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include <iostream>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -56,7 +56,7 @@ void loop() { RUN_ALL_TESTS(); }
 // https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library
 // // NOLINT
 #if GTEST_OS_WINDOWS_MOBILE
-# include <tchar.h>  // NOLINT
+#include <tchar.h>  // NOLINT
 
 GTEST_API_ int _tmain(int argc, TCHAR** argv) {
 #else
diff --git a/googletest/googlemock/test/BUILD.bazel b/googletest/googlemock/test/BUILD.bazel
index efb7306b22627f9c0fe14b121f9dc60e2500cca0..d4297c80fe8d182bd5675a26701bd97497d82dd5 100644
--- a/googletest/googlemock/test/BUILD.bazel
+++ b/googletest/googlemock/test/BUILD.bazel
@@ -30,7 +30,6 @@
 #
 #   Bazel Build for Google C++ Testing Framework(Google Test)-googlemock
 
-load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
 load("@rules_python//python:defs.bzl", "py_library", "py_test")
 
 licenses(["notice"])
@@ -39,8 +38,9 @@ licenses(["notice"])
 cc_test(
     name = "gmock_all_test",
     size = "small",
-    srcs = glob(include = ["gmock-*.cc"]),
+    srcs = glob(include = ["gmock-*.cc"]) + ["gmock-matchers_test.h"],
     linkopts = select({
+        "//:qnx": [],
         "//:windows": [],
         "//conditions:default": ["-pthread"],
     }),
diff --git a/googletest/googlemock/test/gmock-actions_test.cc b/googletest/googlemock/test/gmock-actions_test.cc
index e1ca7fe2ddb8adc4f4dd60a8964386089439c0b7..510d15c8de7d548405afdefa55d8033df364702b 100644
--- a/googletest/googlemock/test/gmock-actions_test.cc
+++ b/googletest/googlemock/test/gmock-actions_test.cc
@@ -27,64 +27,230 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the built-in actions.
 
-// Silence C4100 (unreferenced formal parameter) for MSVC
+// Silence C4100 (unreferenced formal parameter) and C4503 (decorated name
+// length exceeded) for MSVC.
 #ifdef _MSC_VER
-#  pragma warning(push)
-#  pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#pragma warning(disable : 4503)
 #if _MSC_VER == 1900
 // and silence C4800 (C4800: 'int *const ': forcing value
 // to bool 'true' or 'false') for MSVC 15
-#  pragma warning(disable:4800)
+#pragma warning(disable : 4800)
 #endif
 #endif
 
 #include "gmock/gmock-actions.h"
+
 #include <algorithm>
+#include <functional>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <type_traits>
+#include <vector>
+
 #include "gmock/gmock.h"
 #include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 
+namespace testing {
 namespace {
 
-using ::testing::_;
-using ::testing::Action;
-using ::testing::ActionInterface;
-using ::testing::Assign;
-using ::testing::ByMove;
-using ::testing::ByRef;
-using ::testing::DefaultValue;
-using ::testing::DoAll;
-using ::testing::DoDefault;
-using ::testing::IgnoreResult;
-using ::testing::Invoke;
-using ::testing::InvokeWithoutArgs;
-using ::testing::MakePolymorphicAction;
-using ::testing::PolymorphicAction;
-using ::testing::Return;
-using ::testing::ReturnNew;
-using ::testing::ReturnNull;
-using ::testing::ReturnRef;
-using ::testing::ReturnRefOfCopy;
-using ::testing::ReturnRoundRobin;
-using ::testing::SetArgPointee;
-using ::testing::SetArgumentPointee;
-using ::testing::Unused;
-using ::testing::WithArgs;
 using ::testing::internal::BuiltInDefaultValue;
 
-#if !GTEST_OS_WINDOWS_MOBILE
-using ::testing::SetErrnoAndReturn;
-#endif
+TEST(TypeTraits, Negation) {
+  // Direct use with std types.
+  static_assert(std::is_base_of<std::false_type,
+                                internal::negation<std::true_type>>::value,
+                "");
+
+  static_assert(std::is_base_of<std::true_type,
+                                internal::negation<std::false_type>>::value,
+                "");
+
+  // With other types that fit the requirement of a value member that is
+  // convertible to bool.
+  static_assert(std::is_base_of<
+                    std::true_type,
+                    internal::negation<std::integral_constant<int, 0>>>::value,
+                "");
+
+  static_assert(std::is_base_of<
+                    std::false_type,
+                    internal::negation<std::integral_constant<int, 1>>>::value,
+                "");
+
+  static_assert(std::is_base_of<
+                    std::false_type,
+                    internal::negation<std::integral_constant<int, -1>>>::value,
+                "");
+}
+
+// Weird false/true types that aren't actually bool constants (but should still
+// be legal according to [meta.logical] because `bool(T::value)` is valid), are
+// distinct from std::false_type and std::true_type, and are distinct from other
+// instantiations of the same template.
+//
+// These let us check finicky details mandated by the standard like
+// "std::conjunction should evaluate to a type that inherits from the first
+// false-y input".
+template <int>
+struct MyFalse : std::integral_constant<int, 0> {};
+
+template <int>
+struct MyTrue : std::integral_constant<int, -1> {};
+
+TEST(TypeTraits, Conjunction) {
+  // Base case: always true.
+  static_assert(std::is_base_of<std::true_type, internal::conjunction<>>::value,
+                "");
+
+  // One predicate: inherits from that predicate, regardless of value.
+  static_assert(
+      std::is_base_of<MyFalse<0>, internal::conjunction<MyFalse<0>>>::value,
+      "");
+
+  static_assert(
+      std::is_base_of<MyTrue<0>, internal::conjunction<MyTrue<0>>>::value, "");
+
+  // Multiple predicates, with at least one false: inherits from that one.
+  static_assert(
+      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+                                                        MyTrue<2>>>::value,
+      "");
+
+  static_assert(
+      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+                                                        MyFalse<2>>>::value,
+      "");
+
+  // Short circuiting: in the case above, additional predicates need not even
+  // define a value member.
+  struct Empty {};
+  static_assert(
+      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+                                                        Empty>>::value,
+      "");
+
+  // All predicates true: inherits from the last.
+  static_assert(
+      std::is_base_of<MyTrue<2>, internal::conjunction<MyTrue<0>, MyTrue<1>,
+                                                       MyTrue<2>>>::value,
+      "");
+}
+
+TEST(TypeTraits, Disjunction) {
+  // Base case: always false.
+  static_assert(
+      std::is_base_of<std::false_type, internal::disjunction<>>::value, "");
+
+  // One predicate: inherits from that predicate, regardless of value.
+  static_assert(
+      std::is_base_of<MyFalse<0>, internal::disjunction<MyFalse<0>>>::value,
+      "");
+
+  static_assert(
+      std::is_base_of<MyTrue<0>, internal::disjunction<MyTrue<0>>>::value, "");
+
+  // Multiple predicates, with at least one true: inherits from that one.
+  static_assert(
+      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+                                                       MyFalse<2>>>::value,
+      "");
+
+  static_assert(
+      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+                                                       MyTrue<2>>>::value,
+      "");
+
+  // Short circuiting: in the case above, additional predicates need not even
+  // define a value member.
+  struct Empty {};
+  static_assert(
+      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+                                                       Empty>>::value,
+      "");
+
+  // All predicates false: inherits from the last.
+  static_assert(
+      std::is_base_of<MyFalse<2>, internal::disjunction<MyFalse<0>, MyFalse<1>,
+                                                        MyFalse<2>>>::value,
+      "");
+}
+
+TEST(TypeTraits, IsInvocableRV) {
+  struct C {
+    int operator()() const { return 0; }
+    void operator()(int) & {}
+    std::string operator()(int) && { return ""; };
+  };
+
+  // The first overload is callable for const and non-const rvalues and lvalues.
+  // It can be used to obtain an int, cv void, or anything int is convertible
+  // to.
+  static_assert(internal::is_callable_r<int, C>::value, "");
+  static_assert(internal::is_callable_r<int, C&>::value, "");
+  static_assert(internal::is_callable_r<int, const C>::value, "");
+  static_assert(internal::is_callable_r<int, const C&>::value, "");
+
+  static_assert(internal::is_callable_r<void, C>::value, "");
+  static_assert(internal::is_callable_r<const volatile void, C>::value, "");
+  static_assert(internal::is_callable_r<char, C>::value, "");
+
+  // It's possible to provide an int. If it's given to an lvalue, the result is
+  // void. Otherwise it is std::string (which is also treated as allowed for a
+  // void result type).
+  static_assert(internal::is_callable_r<void, C&, int>::value, "");
+  static_assert(!internal::is_callable_r<int, C&, int>::value, "");
+  static_assert(!internal::is_callable_r<std::string, C&, int>::value, "");
+  static_assert(!internal::is_callable_r<void, const C&, int>::value, "");
+
+  static_assert(internal::is_callable_r<std::string, C, int>::value, "");
+  static_assert(internal::is_callable_r<void, C, int>::value, "");
+  static_assert(!internal::is_callable_r<int, C, int>::value, "");
+
+  // It's not possible to provide other arguments.
+  static_assert(!internal::is_callable_r<void, C, std::string>::value, "");
+  static_assert(!internal::is_callable_r<void, C, int, int>::value, "");
+
+  // In C++17 and above, where it's guaranteed that functions can return
+  // non-moveable objects, everything should work fine for non-moveable rsult
+  // types too.
+#if defined(__cplusplus) && __cplusplus >= 201703L
+  {
+    struct NonMoveable {
+      NonMoveable() = default;
+      NonMoveable(NonMoveable&&) = delete;
+    };
+
+    static_assert(!std::is_move_constructible_v<NonMoveable>);
+
+    struct Callable {
+      NonMoveable operator()() { return NonMoveable(); }
+    };
+
+    static_assert(internal::is_callable_r<NonMoveable, Callable>::value);
+    static_assert(internal::is_callable_r<void, Callable>::value);
+    static_assert(
+        internal::is_callable_r<const volatile void, Callable>::value);
+
+    static_assert(!internal::is_callable_r<int, Callable>::value);
+    static_assert(!internal::is_callable_r<NonMoveable, Callable, int>::value);
+  }
+#endif  // C++17 and above
+
+  // Nothing should choke when we try to call other arguments besides directly
+  // callable objects, but they should not show up as callable.
+  static_assert(!internal::is_callable_r<void, int>::value, "");
+  static_assert(!internal::is_callable_r<void, void (C::*)()>::value, "");
+  static_assert(!internal::is_callable_r<void, void (C::*)(), C*>::value, "");
+}
 
 // Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
 TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
@@ -114,17 +280,17 @@ TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
 #endif
 #endif
   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());     // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());            // NOLINT
   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
-  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());       // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());          // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());                 // NOLINT
   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<signed long long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<long long>::Get());  // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<signed long long>::Get());     // NOLINT
+  EXPECT_EQ(0, BuiltInDefaultValue<long long>::Get());            // NOLINT
   EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
 }
@@ -139,17 +305,17 @@ TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
   EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
 #endif
   EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());    // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());           // NOLINT
   EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
   EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
   EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
-  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());       // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());         // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());                // NOLINT
   EXPECT_TRUE(BuiltInDefaultValue<unsigned long long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<signed long long>::Exists());  // NOLINT
-  EXPECT_TRUE(BuiltInDefaultValue<long long>::Exists());  // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<signed long long>::Exists());    // NOLINT
+  EXPECT_TRUE(BuiltInDefaultValue<long long>::Exists());           // NOLINT
   EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
   EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
 }
@@ -167,13 +333,13 @@ TEST(BuiltInDefaultValueTest, BoolExists) {
 // Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
 // string type.
 TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
-  EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
+  EXPECT_EQ("", BuiltInDefaultValue<::std::string>::Get());
 }
 
 // Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
 // string type.
 TEST(BuiltInDefaultValueTest, ExistsForString) {
-  EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
+  EXPECT_TRUE(BuiltInDefaultValue<::std::string>::Exists());
 }
 
 // Tests that BuiltInDefaultValue<const T>::Get() returns the same
@@ -208,7 +374,6 @@ class MyNonDefaultConstructible {
   int value_;
 };
 
-
 TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
   EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
 }
@@ -217,25 +382,19 @@ TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
   EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
 }
 
-
 TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
   EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
 }
 
 // Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<int&>::Get();
-  }, "");
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<const char&>::Get();
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ BuiltInDefaultValue<int&>::Get(); }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ BuiltInDefaultValue<const char&>::Get(); }, "");
 }
 
 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      { BuiltInDefaultValue<MyNonDefaultConstructible>::Get(); }, "");
 }
 
 // Tests that DefaultValue<T>::IsSet() is false initially.
@@ -281,26 +440,22 @@ TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
 
   EXPECT_EQ(0, DefaultValue<int>::Get());
 
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
+                            "");
 }
 
 TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
-  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
-    return std::unique_ptr<int>(new int(42));
-  });
+  DefaultValue<std::unique_ptr<int>>::SetFactory(
+      [] { return std::unique_ptr<int>(new int(42)); });
   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
   std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
   EXPECT_EQ(42, *i);
 }
 
 // Tests that DefaultValue<void>::Get() returns void.
-TEST(DefaultValueTest, GetWorksForVoid) {
-  return DefaultValue<void>::Get();
-}
+TEST(DefaultValueTest, GetWorksForVoid) { return DefaultValue<void>::Get(); }
 
 // Tests using DefaultValue with a reference type.
 
@@ -311,7 +466,7 @@ TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
 }
 
-// Tests that DefaultValue<T&>::Exists is false initiallly.
+// Tests that DefaultValue<T&>::Exists is false initially.
 TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
   EXPECT_FALSE(DefaultValue<int&>::Exists());
   EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
@@ -348,12 +503,9 @@ TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
   EXPECT_FALSE(DefaultValue<int&>::IsSet());
   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
 
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<int&>::Get();
-  }, "");
-  EXPECT_DEATH_IF_SUPPORTED({
-    DefaultValue<MyNonDefaultConstructible>::Get();
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<int&>::Get(); }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
+                            "");
 }
 
 // Tests that ActionInterface can be implemented by defining the
@@ -384,7 +536,7 @@ TEST(ActionInterfaceTest, MakeAction) {
   EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
 }
 
-// Tests that Action<F> can be contructed from a pointer to
+// Tests that Action<F> can be constructed from a pointer to
 // ActionInterface<F>.
 TEST(ActionTest, CanBeConstructedFromActionInterface) {
   Action<MyGlobalFunction> action(new MyActionImpl);
@@ -433,7 +585,7 @@ class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
 };
 
 TEST(ActionTest, CanBeConvertedToOtherActionType) {
-  const Action<bool(int)> a1(new IsNotZero);  // NOLINT
+  const Action<bool(int)> a1(new IsNotZero);           // NOLINT
   const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
   EXPECT_EQ(1, a2.Perform(std::make_tuple('a')));
   EXPECT_EQ(0, a2.Perform(std::make_tuple('\0')));
@@ -525,27 +677,137 @@ TEST(ReturnTest, AcceptsStringLiteral) {
   EXPECT_EQ("world", a2.Perform(std::make_tuple()));
 }
 
-// Test struct which wraps a vector of integers. Used in
-// 'SupportsWrapperReturnType' test.
-struct IntegerVectorWrapper {
-  std::vector<int> * v;
-  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
-};
+// Return(x) should work fine when the mock function's return type is a
+// reference-like wrapper for decltype(x), as when x is a std::string and the
+// mock function returns std::string_view.
+TEST(ReturnTest, SupportsReferenceLikeReturnType) {
+  // A reference wrapper for std::vector<int>, implicitly convertible from it.
+  struct Result {
+    const std::vector<int>* v;
+    Result(const std::vector<int>& vec) : v(&vec) {}  // NOLINT
+  };
+
+  // Set up an action for a mock function that returns the reference wrapper
+  // type, initializing it with an actual vector.
+  //
+  // The returned wrapper should be initialized with a copy of that vector
+  // that's embedded within the action itself (which should stay alive as long
+  // as the mock object is alive), rather than e.g. a reference to the temporary
+  // we feed to Return. This should work fine both for WillOnce and
+  // WillRepeatedly.
+  MockFunction<Result()> mock;
+  EXPECT_CALL(mock, Call)
+      .WillOnce(Return(std::vector<int>{17, 19, 23}))
+      .WillRepeatedly(Return(std::vector<int>{29, 31, 37}));
 
-// Tests that Return() works when return type is a wrapper type.
-TEST(ReturnTest, SupportsWrapperReturnType) {
-  // Initialize vector of integers.
-  std::vector<int> v;
-  for (int i = 0; i < 5; ++i) v.push_back(i);
+  EXPECT_THAT(mock.AsStdFunction()(),
+              Field(&Result::v, Pointee(ElementsAre(17, 19, 23))));
 
-  // Return() called with 'v' as argument. The Action will return the same data
-  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
-  Action<IntegerVectorWrapper()> a = Return(v);
-  const std::vector<int>& result = *(a.Perform(std::make_tuple()).v);
-  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
+  EXPECT_THAT(mock.AsStdFunction()(),
+              Field(&Result::v, Pointee(ElementsAre(29, 31, 37))));
 }
 
-// Tests that Return(v) is covaraint.
+TEST(ReturnTest, PrefersConversionOperator) {
+  // Define types In and Out such that:
+  //
+  //  *  In is implicitly convertible to Out.
+  //  *  Out also has an explicit constructor from In.
+  //
+  struct In;
+  struct Out {
+    int x;
+
+    explicit Out(const int val) : x(val) {}
+    explicit Out(const In&) : x(0) {}
+  };
+
+  struct In {
+    operator Out() const { return Out{19}; }  // NOLINT
+  };
+
+  // Assumption check: the C++ language rules are such that a function that
+  // returns Out which uses In a return statement will use the implicit
+  // conversion path rather than the explicit constructor.
+  EXPECT_THAT([]() -> Out { return In(); }(), Field(&Out::x, 19));
+
+  // Return should work the same way: if the mock function's return type is Out
+  // and we feed Return an In value, then the Out should be created through the
+  // implicit conversion path rather than the explicit constructor.
+  MockFunction<Out()> mock;
+  EXPECT_CALL(mock, Call).WillOnce(Return(In()));
+  EXPECT_THAT(mock.AsStdFunction()(), Field(&Out::x, 19));
+}
+
+// It should be possible to use Return(R) with a mock function result type U
+// that is convertible from const R& but *not* R (such as
+// std::reference_wrapper). This should work for both WillOnce and
+// WillRepeatedly.
+TEST(ReturnTest, ConversionRequiresConstLvalueReference) {
+  using R = int;
+  using U = std::reference_wrapper<const int>;
+
+  static_assert(std::is_convertible<const R&, U>::value, "");
+  static_assert(!std::is_convertible<R, U>::value, "");
+
+  MockFunction<U()> mock;
+  EXPECT_CALL(mock, Call).WillOnce(Return(17)).WillRepeatedly(Return(19));
+
+  EXPECT_EQ(17, mock.AsStdFunction()());
+  EXPECT_EQ(19, mock.AsStdFunction()());
+}
+
+// Return(x) should not be usable with a mock function result type that's
+// implicitly convertible from decltype(x) but requires a non-const lvalue
+// reference to the input. It doesn't make sense for the conversion operator to
+// modify the input.
+TEST(ReturnTest, ConversionRequiresMutableLvalueReference) {
+  // Set up a type that is implicitly convertible from std::string&, but not
+  // std::string&& or `const std::string&`.
+  //
+  // Avoid asserting about conversion from std::string on MSVC, which seems to
+  // implement std::is_convertible incorrectly in this case.
+  struct S {
+    S(std::string&) {}  // NOLINT
+  };
+
+  static_assert(std::is_convertible<std::string&, S>::value, "");
+#ifndef _MSC_VER
+  static_assert(!std::is_convertible<std::string&&, S>::value, "");
+#endif
+  static_assert(!std::is_convertible<const std::string&, S>::value, "");
+
+  // It shouldn't be possible to use the result of Return(std::string) in a
+  // context where an S is needed.
+  //
+  // Here too we disable the assertion for MSVC, since its incorrect
+  // implementation of is_convertible causes our SFINAE to be wrong.
+  using RA = decltype(Return(std::string()));
+
+  static_assert(!std::is_convertible<RA, Action<S()>>::value, "");
+#ifndef _MSC_VER
+  static_assert(!std::is_convertible<RA, OnceAction<S()>>::value, "");
+#endif
+}
+
+TEST(ReturnTest, MoveOnlyResultType) {
+  // Return should support move-only result types when used with WillOnce.
+  {
+    MockFunction<std::unique_ptr<int>()> mock;
+    EXPECT_CALL(mock, Call)
+        // NOLINTNEXTLINE
+        .WillOnce(Return(std::unique_ptr<int>(new int(17))));
+
+    EXPECT_THAT(mock.AsStdFunction()(), Pointee(17));
+  }
+
+  // The result of Return should not be convertible to Action (so it can't be
+  // used with WillRepeatedly).
+  static_assert(!std::is_convertible<decltype(Return(std::unique_ptr<int>())),
+                                     Action<std::unique_ptr<int>()>>::value,
+                "");
+}
+
+// Tests that Return(v) is covariant.
 
 struct Base {
   bool operator==(const Base&) { return true; }
@@ -596,19 +858,6 @@ TEST(ReturnTest, ConvertsArgumentWhenConverted) {
                           << "when performed.";
 }
 
-class DestinationType {};
-
-class SourceType {
- public:
-  // Note: a non-const typecast operator.
-  operator DestinationType() { return DestinationType(); }
-};
-
-TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
-  SourceType s;
-  Action<DestinationType()> action(Return(s));
-}
-
 // Tests that ReturnNull() returns NULL in a pointer-returning function.
 TEST(ReturnNullTest, WorksInPointerReturningFunction) {
   const Action<int*()> a1 = ReturnNull();
@@ -648,7 +897,9 @@ TEST(ReturnRefTest, IsCovariant) {
 }
 
 template <typename T, typename = decltype(ReturnRef(std::declval<T&&>()))>
-bool CanCallReturnRef(T&&) { return true; }
+bool CanCallReturnRef(T&&) {
+  return true;
+}
 bool CanCallReturnRef(Unused) { return false; }
 
 // Tests that ReturnRef(v) is working with non-temporaries (T&)
@@ -668,7 +919,7 @@ TEST(ReturnRefTest, WorksForNonTemporary) {
 
 // Tests that ReturnRef(v) is not working with temporaries (T&&)
 TEST(ReturnRefTest, DoesNotWorkForTemporary) {
-  auto scalar_value = []()  -> int { return 123; };
+  auto scalar_value = []() -> int { return 123; };
   EXPECT_FALSE(CanCallReturnRef(scalar_value()));
 
   auto non_scalar_value = []() -> std::string { return "ABC"; };
@@ -747,15 +998,15 @@ class MockClass {
                int(const std::unique_ptr<int>&, std::unique_ptr<int>));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
+  MockClass(const MockClass&) = delete;
+  MockClass& operator=(const MockClass&) = delete;
 };
 
 // Tests that DoDefault() returns the built-in default value for the
 // return type by default.
 TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
   MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
+  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
   EXPECT_EQ(0, mock.IntFunc(true));
 }
 
@@ -763,14 +1014,11 @@ TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
 // the process when there is no built-in default value for the return type.
 TEST(DoDefaultDeathTest, DiesForUnknowType) {
   MockClass mock;
-  EXPECT_CALL(mock, Foo())
-      .WillRepeatedly(DoDefault());
+  EXPECT_CALL(mock, Foo()).WillRepeatedly(DoDefault());
 #if GTEST_HAS_EXCEPTIONS
   EXPECT_ANY_THROW(mock.Foo());
 #else
-  EXPECT_DEATH_IF_SUPPORTED({
-    mock.Foo();
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ mock.Foo(); }, "");
 #endif
 }
 
@@ -782,16 +1030,13 @@ void VoidFunc(bool /* flag */) {}
 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
   MockClass mock;
   EXPECT_CALL(mock, IntFunc(_))
-      .WillRepeatedly(DoAll(Invoke(VoidFunc),
-                            DoDefault()));
+      .WillRepeatedly(DoAll(Invoke(VoidFunc), DoDefault()));
 
   // Ideally we should verify the error message as well.  Sadly,
   // EXPECT_DEATH() can only capture stderr, while Google Mock's
   // errors are printed on stdout.  Therefore we have to settle for
   // not verifying the message.
-  EXPECT_DEATH_IF_SUPPORTED({
-    mock.IntFunc(true);
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ mock.IntFunc(true); }, "");
 }
 
 // Tests that DoDefault() returns the default value set by
@@ -799,8 +1044,7 @@ TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
 TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
   DefaultValue<int>::Set(1);
   MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
+  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
   EXPECT_EQ(1, mock.IntFunc(false));
   DefaultValue<int>::Clear();
 }
@@ -808,20 +1052,19 @@ TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
 // Tests that DoDefault() does the action specified by ON_CALL().
 TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
   MockClass mock;
-  ON_CALL(mock, IntFunc(_))
-      .WillByDefault(Return(2));
-  EXPECT_CALL(mock, IntFunc(_))
-      .WillOnce(DoDefault());
+  ON_CALL(mock, IntFunc(_)).WillByDefault(Return(2));
+  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
   EXPECT_EQ(2, mock.IntFunc(false));
 }
 
 // Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
 TEST(DoDefaultTest, CannotBeUsedInOnCall) {
   MockClass mock;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(mock, IntFunc(_))
-      .WillByDefault(DoDefault());
-  }, "DoDefault() cannot be used in ON_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        ON_CALL(mock, IntFunc(_)).WillByDefault(DoDefault());
+      },
+      "DoDefault() cannot be used in ON_CALL()");
 }
 
 // Tests that SetArgPointee<N>(v) sets the variable pointed to by
@@ -868,7 +1111,7 @@ TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
   a.Perform(std::make_tuple(&ptr));
   EXPECT_STREQ(L"world", ptr);
 
-# if GTEST_HAS_STD_WSTRING
+#if GTEST_HAS_STD_WSTRING
 
   typedef void MyStringFunction(std::wstring*);
   Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
@@ -876,7 +1119,7 @@ TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
   a2.Perform(std::make_tuple(&str));
   EXPECT_EQ(L"world", str);
 
-# endif
+#endif
 }
 
 // Tests that SetArgPointee<N>() accepts a char pointer.
@@ -907,7 +1150,7 @@ TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
   a.Perform(std::make_tuple(true, &ptr));
   EXPECT_EQ(hi, ptr);
 
-# if GTEST_HAS_STD_WSTRING
+#if GTEST_HAS_STD_WSTRING
 
   typedef void MyStringFunction(bool, std::wstring*);
   wchar_t world_array[] = L"world";
@@ -916,7 +1159,7 @@ TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
   std::wstring str;
   a2.Perform(std::make_tuple(true, &str));
   EXPECT_EQ(world_array, str);
-# endif
+#endif
 }
 
 // Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
@@ -1079,6 +1322,159 @@ TEST(AssignTest, CompatibleTypes) {
   EXPECT_DOUBLE_EQ(5, x);
 }
 
+// DoAll should support &&-qualified actions when used with WillOnce.
+TEST(DoAll, SupportsRefQualifiedActions) {
+  struct InitialAction {
+    void operator()(const int arg) && { EXPECT_EQ(17, arg); }
+  };
+
+  struct FinalAction {
+    int operator()() && { return 19; }
+  };
+
+  MockFunction<int(int)> mock;
+  EXPECT_CALL(mock, Call).WillOnce(DoAll(InitialAction{}, FinalAction{}));
+  EXPECT_EQ(19, mock.AsStdFunction()(17));
+}
+
+// DoAll should never provide rvalue references to the initial actions. If the
+// mock action itself accepts an rvalue reference or a non-scalar object by
+// value then the final action should receive an rvalue reference, but initial
+// actions should receive only lvalue references.
+TEST(DoAll, ProvidesLvalueReferencesToInitialActions) {
+  struct Obj {};
+
+  // Mock action accepts by value: the initial action should be fed a const
+  // lvalue reference, and the final action an rvalue reference.
+  {
+    struct InitialAction {
+      void operator()(Obj&) const { FAIL() << "Unexpected call"; }
+      void operator()(const Obj&) const {}
+      void operator()(Obj&&) const { FAIL() << "Unexpected call"; }
+      void operator()(const Obj&&) const { FAIL() << "Unexpected call"; }
+    };
+
+    MockFunction<void(Obj)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](Obj&&) {}))
+        .WillRepeatedly(DoAll(InitialAction{}, InitialAction{}, [](Obj&&) {}));
+
+    mock.AsStdFunction()(Obj{});
+    mock.AsStdFunction()(Obj{});
+  }
+
+  // Mock action accepts by const lvalue reference: both actions should receive
+  // a const lvalue reference.
+  {
+    struct InitialAction {
+      void operator()(Obj&) const { FAIL() << "Unexpected call"; }
+      void operator()(const Obj&) const {}
+      void operator()(Obj&&) const { FAIL() << "Unexpected call"; }
+      void operator()(const Obj&&) const { FAIL() << "Unexpected call"; }
+    };
+
+    MockFunction<void(const Obj&)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](const Obj&) {}))
+        .WillRepeatedly(
+            DoAll(InitialAction{}, InitialAction{}, [](const Obj&) {}));
+
+    mock.AsStdFunction()(Obj{});
+    mock.AsStdFunction()(Obj{});
+  }
+
+  // Mock action accepts by non-const lvalue reference: both actions should get
+  // a non-const lvalue reference if they want them.
+  {
+    struct InitialAction {
+      void operator()(Obj&) const {}
+      void operator()(Obj&&) const { FAIL() << "Unexpected call"; }
+    };
+
+    MockFunction<void(Obj&)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](Obj&) {}))
+        .WillRepeatedly(DoAll(InitialAction{}, InitialAction{}, [](Obj&) {}));
+
+    Obj obj;
+    mock.AsStdFunction()(obj);
+    mock.AsStdFunction()(obj);
+  }
+
+  // Mock action accepts by rvalue reference: the initial actions should receive
+  // a non-const lvalue reference if it wants it, and the final action an rvalue
+  // reference.
+  {
+    struct InitialAction {
+      void operator()(Obj&) const {}
+      void operator()(Obj&&) const { FAIL() << "Unexpected call"; }
+    };
+
+    MockFunction<void(Obj &&)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](Obj&&) {}))
+        .WillRepeatedly(DoAll(InitialAction{}, InitialAction{}, [](Obj&&) {}));
+
+    mock.AsStdFunction()(Obj{});
+    mock.AsStdFunction()(Obj{});
+  }
+
+  // &&-qualified initial actions should also be allowed with WillOnce.
+  {
+    struct InitialAction {
+      void operator()(Obj&) && {}
+    };
+
+    MockFunction<void(Obj&)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](Obj&) {}));
+
+    Obj obj;
+    mock.AsStdFunction()(obj);
+  }
+
+  {
+    struct InitialAction {
+      void operator()(Obj&) && {}
+    };
+
+    MockFunction<void(Obj &&)> mock;
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(InitialAction{}, InitialAction{}, [](Obj&&) {}));
+
+    mock.AsStdFunction()(Obj{});
+  }
+}
+
+// DoAll should support being used with type-erased Action objects, both through
+// WillOnce and WillRepeatedly.
+TEST(DoAll, SupportsTypeErasedActions) {
+  // With only type-erased actions.
+  const Action<void()> initial_action = [] {};
+  const Action<int()> final_action = [] { return 17; };
+
+  MockFunction<int()> mock;
+  EXPECT_CALL(mock, Call)
+      .WillOnce(DoAll(initial_action, initial_action, final_action))
+      .WillRepeatedly(DoAll(initial_action, initial_action, final_action));
+
+  EXPECT_EQ(17, mock.AsStdFunction()());
+
+  // With &&-qualified and move-only final action.
+  {
+    struct FinalAction {
+      FinalAction() = default;
+      FinalAction(FinalAction&&) = default;
+
+      int operator()() && { return 17; }
+    };
+
+    EXPECT_CALL(mock, Call)
+        .WillOnce(DoAll(initial_action, initial_action, FinalAction{}));
+
+    EXPECT_EQ(17, mock.AsStdFunction()());
+  }
+}
 
 // Tests using WithArgs and with an action that takes 1 argument.
 TEST(WithArgsTest, OneArg) {
@@ -1175,8 +1571,29 @@ TEST(WithArgsTest, ReturnReference) {
 
 TEST(WithArgsTest, InnerActionWithConversion) {
   Action<Derived*()> inner = [] { return nullptr; };
-  Action<Base*(double)> a = testing::WithoutArgs(inner);
-  EXPECT_EQ(nullptr, a.Perform(std::make_tuple(1.1)));
+
+  MockFunction<Base*(double)> mock;
+  EXPECT_CALL(mock, Call)
+      .WillOnce(WithoutArgs(inner))
+      .WillRepeatedly(WithoutArgs(inner));
+
+  EXPECT_EQ(nullptr, mock.AsStdFunction()(1.1));
+  EXPECT_EQ(nullptr, mock.AsStdFunction()(1.1));
+}
+
+// It should be possible to use an &&-qualified inner action as long as the
+// whole shebang is used as an rvalue with WillOnce.
+TEST(WithArgsTest, RefQualifiedInnerAction) {
+  struct SomeAction {
+    int operator()(const int arg) && {
+      EXPECT_EQ(17, arg);
+      return 19;
+    }
+  };
+
+  MockFunction<int(int, int)> mock;
+  EXPECT_CALL(mock, Call).WillOnce(WithArg<1>(SomeAction{}));
+  EXPECT_EQ(19, mock.AsStdFunction()(0, 17));
 }
 
 #if !GTEST_OS_WINDOWS_MOBILE
@@ -1235,7 +1652,7 @@ TEST(ByRefTest, IsCopyable) {
 TEST(ByRefTest, ConstValue) {
   const int n = 0;
   // int& ref = ByRef(n);  // This shouldn't compile - we have a
-                           // negative compilation test to catch it.
+  // negative compilation test to catch it.
   const int& const_ref = ByRef(n);
   EXPECT_EQ(&n, &const_ref);
 }
@@ -1260,7 +1677,7 @@ TEST(ByRefTest, ExplicitType) {
   EXPECT_EQ(&n, &r1);
 
   // ByRef<char>(n);  // This shouldn't compile - we have a negative
-                      // compilation test to catch it.
+  // compilation test to catch it.
 
   Derived d;
   Derived& r2 = ByRef<Derived>(d);
@@ -1375,9 +1792,10 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
   MockClass mock;
   std::unique_ptr<int> i(new int(19));
   EXPECT_CALL(mock_function, Call());
-  EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
-      InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
-      Return(ByMove(std::move(i)))));
+  EXPECT_CALL(mock, MakeUnique())
+      .WillOnce(DoAll(InvokeWithoutArgs(&mock_function,
+                                        &testing::MockFunction<void()>::Call),
+                      Return(ByMove(std::move(i)))));
 
   std::unique_ptr<int> result1 = mock.MakeUnique();
   EXPECT_EQ(19, *result1);
@@ -1387,9 +1805,8 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
   MockClass mock;
 
   // Check default value
-  DefaultValue<std::unique_ptr<int>>::SetFactory([] {
-    return std::unique_ptr<int>(new int(42));
-  });
+  DefaultValue<std::unique_ptr<int>>::SetFactory(
+      [] { return std::unique_ptr<int>(new int(42)); });
   EXPECT_EQ(42, *mock.MakeUnique());
 
   EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
@@ -1449,6 +1866,178 @@ TEST(MockMethodTest, CanTakeMoveOnlyValue) {
   EXPECT_EQ(42, *saved);
 }
 
+// It should be possible to use callables with an &&-qualified call operator
+// with WillOnce, since they will be called only once. This allows actions to
+// contain and manipulate move-only types.
+TEST(MockMethodTest, ActionHasRvalueRefQualifiedCallOperator) {
+  struct Return17 {
+    int operator()() && { return 17; }
+  };
+
+  // Action is directly compatible with mocked function type.
+  {
+    MockFunction<int()> mock;
+    EXPECT_CALL(mock, Call).WillOnce(Return17());
+
+    EXPECT_EQ(17, mock.AsStdFunction()());
+  }
+
+  // Action doesn't want mocked function arguments.
+  {
+    MockFunction<int(int)> mock;
+    EXPECT_CALL(mock, Call).WillOnce(Return17());
+
+    EXPECT_EQ(17, mock.AsStdFunction()(0));
+  }
+}
+
+// Edge case: if an action has both a const-qualified and an &&-qualified call
+// operator, there should be no "ambiguous call" errors. The &&-qualified
+// operator should be used by WillOnce (since it doesn't need to retain the
+// action beyond one call), and the const-qualified one by WillRepeatedly.
+TEST(MockMethodTest, ActionHasMultipleCallOperators) {
+  struct ReturnInt {
+    int operator()() && { return 17; }
+    int operator()() const& { return 19; }
+  };
+
+  // Directly compatible with mocked function type.
+  {
+    MockFunction<int()> mock;
+    EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());
+
+    EXPECT_EQ(17, mock.AsStdFunction()());
+    EXPECT_EQ(19, mock.AsStdFunction()());
+    EXPECT_EQ(19, mock.AsStdFunction()());
+  }
+
+  // Ignores function arguments.
+  {
+    MockFunction<int(int)> mock;
+    EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());
+
+    EXPECT_EQ(17, mock.AsStdFunction()(0));
+    EXPECT_EQ(19, mock.AsStdFunction()(0));
+    EXPECT_EQ(19, mock.AsStdFunction()(0));
+  }
+}
+
+// WillOnce should have no problem coping with a move-only action, whether it is
+// &&-qualified or not.
+TEST(MockMethodTest, MoveOnlyAction) {
+  // &&-qualified
+  {
+    struct Return17 {
+      Return17() = default;
+      Return17(Return17&&) = default;
+
+      Return17(const Return17&) = delete;
+      Return17 operator=(const Return17&) = delete;
+
+      int operator()() && { return 17; }
+    };
+
+    MockFunction<int()> mock;
+    EXPECT_CALL(mock, Call).WillOnce(Return17());
+    EXPECT_EQ(17, mock.AsStdFunction()());
+  }
+
+  // Not &&-qualified
+  {
+    struct Return17 {
+      Return17() = default;
+      Return17(Return17&&) = default;
+
+      Return17(const Return17&) = delete;
+      Return17 operator=(const Return17&) = delete;
+
+      int operator()() const { return 17; }
+    };
+
+    MockFunction<int()> mock;
+    EXPECT_CALL(mock, Call).WillOnce(Return17());
+    EXPECT_EQ(17, mock.AsStdFunction()());
+  }
+}
+
+// It should be possible to use an action that returns a value with a mock
+// function that doesn't, both through WillOnce and WillRepeatedly.
+TEST(MockMethodTest, ActionReturnsIgnoredValue) {
+  struct ReturnInt {
+    int operator()() const { return 0; }
+  };
+
+  MockFunction<void()> mock;
+  EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());
+
+  mock.AsStdFunction()();
+  mock.AsStdFunction()();
+}
+
+// Despite the fanciness around move-only actions and so on, it should still be
+// possible to hand an lvalue reference to a copyable action to WillOnce.
+TEST(MockMethodTest, WillOnceCanAcceptLvalueReference) {
+  MockFunction<int()> mock;
+
+  const auto action = [] { return 17; };
+  EXPECT_CALL(mock, Call).WillOnce(action);
+
+  EXPECT_EQ(17, mock.AsStdFunction()());
+}
+
+// A callable that doesn't use SFINAE to restrict its call operator's overload
+// set, but is still picky about which arguments it will accept.
+struct StaticAssertSingleArgument {
+  template <typename... Args>
+  static constexpr bool CheckArgs() {
+    static_assert(sizeof...(Args) == 1, "");
+    return true;
+  }
+
+  template <typename... Args, bool = CheckArgs<Args...>()>
+  int operator()(Args...) const {
+    return 17;
+  }
+};
+
+// WillOnce and WillRepeatedly should both work fine with naïve implementations
+// of actions that don't use SFINAE to limit the overload set for their call
+// operator. If they are compatible with the actual mocked signature, we
+// shouldn't probe them with no arguments and trip a static_assert.
+TEST(MockMethodTest, ActionSwallowsAllArguments) {
+  MockFunction<int(int)> mock;
+  EXPECT_CALL(mock, Call)
+      .WillOnce(StaticAssertSingleArgument{})
+      .WillRepeatedly(StaticAssertSingleArgument{});
+
+  EXPECT_EQ(17, mock.AsStdFunction()(0));
+  EXPECT_EQ(17, mock.AsStdFunction()(0));
+}
+
+struct ActionWithTemplatedConversionOperators {
+  template <typename... Args>
+  operator OnceAction<int(Args...)>() && {  // NOLINT
+    return [] { return 17; };
+  }
+
+  template <typename... Args>
+  operator Action<int(Args...)>() const {  // NOLINT
+    return [] { return 19; };
+  }
+};
+
+// It should be fine to hand both WillOnce and WillRepeatedly a function that
+// defines templated conversion operators to OnceAction and Action. WillOnce
+// should prefer the OnceAction version.
+TEST(MockMethodTest, ActionHasTemplatedConversionOperators) {
+  MockFunction<int()> mock;
+  EXPECT_CALL(mock, Call)
+      .WillOnce(ActionWithTemplatedConversionOperators{})
+      .WillRepeatedly(ActionWithTemplatedConversionOperators{});
+
+  EXPECT_EQ(17, mock.AsStdFunction()());
+  EXPECT_EQ(19, mock.AsStdFunction()());
+}
 
 // Tests for std::function based action.
 
@@ -1463,7 +2052,9 @@ int Deref(std::unique_ptr<int> ptr) { return *ptr; }
 
 struct Double {
   template <typename T>
-  T operator()(T t) { return 2 * t; }
+  T operator()(T t) {
+    return 2 * t;
+  }
 };
 
 std::unique_ptr<int> UniqueInt(int i) {
@@ -1532,8 +2123,9 @@ TEST(FunctorActionTest, TypeConversion) {
 
 TEST(FunctorActionTest, UnusedArguments) {
   // Verify that users can ignore uninteresting arguments.
-  Action<int(int, double y, double z)> a =
-      [](int i, Unused, Unused) { return 2 * i; };
+  Action<int(int, double y, double z)> a = [](int i, Unused, Unused) {
+    return 2 * i;
+  };
   std::tuple<int, double, double> dummy = std::make_tuple(3, 7.3, 9.44);
   EXPECT_EQ(6, a.Perform(dummy));
 }
@@ -1552,9 +2144,7 @@ TEST(MoveOnlyArgumentsTest, ReturningActions) {
   EXPECT_EQ(x, 3);
 }
 
-ACTION(ReturnArity) {
-  return std::tuple_size<args_type>::value;
-}
+ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
 
 TEST(ActionMacro, LargeArity) {
   EXPECT_EQ(
@@ -1573,11 +2163,5 @@ TEST(ActionMacro, LargeArity) {
                                    14, 15, 16, 17, 18, 19)));
 }
 
-}  // Unnamed namespace
-
-#ifdef _MSC_VER
-#if _MSC_VER == 1900
-#  pragma warning(pop)
-#endif
-#endif
-
+}  // namespace
+}  // namespace testing
diff --git a/googletest/googlemock/test/gmock-cardinalities_test.cc b/googletest/googlemock/test/gmock-cardinalities_test.cc
index ca97cae249246ba74853720ae4a50e0b28abf638..cdd99563538745945c8d69daba4f63b0e0bcdcef 100644
--- a/googletest/googlemock/test/gmock-cardinalities_test.cc
+++ b/googletest/googlemock/test/gmock-cardinalities_test.cc
@@ -27,14 +27,13 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the built-in cardinalities.
 
 #include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 
 namespace {
 
@@ -55,13 +54,12 @@ class MockFoo {
   MOCK_METHOD0(Bar, int());  // NOLINT
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+  MockFoo(const MockFoo&) = delete;
+  MockFoo& operator=(const MockFoo&) = delete;
 };
 
 // Tests that Cardinality objects can be default constructed.
-TEST(CardinalityTest, IsDefaultConstructable) {
-  Cardinality c;
-}
+TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; }
 
 // Tests that Cardinality objects are copyable.
 TEST(CardinalityTest, IsCopyable) {
@@ -119,8 +117,7 @@ TEST(AnyNumber, Works) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times", ss.str());
 }
 
 TEST(AnyNumberTest, HasCorrectBounds) {
@@ -132,9 +129,11 @@ TEST(AnyNumberTest, HasCorrectBounds) {
 // Tests AtLeast(n).
 
 TEST(AtLeastTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtLeast(-1);
-  }, "The invocation lower bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        AtLeast(-1);
+      },
+      "The invocation lower bound must be >= 0");
 }
 
 TEST(AtLeastTest, OnZero) {
@@ -147,8 +146,7 @@ TEST(AtLeastTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times", ss.str());
 }
 
 TEST(AtLeastTest, OnPositiveNumber) {
@@ -164,18 +162,15 @@ TEST(AtLeastTest, OnPositiveNumber) {
 
   stringstream ss1;
   AtLeast(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice", ss2.str());
 
   stringstream ss3;
   AtLeast(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times", ss3.str());
 }
 
 TEST(AtLeastTest, HasCorrectBounds) {
@@ -187,9 +182,11 @@ TEST(AtLeastTest, HasCorrectBounds) {
 // Tests AtMost(n).
 
 TEST(AtMostTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtMost(-1);
-  }, "The invocation upper bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        AtMost(-1);
+      },
+      "The invocation upper bound must be >= 0");
 }
 
 TEST(AtMostTest, OnZero) {
@@ -202,8 +199,7 @@ TEST(AtMostTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(AtMostTest, OnPositiveNumber) {
@@ -219,18 +215,15 @@ TEST(AtMostTest, OnPositiveNumber) {
 
   stringstream ss1;
   AtMost(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice", ss2.str());
 
   stringstream ss3;
   AtMost(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times", ss3.str());
 }
 
 TEST(AtMostTest, HasCorrectBounds) {
@@ -242,22 +235,28 @@ TEST(AtMostTest, HasCorrectBounds) {
 // Tests Between(m, n).
 
 TEST(BetweenTest, OnNegativeStart) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(-1, 2);
-  }, "The invocation lower bound must be >= 0, but is actually -1");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(-1, 2);
+      },
+      "The invocation lower bound must be >= 0, but is actually -1");
 }
 
 TEST(BetweenTest, OnNegativeEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(1, -2);
-  }, "The invocation upper bound must be >= 0, but is actually -2");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(1, -2);
+      },
+      "The invocation upper bound must be >= 0, but is actually -2");
 }
 
 TEST(BetweenTest, OnStartBiggerThanEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(2, 1);
-  }, "The invocation upper bound (1) must be >= "
-     "the invocation lower bound (2)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(2, 1);
+      },
+      "The invocation upper bound (1) must be >= "
+      "the invocation lower bound (2)");
 }
 
 TEST(BetweenTest, OnZeroStartAndZeroEnd) {
@@ -271,8 +270,7 @@ TEST(BetweenTest, OnZeroStartAndZeroEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
@@ -289,8 +287,7 @@ TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice", ss.str());
 }
 
 TEST(BetweenTest, OnSameStartAndEnd) {
@@ -307,8 +304,7 @@ TEST(BetweenTest, OnSameStartAndEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss.str());
 }
 
 TEST(BetweenTest, OnDifferentStartAndEnd) {
@@ -328,8 +324,7 @@ TEST(BetweenTest, OnDifferentStartAndEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times", ss.str());
 }
 
 TEST(BetweenTest, HasCorrectBounds) {
@@ -341,9 +336,11 @@ TEST(BetweenTest, HasCorrectBounds) {
 // Tests Exactly(n).
 
 TEST(ExactlyTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Exactly(-1);
-  }, "The invocation lower bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Exactly(-1);
+      },
+      "The invocation lower bound must be >= 0");
 }
 
 TEST(ExactlyTest, OnZero) {
@@ -356,8 +353,7 @@ TEST(ExactlyTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(ExactlyTest, OnPositiveNumber) {
@@ -370,18 +366,15 @@ TEST(ExactlyTest, OnPositiveNumber) {
 
   stringstream ss1;
   Exactly(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called twice", ss2.str());
 
   stringstream ss3;
   Exactly(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss3.str());
 }
 
 TEST(ExactlyTest, HasCorrectBounds) {
diff --git a/googletest/googlemock/test/gmock-function-mocker_test.cc b/googletest/googlemock/test/gmock-function-mocker_test.cc
index cf76fa99f286fe4eeb85d1d2181c04f4074b7417..1d15a29931d0c370c1c3c2729471124056b214ac 100644
--- a/googletest/googlemock/test/gmock-function-mocker_test.cc
+++ b/googletest/googlemock/test/gmock-function-mocker_test.cc
@@ -27,6 +27,11 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// Silence C4503 (decorated name length exceeded) for MSVC.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4503)
+#endif
 
 // Google Mock - a framework for writing C++ mock classes.
 //
@@ -37,7 +42,7 @@
 // MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
 // we are getting compiler errors if we use basetyps.h, hence including
 // objbase.h for definition of STDMETHOD.
-# include <objbase.h>
+#include <objbase.h>
 #endif  // GTEST_OS_WINDOWS
 
 #include <functional>
@@ -65,7 +70,7 @@ using testing::Return;
 using testing::ReturnRef;
 using testing::TypedEq;
 
-template<typename T>
+template <typename T>
 class TemplatedCopyable {
  public:
   TemplatedCopyable() {}
@@ -82,7 +87,7 @@ class FooInterface {
 
   virtual int Nullary() = 0;
   virtual bool Unary(int x) = 0;
-  virtual long Binary(short x, int y) = 0;  // NOLINT
+  virtual long Binary(short x, int y) = 0;                     // NOLINT
   virtual int Decimal(bool b, char c, short d, int e, long f,  // NOLINT
                       float g, double h, unsigned i, char* j,
                       const std::string& k) = 0;
@@ -133,8 +138,8 @@ class FooInterface {
 // signature. This was fixed in Visual Studio 2008. However, the compiler
 // still emits a warning that alerts about this change in behavior.
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable : 4373)
+#pragma warning(push)
+#pragma warning(disable : 4373)
 #endif
 class MockFoo : public FooInterface {
  public:
@@ -203,7 +208,8 @@ class MockFoo : public FooInterface {
   MOCK_METHOD(int, RefQualifiedOverloaded, (), (ref(&&), override));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+  MockFoo(const MockFoo&) = delete;
+  MockFoo& operator=(const MockFoo&) = delete;
 };
 
 class LegacyMockFoo : public FooInterface {
@@ -275,11 +281,12 @@ class LegacyMockFoo : public FooInterface {
   int RefQualifiedOverloaded() && override { return 0; }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockFoo);
+  LegacyMockFoo(const LegacyMockFoo&) = delete;
+  LegacyMockFoo& operator=(const LegacyMockFoo&) = delete;
 };
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 template <class T>
@@ -493,7 +500,8 @@ class MockB {
   MOCK_METHOD(void, DoB, ());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+  MockB(const MockB&) = delete;
+  MockB& operator=(const MockB&) = delete;
 };
 
 class LegacyMockB {
@@ -503,7 +511,8 @@ class LegacyMockB {
   MOCK_METHOD0(DoB, void());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockB);
+  LegacyMockB(const LegacyMockB&) = delete;
+  LegacyMockB& operator=(const LegacyMockB&) = delete;
 };
 
 template <typename T>
@@ -558,7 +567,8 @@ class MockStack : public StackInterface<T> {
   MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (int), (const));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
+  MockStack(const MockStack&) = delete;
+  MockStack& operator=(const MockStack&) = delete;
 };
 
 template <typename T>
@@ -576,7 +586,8 @@ class LegacyMockStack : public StackInterface<T> {
   MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int));  // NOLINT
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockStack);
+  LegacyMockStack(const LegacyMockStack&) = delete;
+  LegacyMockStack& operator=(const LegacyMockStack&) = delete;
 };
 
 template <typename T>
@@ -595,10 +606,8 @@ TYPED_TEST(TemplateMockTest, Works) {
       .WillOnce(Return(0));
   EXPECT_CALL(mock, Push(_));
   int n = 5;
-  EXPECT_CALL(mock, GetTop())
-      .WillOnce(ReturnRef(n));
-  EXPECT_CALL(mock, Pop())
-      .Times(AnyNumber());
+  EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n));
+  EXPECT_CALL(mock, Pop()).Times(AnyNumber());
 
   EXPECT_EQ(0, mock.GetSize());
   mock.Push(5);
@@ -612,10 +621,8 @@ TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
   TypeParam mock;
 
   const std::map<int, int> a_map;
-  EXPECT_CALL(mock, ReturnTypeWithComma())
-      .WillOnce(Return(a_map));
-  EXPECT_CALL(mock, ReturnTypeWithComma(1))
-      .WillOnce(Return(a_map));
+  EXPECT_CALL(mock, ReturnTypeWithComma()).WillOnce(Return(a_map));
+  EXPECT_CALL(mock, ReturnTypeWithComma(1)).WillOnce(Return(a_map));
 
   EXPECT_EQ(a_map, mock.ReturnTypeWithComma());
   EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
@@ -650,7 +657,8 @@ class MockStackWithCallType : public StackInterfaceWithCallType<T> {
               (Calltype(STDMETHODCALLTYPE), override, const));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
+  MockStackWithCallType(const MockStackWithCallType&) = delete;
+  MockStackWithCallType& operator=(const MockStackWithCallType&) = delete;
 };
 
 template <typename T>
@@ -664,7 +672,9 @@ class LegacyMockStackWithCallType : public StackInterfaceWithCallType<T> {
   MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockStackWithCallType);
+  LegacyMockStackWithCallType(const LegacyMockStackWithCallType&) = delete;
+  LegacyMockStackWithCallType& operator=(const LegacyMockStackWithCallType&) =
+      delete;
 };
 
 template <typename T>
@@ -685,10 +695,8 @@ TYPED_TEST(TemplateMockTestWithCallType, Works) {
       .WillOnce(Return(0));
   EXPECT_CALL(mock, Push(_));
   int n = 5;
-  EXPECT_CALL(mock, GetTop())
-      .WillOnce(ReturnRef(n));
-  EXPECT_CALL(mock, Pop())
-      .Times(AnyNumber());
+  EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n));
+  EXPECT_CALL(mock, Pop()).Times(AnyNumber());
 
   EXPECT_EQ(0, mock.GetSize());
   mock.Push(5);
@@ -716,7 +724,9 @@ class MockOverloadedOnArgNumber {
   MY_MOCK_METHODS1_;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
+  MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete;
+  MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumber&) =
+      delete;
 };
 
 class LegacyMockOverloadedOnArgNumber {
@@ -726,7 +736,10 @@ class LegacyMockOverloadedOnArgNumber {
   LEGACY_MY_MOCK_METHODS1_;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LegacyMockOverloadedOnArgNumber);
+  LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNumber&) =
+      delete;
+  LegacyMockOverloadedOnArgNumber& operator=(
+      const LegacyMockOverloadedOnArgNumber&) = delete;
 };
 
 template <typename T>
@@ -747,9 +760,9 @@ TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
   EXPECT_TRUE(mock.Overloaded(true, 1));
 }
 
-#define MY_MOCK_METHODS2_ \
-    MOCK_CONST_METHOD1(Overloaded, int(int n)); \
-    MOCK_METHOD1(Overloaded, int(int n))
+#define MY_MOCK_METHODS2_                     \
+  MOCK_CONST_METHOD1(Overloaded, int(int n)); \
+  MOCK_METHOD1(Overloaded, int(int n))
 
 class MockOverloadedOnConstness {
  public:
@@ -758,7 +771,9 @@ class MockOverloadedOnConstness {
   MY_MOCK_METHODS2_;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
+  MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete;
+  MockOverloadedOnConstness& operator=(const MockOverloadedOnConstness&) =
+      delete;
 };
 
 TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
@@ -779,9 +794,7 @@ TEST(MockMethodMockFunctionTest, WorksForVoidNullary) {
 
 TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) {
   MockFunction<int()> foo;
-  EXPECT_CALL(foo, Call())
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
+  EXPECT_CALL(foo, Call()).WillOnce(Return(1)).WillOnce(Return(2));
   EXPECT_EQ(1, foo.Call());
   EXPECT_EQ(2, foo.Call());
 }
@@ -794,19 +807,17 @@ TEST(MockMethodMockFunctionTest, WorksForVoidUnary) {
 
 TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) {
   MockFunction<int(bool, int)> foo;
-  EXPECT_CALL(foo, Call(false, 42))
-      .WillOnce(Return(1))
-      .WillOnce(Return(2));
-  EXPECT_CALL(foo, Call(true, Ge(100)))
-      .WillOnce(Return(3));
+  EXPECT_CALL(foo, Call(false, 42)).WillOnce(Return(1)).WillOnce(Return(2));
+  EXPECT_CALL(foo, Call(true, Ge(100))).WillOnce(Return(3));
   EXPECT_EQ(1, foo.Call(false, 42));
   EXPECT_EQ(2, foo.Call(false, 42));
   EXPECT_EQ(3, foo.Call(true, 120));
 }
 
 TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
-  MockFunction<int(bool a0, char a1, int a2, int a3, int a4,
-                   int a5, int a6, char a7, int a8, bool a9)> foo;
+  MockFunction<int(bool a0, char a1, int a2, int a3, int a4, int a5, int a6,
+                   char a7, int a8, bool a9)>
+      foo;
   EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _))
       .WillOnce(Return(1))
       .WillOnce(Return(2));
@@ -816,9 +827,7 @@ TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
 
 TEST(MockMethodMockFunctionTest, AsStdFunction) {
   MockFunction<int(int)> foo;
-  auto call = [](const std::function<int(int)> &f, int i) {
-    return f(i);
-  };
+  auto call = [](const std::function<int(int)>& f, int i) { return f(i); };
   EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1));
   EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2));
   EXPECT_EQ(-1, call(foo.AsStdFunction(), 1));
@@ -836,10 +845,8 @@ TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) {
 }
 
 TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
-  MockFunction<int(int &)> foo;
-  auto call = [](const std::function<int(int& )> &f, int &i) {
-    return f(i);
-  };
+  MockFunction<int(int&)> foo;
+  auto call = [](const std::function<int(int&)>& f, int& i) { return f(i); };
   int i = 42;
   EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1));
   EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
@@ -888,8 +895,7 @@ TYPED_TEST(
 }
 
 template <typename F>
-struct AlternateCallable {
-};
+struct AlternateCallable {};
 
 TYPED_TEST(MockMethodMockFunctionSignatureTest,
            IsMockFunctionTemplateArgumentDeducedForAlternateCallable) {
@@ -898,16 +904,14 @@ TYPED_TEST(MockMethodMockFunctionSignatureTest,
   EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
 }
 
-TYPED_TEST(
-    MockMethodMockFunctionSignatureTest,
-    IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) {
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+           IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) {
   using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
   using ForStdFunction =
       decltype(&MockFunction<std::function<TypeParam>>::Call);
   EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
 }
 
-
 struct MockMethodSizes0 {
   MOCK_METHOD(void, func, ());
 };
@@ -925,22 +929,21 @@ struct MockMethodSizes4 {
 };
 
 struct LegacyMockMethodSizes0 {
-    MOCK_METHOD0(func, void());
+  MOCK_METHOD0(func, void());
 };
 struct LegacyMockMethodSizes1 {
-    MOCK_METHOD1(func, void(int));
+  MOCK_METHOD1(func, void(int));
 };
 struct LegacyMockMethodSizes2 {
-    MOCK_METHOD2(func, void(int, int));
+  MOCK_METHOD2(func, void(int, int));
 };
 struct LegacyMockMethodSizes3 {
-    MOCK_METHOD3(func, void(int, int, int));
+  MOCK_METHOD3(func, void(int, int, int));
 };
 struct LegacyMockMethodSizes4 {
-    MOCK_METHOD4(func, void(int, int, int, int));
+  MOCK_METHOD4(func, void(int, int, int, int));
 };
 
-
 TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
   EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1));
   EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2));
@@ -955,6 +958,21 @@ TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
   EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(MockMethodSizes0));
 }
 
+TEST(MockMethodMockFunctionTest, EnsureNoUnusedMemberFunction) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic error "-Wunused-member-function"
+#endif
+  // https://github.com/google/googletest/issues/4052
+  struct Foo {
+    MOCK_METHOD(void, foo, ());
+  };
+  EXPECT_CALL(Foo(), foo()).Times(0);
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}
+
 void hasTwoParams(int, int);
 void MaybeThrows();
 void DoesntThrow() noexcept;
diff --git a/googletest/googlemock/test/gmock-internal-utils_test.cc b/googletest/googlemock/test/gmock-internal-utils_test.cc
index 0d15e8f482c7c7900ca81115fa8d312b75639f53..932bece5afed52af7e85d5d100a35f4d589955d0 100644
--- a/googletest/googlemock/test/gmock-internal-utils_test.cc
+++ b/googletest/googlemock/test/gmock-internal-utils_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the internal utilities.
@@ -58,7 +57,7 @@
 #undef GTEST_IMPLEMENTATION_
 
 #if GTEST_OS_CYGWIN
-# include <sys/types.h>  // For ssize_t. NOLINT
+#include <sys/types.h>  // For ssize_t. NOLINT
 #endif
 
 namespace proto2 {
@@ -70,24 +69,23 @@ namespace internal {
 
 namespace {
 
-TEST(JoinAsTupleTest, JoinsEmptyTuple) {
-  EXPECT_EQ("", JoinAsTuple(Strings()));
+TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) {
+  EXPECT_EQ("", JoinAsKeyValueTuple({}, Strings()));
 }
 
-TEST(JoinAsTupleTest, JoinsOneTuple) {
-  const char* fields[] = {"1"};
-  EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1)));
+TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) {
+  EXPECT_EQ("(a: 1)", JoinAsKeyValueTuple({"a"}, {"1"}));
 }
 
-TEST(JoinAsTupleTest, JoinsTwoTuple) {
-  const char* fields[] = {"1", "a"};
-  EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2)));
+TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) {
+  EXPECT_EQ("(a: 1, b: 2)", JoinAsKeyValueTuple({"a", "b"}, {"1", "2"}));
 }
 
-TEST(JoinAsTupleTest, JoinsTenTuple) {
-  const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
-  EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
-            JoinAsTuple(Strings(fields, fields + 10)));
+TEST(JoinAsKeyValueTupleTest, JoinsTenTuple) {
+  EXPECT_EQ(
+      "(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10)",
+      JoinAsKeyValueTuple({"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
+                          {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}));
 }
 
 TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
@@ -140,6 +138,12 @@ TEST(GetRawPointerTest, WorksForRawPointers) {
   EXPECT_EQ(&n, GetRawPointer(&n));
 }
 
+TEST(GetRawPointerTest, WorksForStdReferenceWrapper) {
+  int n = 1;
+  EXPECT_EQ(&n, GetRawPointer(std::ref(n)));
+  EXPECT_EQ(&n, GetRawPointer(std::cref(n)));
+}
+
 // Tests KindOf<T>.
 
 class Base {};
@@ -150,19 +154,19 @@ TEST(KindOfTest, Bool) {
 }
 
 TEST(KindOfTest, Integer) {
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long long));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char));                // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char));         // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char));       // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short));               // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short));      // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int));                 // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int));        // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long));                // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long));       // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long long));           // NOLINT
   EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));  // NOLINT
-  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));  // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));             // NOLINT
+  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));              // NOLINT
 #if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
   // ssize_t is not defined on Windows and possibly some other OSes.
   EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
@@ -170,15 +174,15 @@ TEST(KindOfTest, Integer) {
 }
 
 TEST(KindOfTest, FloatingPoint) {
-  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));  // NOLINT
-  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));  // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float));        // NOLINT
+  EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double));       // NOLINT
   EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double));  // NOLINT
 }
 
 TEST(KindOfTest, Other) {
-  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*));   // NOLINT
   EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**));  // NOLINT
-  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));  // NOLINT
+  EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base));    // NOLINT
 }
 
 // Tests LosslessArithmeticConvertible<T, U>.
@@ -209,26 +213,26 @@ TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
   EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
 
   // Unsigned => larger unsigned is fine.
-  EXPECT_TRUE((LosslessArithmeticConvertible<
-               unsigned short, uint64_t>::value));  // NOLINT
+  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned short,
+                                             uint64_t>::value));  // NOLINT
 
   // Signed => unsigned is not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-                short, uint64_t>::value));  // NOLINT
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-      signed char, unsigned int>::value));  // NOLINT
+  EXPECT_FALSE(
+      (LosslessArithmeticConvertible<short, uint64_t>::value));  // NOLINT
+  EXPECT_FALSE((LosslessArithmeticConvertible<signed char,
+                                              unsigned int>::value));  // NOLINT
 
   // Same size and same signedness: fine too.
-  EXPECT_TRUE((LosslessArithmeticConvertible<
-               unsigned char, unsigned char>::value));
+  EXPECT_TRUE(
+      (LosslessArithmeticConvertible<unsigned char, unsigned char>::value));
   EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
   EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
-  EXPECT_TRUE((LosslessArithmeticConvertible<
-               unsigned long, unsigned long>::value));  // NOLINT
+  EXPECT_TRUE((LosslessArithmeticConvertible<unsigned long,
+                                             unsigned long>::value));  // NOLINT
 
   // Same size, different signedness: not fine.
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-                unsigned char, signed char>::value));
+  EXPECT_FALSE(
+      (LosslessArithmeticConvertible<unsigned char, signed char>::value));
   EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
   EXPECT_FALSE((LosslessArithmeticConvertible<uint64_t, int64_t>::value));
 
@@ -243,8 +247,8 @@ TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
   // the format of the latter is implementation-defined.
   EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
   EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
-  EXPECT_FALSE((LosslessArithmeticConvertible<
-                short, long double>::value));  // NOLINT
+  EXPECT_FALSE(
+      (LosslessArithmeticConvertible<short, long double>::value));  // NOLINT
 }
 
 TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
@@ -272,7 +276,7 @@ TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
   EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
   GTEST_INTENTIONAL_CONST_COND_PUSH_()
   if (sizeof(double) == sizeof(long double)) {  // NOLINT
-  GTEST_INTENTIONAL_CONST_COND_POP_()
+    GTEST_INTENTIONAL_CONST_COND_POP_()
     // In some implementations (e.g. MSVC), double and long double
     // have the same size.
     EXPECT_TRUE((LosslessArithmeticConvertible<long double, double>::value));
@@ -291,7 +295,7 @@ TEST(TupleMatchesTest, WorksForSize0) {
 }
 
 TEST(TupleMatchesTest, WorksForSize1) {
-  std::tuple<Matcher<int> > matchers(Eq(1));
+  std::tuple<Matcher<int>> matchers(Eq(1));
   std::tuple<int> values1(1), values2(2);
 
   EXPECT_TRUE(TupleMatches(matchers, values1));
@@ -299,7 +303,7 @@ TEST(TupleMatchesTest, WorksForSize1) {
 }
 
 TEST(TupleMatchesTest, WorksForSize2) {
-  std::tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq('a'));
+  std::tuple<Matcher<int>, Matcher<char>> matchers(Eq(1), Eq('a'));
   std::tuple<int, char> values1(1, 'a'), values2(1, 'b'), values3(2, 'a'),
       values4(2, 'b');
 
@@ -312,7 +316,7 @@ TEST(TupleMatchesTest, WorksForSize2) {
 TEST(TupleMatchesTest, WorksForSize5) {
   std::tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
              Matcher<long>,  // NOLINT
-             Matcher<std::string> >
+             Matcher<std::string>>
       matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi"));
   std::tuple<int, char, bool, long, std::string>  // NOLINT
       values1(1, 'a', true, 2L, "hi"), values2(1, 'a', true, 2L, "hello"),
@@ -331,13 +335,10 @@ TEST(AssertTest, SucceedsOnTrue) {
 
 // Tests that Assert(false, ...) generates a fatal failure.
 TEST(AssertTest, FailsFatallyOnFalse) {
-  EXPECT_DEATH_IF_SUPPORTED({
-    Assert(false, __FILE__, __LINE__, "This should fail.");
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      { Assert(false, __FILE__, __LINE__, "This should fail."); }, "");
 
-  EXPECT_DEATH_IF_SUPPORTED({
-    Assert(false, __FILE__, __LINE__);
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED({ Assert(false, __FILE__, __LINE__); }, "");
 }
 
 // Tests that Expect(true, ...) succeeds.
@@ -348,40 +349,44 @@ TEST(ExpectTest, SucceedsOnTrue) {
 
 // Tests that Expect(false, ...) generates a non-fatal failure.
 TEST(ExpectTest, FailsNonfatallyOnFalse) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Expect(false, __FILE__, __LINE__, "This should fail.");
-  }, "This should fail");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Expect(false, __FILE__, __LINE__, "This should fail.");
+      },
+      "This should fail");
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Expect(false, __FILE__, __LINE__);
-  }, "Expectation failed");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Expect(false, __FILE__, __LINE__);
+      },
+      "Expectation failed");
 }
 
 // Tests LogIsVisible().
 
 class LogIsVisibleTest : public ::testing::Test {
  protected:
-  void SetUp() override { original_verbose_ = GMOCK_FLAG(verbose); }
+  void SetUp() override { original_verbose_ = GMOCK_FLAG_GET(verbose); }
 
-  void TearDown() override { GMOCK_FLAG(verbose) = original_verbose_; }
+  void TearDown() override { GMOCK_FLAG_SET(verbose, original_verbose_); }
 
   std::string original_verbose_;
 };
 
 TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
   EXPECT_TRUE(LogIsVisible(kInfo));
   EXPECT_TRUE(LogIsVisible(kWarning));
 }
 
 TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  GMOCK_FLAG_SET(verbose, kErrorVerbosity);
   EXPECT_FALSE(LogIsVisible(kInfo));
   EXPECT_FALSE(LogIsVisible(kWarning));
 }
 
 TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  GMOCK_FLAG_SET(verbose, kWarningVerbosity);
   EXPECT_FALSE(LogIsVisible(kInfo));
   EXPECT_TRUE(LogIsVisible(kWarning));
 }
@@ -394,31 +399,31 @@ TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
 // and log severity.
 void TestLogWithSeverity(const std::string& verbosity, LogSeverity severity,
                          bool should_print) {
-  const std::string old_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = verbosity;
+  const std::string old_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, verbosity);
   CaptureStdout();
   Log(severity, "Test log.\n", 0);
   if (should_print) {
-    EXPECT_THAT(GetCapturedStdout().c_str(),
-                ContainsRegex(
-                    severity == kWarning ?
-                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
-                    "^\nTest log\\.\nStack trace:\n"));
+    EXPECT_THAT(
+        GetCapturedStdout().c_str(),
+        ContainsRegex(severity == kWarning
+                          ? "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n"
+                          : "^\nTest log\\.\nStack trace:\n"));
   } else {
     EXPECT_STREQ("", GetCapturedStdout().c_str());
   }
-  GMOCK_FLAG(verbose) = old_flag;
+  GMOCK_FLAG_SET(verbose, old_flag);
 }
 
 // Tests that when the stack_frames_to_skip parameter is negative,
 // Log() doesn't include the stack trace in the output.
 TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
   CaptureStdout();
   Log(kInfo, "Test log.\n", -1);
   EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
@@ -440,7 +445,8 @@ TEST(LogTest, NoSkippingStackFrameInOptMode) {
   const std::string log = GetCapturedStdout();
 
   std::string expected_trace =
-      (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString();
+      (testing::Message() << GTEST_FLAG_GET(stack_trace_depth) << "::")
+          .GetString();
   std::string expected_message =
       "\nGMOCK WARNING:\n"
       "Test log.\n"
@@ -449,13 +455,13 @@ TEST(LogTest, NoSkippingStackFrameInOptMode) {
   EXPECT_THAT(log, HasSubstr(expected_message));
   int skip_count = atoi(log.substr(expected_message.size()).c_str());
 
-# if defined(NDEBUG)
+#if defined(NDEBUG)
   // In opt mode, no stack frame should be skipped.
   const int expected_skip_count = 0;
-# else
+#else
   // In dbg mode, the stack frames should be skipped.
   const int expected_skip_count = 100;
-# endif
+#endif
 
   // Note that each inner implementation layer will +1 the number to remove
   // itself from the trace. This means that the value is a little higher than
@@ -497,12 +503,12 @@ TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
 
 // Verifies that Log() behaves correctly for the given verbosity level
 // and log severity.
-std::string GrabOutput(void(*logger)(), const char* verbosity) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = verbosity;
+std::string GrabOutput(void (*logger)(), const char* verbosity) {
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, verbosity);
   CaptureStdout();
   logger();
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
   return GetCapturedStdout();
 }
 
@@ -532,7 +538,7 @@ TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
 
 // Verifies that EXPECT_CALL doesn't log
 // if the --gmock_verbose flag is set to "error".
-TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
+TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
   EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
 }
 
@@ -576,9 +582,9 @@ TEST(OnCallTest, LogsAnythingArgument) {
 
 TEST(StlContainerViewTest, WorksForStlContainer) {
   StaticAssertTypeEq<std::vector<int>,
-      StlContainerView<std::vector<int> >::type>();
+                     StlContainerView<std::vector<int>>::type>();
   StaticAssertTypeEq<const std::vector<double>&,
-      StlContainerView<std::vector<double> >::const_reference>();
+                     StlContainerView<std::vector<double>>::const_reference>();
 
   typedef std::vector<char> Chars;
   Chars v1;
@@ -591,17 +597,16 @@ TEST(StlContainerViewTest, WorksForStlContainer) {
 }
 
 TEST(StlContainerViewTest, WorksForStaticNativeArray) {
-  StaticAssertTypeEq<NativeArray<int>,
-      StlContainerView<int[3]>::type>();
+  StaticAssertTypeEq<NativeArray<int>, StlContainerView<int[3]>::type>();
   StaticAssertTypeEq<NativeArray<double>,
-      StlContainerView<const double[4]>::type>();
+                     StlContainerView<const double[4]>::type>();
   StaticAssertTypeEq<NativeArray<char[3]>,
-      StlContainerView<const char[2][3]>::type>();
+                     StlContainerView<const char[2][3]>::type>();
 
   StaticAssertTypeEq<const NativeArray<int>,
-      StlContainerView<int[2]>::const_reference>();
+                     StlContainerView<int[2]>::const_reference>();
 
-  int a1[3] = { 0, 1, 2 };
+  int a1[3] = {0, 1, 2};
   NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
   EXPECT_EQ(3U, a2.size());
   EXPECT_EQ(a1, a2.begin());
@@ -619,24 +624,24 @@ TEST(StlContainerViewTest, WorksForStaticNativeArray) {
 
 TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
   StaticAssertTypeEq<NativeArray<int>,
-                     StlContainerView<std::tuple<const int*, size_t> >::type>();
+                     StlContainerView<std::tuple<const int*, size_t>>::type>();
   StaticAssertTypeEq<
       NativeArray<double>,
-      StlContainerView<std::tuple<std::shared_ptr<double>, int> >::type>();
+      StlContainerView<std::tuple<std::shared_ptr<double>, int>>::type>();
 
   StaticAssertTypeEq<
       const NativeArray<int>,
-      StlContainerView<std::tuple<const int*, int> >::const_reference>();
+      StlContainerView<std::tuple<const int*, int>>::const_reference>();
 
-  int a1[3] = { 0, 1, 2 };
+  int a1[3] = {0, 1, 2};
   const int* const p1 = a1;
   NativeArray<int> a2 =
-      StlContainerView<std::tuple<const int*, int> >::ConstReference(
+      StlContainerView<std::tuple<const int*, int>>::ConstReference(
           std::make_tuple(p1, 3));
   EXPECT_EQ(3U, a2.size());
   EXPECT_EQ(a1, a2.begin());
 
-  const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t> >::Copy(
+  const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t>>::Copy(
       std::make_tuple(static_cast<int*>(a1), 3));
   ASSERT_EQ(3U, a3.size());
   EXPECT_EQ(0, a3.begin()[0]);
@@ -715,6 +720,46 @@ TEST(FunctionTest, LongArgumentList) {
                    F::MakeResultIgnoredValue>::value));
 }
 
+TEST(Base64Unescape, InvalidString) {
+  std::string unescaped;
+  EXPECT_FALSE(Base64Unescape("(invalid)", &unescaped));
+}
+
+TEST(Base64Unescape, ShortString) {
+  std::string unescaped;
+  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQh", &unescaped));
+  EXPECT_EQ("Hello world!", unescaped);
+}
+
+TEST(Base64Unescape, ShortStringWithPadding) {
+  std::string unescaped;
+  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ=", &unescaped));
+  EXPECT_EQ("Hello world", unescaped);
+}
+
+TEST(Base64Unescape, ShortStringWithoutPadding) {
+  std::string unescaped;
+  EXPECT_TRUE(Base64Unescape("SGVsbG8gd29ybGQ", &unescaped));
+  EXPECT_EQ("Hello world", unescaped);
+}
+
+TEST(Base64Unescape, LongStringWithWhiteSpaces) {
+  std::string escaped =
+      R"(TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
+  IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
+  dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
+  dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
+  ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=)";
+  std::string expected =
+      "Man is distinguished, not only by his reason, but by this singular "
+      "passion from other animals, which is a lust of the mind, that by a "
+      "perseverance of delight in the continued and indefatigable generation "
+      "of knowledge, exceeds the short vehemence of any carnal pleasure.";
+  std::string unescaped;
+  EXPECT_TRUE(Base64Unescape(escaped, &unescaped));
+  EXPECT_EQ(expected, unescaped);
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace testing
diff --git a/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc b/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a4c1def6eb15375e1fe93e26aba24a4969b416f1
--- /dev/null
+++ b/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
@@ -0,0 +1,1517 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
+
+// Silence warning C4244: 'initializing': conversion from 'int' to 'short',
+// possible loss of data and C4100, unreferenced local parameter
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4100)
+#endif
+
+#include "test/gmock-matchers_test.h"
+
+namespace testing {
+namespace gmock_matchers_test {
+namespace {
+
+typedef ::std::tuple<long, int> Tuple2;  // NOLINT
+
+// Tests that Eq() matches a 2-tuple where the first field == the
+// second field.
+TEST(Eq2Test, MatchesEqualArguments) {
+  Matcher<const Tuple2&> m = Eq();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Eq() describes itself properly.
+TEST(Eq2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Eq();
+  EXPECT_EQ("are an equal pair", Describe(m));
+}
+
+// Tests that Ge() matches a 2-tuple where the first field >= the
+// second field.
+TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
+  Matcher<const Tuple2&> m = Ge();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Ge() describes itself properly.
+TEST(Ge2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Ge();
+  EXPECT_EQ("are a pair where the first >= the second", Describe(m));
+}
+
+// Tests that Gt() matches a 2-tuple where the first field > the
+// second field.
+TEST(Gt2Test, MatchesGreaterThanArguments) {
+  Matcher<const Tuple2&> m = Gt();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
+}
+
+// Tests that Gt() describes itself properly.
+TEST(Gt2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Gt();
+  EXPECT_EQ("are a pair where the first > the second", Describe(m));
+}
+
+// Tests that Le() matches a 2-tuple where the first field <= the
+// second field.
+TEST(Le2Test, MatchesLessThanOrEqualArguments) {
+  Matcher<const Tuple2&> m = Le();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
+}
+
+// Tests that Le() describes itself properly.
+TEST(Le2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Le();
+  EXPECT_EQ("are a pair where the first <= the second", Describe(m));
+}
+
+// Tests that Lt() matches a 2-tuple where the first field < the
+// second field.
+TEST(Lt2Test, MatchesLessThanArguments) {
+  Matcher<const Tuple2&> m = Lt();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
+}
+
+// Tests that Lt() describes itself properly.
+TEST(Lt2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Lt();
+  EXPECT_EQ("are a pair where the first < the second", Describe(m));
+}
+
+// Tests that Ne() matches a 2-tuple where the first field != the
+// second field.
+TEST(Ne2Test, MatchesUnequalArguments) {
+  Matcher<const Tuple2&> m = Ne();
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
+  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
+  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
+}
+
+// Tests that Ne() describes itself properly.
+TEST(Ne2Test, CanDescribeSelf) {
+  Matcher<const Tuple2&> m = Ne();
+  EXPECT_EQ("are an unequal pair", Describe(m));
+}
+
+TEST(PairMatchBaseTest, WorksWithMoveOnly) {
+  using Pointers = std::tuple<std::unique_ptr<int>, std::unique_ptr<int>>;
+  Matcher<Pointers> matcher = Eq();
+  Pointers pointers;
+  // Tested values don't matter; the point is that matcher does not copy the
+  // matched values.
+  EXPECT_TRUE(matcher.Matches(pointers));
+}
+
+// Tests that IsNan() matches a NaN, with float.
+TEST(IsNan, FloatMatchesNan) {
+  float quiet_nan = std::numeric_limits<float>::quiet_NaN();
+  float other_nan = std::nanf("1");
+  float real_value = 1.0f;
+
+  Matcher<float> m = IsNan();
+  EXPECT_TRUE(m.Matches(quiet_nan));
+  EXPECT_TRUE(m.Matches(other_nan));
+  EXPECT_FALSE(m.Matches(real_value));
+
+  Matcher<float&> m_ref = IsNan();
+  EXPECT_TRUE(m_ref.Matches(quiet_nan));
+  EXPECT_TRUE(m_ref.Matches(other_nan));
+  EXPECT_FALSE(m_ref.Matches(real_value));
+
+  Matcher<const float&> m_cref = IsNan();
+  EXPECT_TRUE(m_cref.Matches(quiet_nan));
+  EXPECT_TRUE(m_cref.Matches(other_nan));
+  EXPECT_FALSE(m_cref.Matches(real_value));
+}
+
+// Tests that IsNan() matches a NaN, with double.
+TEST(IsNan, DoubleMatchesNan) {
+  double quiet_nan = std::numeric_limits<double>::quiet_NaN();
+  double other_nan = std::nan("1");
+  double real_value = 1.0;
+
+  Matcher<double> m = IsNan();
+  EXPECT_TRUE(m.Matches(quiet_nan));
+  EXPECT_TRUE(m.Matches(other_nan));
+  EXPECT_FALSE(m.Matches(real_value));
+
+  Matcher<double&> m_ref = IsNan();
+  EXPECT_TRUE(m_ref.Matches(quiet_nan));
+  EXPECT_TRUE(m_ref.Matches(other_nan));
+  EXPECT_FALSE(m_ref.Matches(real_value));
+
+  Matcher<const double&> m_cref = IsNan();
+  EXPECT_TRUE(m_cref.Matches(quiet_nan));
+  EXPECT_TRUE(m_cref.Matches(other_nan));
+  EXPECT_FALSE(m_cref.Matches(real_value));
+}
+
+// Tests that IsNan() matches a NaN, with long double.
+TEST(IsNan, LongDoubleMatchesNan) {
+  long double quiet_nan = std::numeric_limits<long double>::quiet_NaN();
+  long double other_nan = std::nan("1");
+  long double real_value = 1.0;
+
+  Matcher<long double> m = IsNan();
+  EXPECT_TRUE(m.Matches(quiet_nan));
+  EXPECT_TRUE(m.Matches(other_nan));
+  EXPECT_FALSE(m.Matches(real_value));
+
+  Matcher<long double&> m_ref = IsNan();
+  EXPECT_TRUE(m_ref.Matches(quiet_nan));
+  EXPECT_TRUE(m_ref.Matches(other_nan));
+  EXPECT_FALSE(m_ref.Matches(real_value));
+
+  Matcher<const long double&> m_cref = IsNan();
+  EXPECT_TRUE(m_cref.Matches(quiet_nan));
+  EXPECT_TRUE(m_cref.Matches(other_nan));
+  EXPECT_FALSE(m_cref.Matches(real_value));
+}
+
+// Tests that IsNan() works with Not.
+TEST(IsNan, NotMatchesNan) {
+  Matcher<float> mf = Not(IsNan());
+  EXPECT_FALSE(mf.Matches(std::numeric_limits<float>::quiet_NaN()));
+  EXPECT_FALSE(mf.Matches(std::nanf("1")));
+  EXPECT_TRUE(mf.Matches(1.0));
+
+  Matcher<double> md = Not(IsNan());
+  EXPECT_FALSE(md.Matches(std::numeric_limits<double>::quiet_NaN()));
+  EXPECT_FALSE(md.Matches(std::nan("1")));
+  EXPECT_TRUE(md.Matches(1.0));
+
+  Matcher<long double> mld = Not(IsNan());
+  EXPECT_FALSE(mld.Matches(std::numeric_limits<long double>::quiet_NaN()));
+  EXPECT_FALSE(mld.Matches(std::nanl("1")));
+  EXPECT_TRUE(mld.Matches(1.0));
+}
+
+// Tests that IsNan() can describe itself.
+TEST(IsNan, CanDescribeSelf) {
+  Matcher<float> mf = IsNan();
+  EXPECT_EQ("is NaN", Describe(mf));
+
+  Matcher<double> md = IsNan();
+  EXPECT_EQ("is NaN", Describe(md));
+
+  Matcher<long double> mld = IsNan();
+  EXPECT_EQ("is NaN", Describe(mld));
+}
+
+// Tests that IsNan() can describe itself with Not.
+TEST(IsNan, CanDescribeSelfWithNot) {
+  Matcher<float> mf = Not(IsNan());
+  EXPECT_EQ("isn't NaN", Describe(mf));
+
+  Matcher<double> md = Not(IsNan());
+  EXPECT_EQ("isn't NaN", Describe(md));
+
+  Matcher<long double> mld = Not(IsNan());
+  EXPECT_EQ("isn't NaN", Describe(mld));
+}
+
+// Tests that FloatEq() matches a 2-tuple where
+// FloatEq(first field) matches the second field.
+TEST(FloatEq2Test, MatchesEqualArguments) {
+  typedef ::std::tuple<float, float> Tpl;
+  Matcher<const Tpl&> m = FloatEq();
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(0.3f, 0.1f + 0.1f + 0.1f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
+}
+
+// Tests that FloatEq() describes itself properly.
+TEST(FloatEq2Test, CanDescribeSelf) {
+  Matcher<const ::std::tuple<float, float>&> m = FloatEq();
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that NanSensitiveFloatEq() matches a 2-tuple where
+// NanSensitiveFloatEq(first field) matches the second field.
+TEST(NanSensitiveFloatEqTest, MatchesEqualArgumentsWithNaN) {
+  typedef ::std::tuple<float, float> Tpl;
+  Matcher<const Tpl&> m = NanSensitiveFloatEq();
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
+                            std::numeric_limits<float>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
+}
+
+// Tests that NanSensitiveFloatEq() describes itself properly.
+TEST(NanSensitiveFloatEqTest, CanDescribeSelfWithNaNs) {
+  Matcher<const ::std::tuple<float, float>&> m = NanSensitiveFloatEq();
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that DoubleEq() matches a 2-tuple where
+// DoubleEq(first field) matches the second field.
+TEST(DoubleEq2Test, MatchesEqualArguments) {
+  typedef ::std::tuple<double, double> Tpl;
+  Matcher<const Tpl&> m = DoubleEq();
+  EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
+  EXPECT_TRUE(m.Matches(Tpl(0.3, 0.1 + 0.1 + 0.1)));
+  EXPECT_FALSE(m.Matches(Tpl(1.1, 1.0)));
+}
+
+// Tests that DoubleEq() describes itself properly.
+TEST(DoubleEq2Test, CanDescribeSelf) {
+  Matcher<const ::std::tuple<double, double>&> m = DoubleEq();
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that NanSensitiveDoubleEq() matches a 2-tuple where
+// NanSensitiveDoubleEq(first field) matches the second field.
+TEST(NanSensitiveDoubleEqTest, MatchesEqualArgumentsWithNaN) {
+  typedef ::std::tuple<double, double> Tpl;
+  Matcher<const Tpl&> m = NanSensitiveDoubleEq();
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
+                            std::numeric_limits<double>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
+}
+
+// Tests that DoubleEq() describes itself properly.
+TEST(NanSensitiveDoubleEqTest, CanDescribeSelfWithNaNs) {
+  Matcher<const ::std::tuple<double, double>&> m = NanSensitiveDoubleEq();
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that FloatEq() matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field.
+TEST(FloatNear2Test, MatchesEqualArguments) {
+  typedef ::std::tuple<float, float> Tpl;
+  Matcher<const Tpl&> m = FloatNear(0.5f);
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(1.3f, 1.0f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.8f, 1.0f)));
+}
+
+// Tests that FloatNear() describes itself properly.
+TEST(FloatNear2Test, CanDescribeSelf) {
+  Matcher<const ::std::tuple<float, float>&> m = FloatNear(0.5f);
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that NanSensitiveFloatNear() matches a 2-tuple where
+// NanSensitiveFloatNear(first field) matches the second field.
+TEST(NanSensitiveFloatNearTest, MatchesNearbyArgumentsWithNaN) {
+  typedef ::std::tuple<float, float> Tpl;
+  Matcher<const Tpl&> m = NanSensitiveFloatNear(0.5f);
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
+                            std::numeric_limits<float>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
+}
+
+// Tests that NanSensitiveFloatNear() describes itself properly.
+TEST(NanSensitiveFloatNearTest, CanDescribeSelfWithNaNs) {
+  Matcher<const ::std::tuple<float, float>&> m = NanSensitiveFloatNear(0.5f);
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that FloatEq() matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field.
+TEST(DoubleNear2Test, MatchesEqualArguments) {
+  typedef ::std::tuple<double, double> Tpl;
+  Matcher<const Tpl&> m = DoubleNear(0.5);
+  EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
+  EXPECT_TRUE(m.Matches(Tpl(1.3, 1.0)));
+  EXPECT_FALSE(m.Matches(Tpl(1.8, 1.0)));
+}
+
+// Tests that DoubleNear() describes itself properly.
+TEST(DoubleNear2Test, CanDescribeSelf) {
+  Matcher<const ::std::tuple<double, double>&> m = DoubleNear(0.5);
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that NanSensitiveDoubleNear() matches a 2-tuple where
+// NanSensitiveDoubleNear(first field) matches the second field.
+TEST(NanSensitiveDoubleNearTest, MatchesNearbyArgumentsWithNaN) {
+  typedef ::std::tuple<double, double> Tpl;
+  Matcher<const Tpl&> m = NanSensitiveDoubleNear(0.5f);
+  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
+  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
+                            std::numeric_limits<double>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
+  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
+  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
+}
+
+// Tests that NanSensitiveDoubleNear() describes itself properly.
+TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
+  Matcher<const ::std::tuple<double, double>&> m = NanSensitiveDoubleNear(0.5f);
+  EXPECT_EQ("are an almost-equal pair", Describe(m));
+}
+
+// Tests that Not(m) matches any value that doesn't match m.
+TEST(NotTest, NegatesMatcher) {
+  Matcher<int> m;
+  m = Not(Eq(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+}
+
+// Tests that Not(m) describes itself properly.
+TEST(NotTest, CanDescribeSelf) {
+  Matcher<int> m = Not(Eq(5));
+  EXPECT_EQ("isn't equal to 5", Describe(m));
+}
+
+// Tests that monomorphic matchers are safely cast by the Not matcher.
+TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 is a monomorphic matcher.
+  Matcher<int> greater_than_5 = Gt(5);
+
+  Matcher<const int&> m = Not(greater_than_5);
+  Matcher<int&> m2 = Not(greater_than_5);
+  Matcher<int&> m3 = Not(m);
+}
+
+// Helper to allow easy testing of AllOf matchers with num parameters.
+void AllOfMatches(int num, const Matcher<int>& m) {
+  SCOPED_TRACE(Describe(m));
+  EXPECT_TRUE(m.Matches(0));
+  for (int i = 1; i <= num; ++i) {
+    EXPECT_FALSE(m.Matches(i));
+  }
+  EXPECT_TRUE(m.Matches(num + 1));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(AllOfTest);
+
+// Tests that AllOf(m1, ..., mn) matches any value that matches all of
+// the given matchers.
+TEST(AllOfTest, MatchesWhenAllMatch) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(0));
+  EXPECT_FALSE(m.Matches(3));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  EXPECT_TRUE(m.Matches(0));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(3));
+
+  // The following tests for varying number of sub-matchers. Due to the way
+  // the sub-matchers are handled it is enough to test every sub-matcher once
+  // with sub-matchers using the same matcher type. Varying matcher types are
+  // checked for above.
+  AllOfMatches(2, AllOf(Ne(1), Ne(2)));
+  AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
+  AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
+  AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
+  AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
+  AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
+  AllOfMatches(8,
+               AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8)));
+  AllOfMatches(
+      9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9)));
+  AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
+                         Ne(9), Ne(10)));
+  AllOfMatches(
+      50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9),
+                Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15), Ne(16), Ne(17),
+                Ne(18), Ne(19), Ne(20), Ne(21), Ne(22), Ne(23), Ne(24), Ne(25),
+                Ne(26), Ne(27), Ne(28), Ne(29), Ne(30), Ne(31), Ne(32), Ne(33),
+                Ne(34), Ne(35), Ne(36), Ne(37), Ne(38), Ne(39), Ne(40), Ne(41),
+                Ne(42), Ne(43), Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
+                Ne(50)));
+}
+
+// Tests that AllOf(m1, ..., mn) describes itself properly.
+TEST(AllOfTest, CanDescribeSelf) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  std::string expected_descr1 =
+      "(is > 0) and (isn't equal to 1) and (isn't equal to 2)";
+  EXPECT_EQ(expected_descr1, Describe(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  std::string expected_descr2 =
+      "(is > 0) and (isn't equal to 1) and (isn't equal to 2) and (isn't equal "
+      "to 3)";
+  EXPECT_EQ(expected_descr2, Describe(m));
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  std::string expected_descr3 =
+      "(is >= 0) and (is < 10) and (isn't equal to 3) and (isn't equal to 5) "
+      "and (isn't equal to 7)";
+  EXPECT_EQ(expected_descr3, Describe(m));
+}
+
+// Tests that AllOf(m1, ..., mn) describes its negation properly.
+TEST(AllOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  std::string expected_descr4 = "(isn't <= 2) or (isn't >= 1)";
+  EXPECT_EQ(expected_descr4, DescribeNegation(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  std::string expected_descr5 =
+      "(isn't > 0) or (is equal to 1) or (is equal to 2)";
+  EXPECT_EQ(expected_descr5, DescribeNegation(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  std::string expected_descr6 =
+      "(isn't > 0) or (is equal to 1) or (is equal to 2) or (is equal to 3)";
+  EXPECT_EQ(expected_descr6, DescribeNegation(m));
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  std::string expected_desr7 =
+      "(isn't >= 0) or (isn't < 10) or (is equal to 3) or (is equal to 5) or "
+      "(is equal to 7)";
+  EXPECT_EQ(expected_desr7, DescribeNegation(m));
+
+  m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9),
+            Ne(10), Ne(11));
+  AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+  EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11)"));
+  AllOfMatches(11, m);
+}
+
+// Tests that monomorphic matchers are safely cast by the AllOf matcher.
+TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 and less_than_10 are monomorphic matchers.
+  Matcher<int> greater_than_5 = Gt(5);
+  Matcher<int> less_than_10 = Lt(10);
+
+  Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
+  Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
+  Matcher<int&> m3 = AllOf(greater_than_5, m2);
+
+  // Tests that BothOf works when composing itself.
+  Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
+  Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
+}
+
+TEST_P(AllOfTestP, ExplainsResult) {
+  Matcher<int> m;
+
+  // Successful match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
+
+  // Successful match.  Both matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
+            Explain(m, 30));
+
+  // Successful match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
+  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
+            Explain(m, 25));
+
+  // Successful match.  All matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ(
+      "which is 30 more than 10, and which is 20 more than 20, "
+      "and which is 10 more than 30",
+      Explain(m, 40));
+
+  // Failed match.  The first matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 40));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
+}
+
+// Helper to allow easy testing of AnyOf matchers with num parameters.
+static void AnyOfMatches(int num, const Matcher<int>& m) {
+  SCOPED_TRACE(Describe(m));
+  EXPECT_FALSE(m.Matches(0));
+  for (int i = 1; i <= num; ++i) {
+    EXPECT_TRUE(m.Matches(i));
+  }
+  EXPECT_FALSE(m.Matches(num + 1));
+}
+
+static void AnyOfStringMatches(int num, const Matcher<std::string>& m) {
+  SCOPED_TRACE(Describe(m));
+  EXPECT_FALSE(m.Matches(std::to_string(0)));
+
+  for (int i = 1; i <= num; ++i) {
+    EXPECT_TRUE(m.Matches(std::to_string(i)));
+  }
+  EXPECT_FALSE(m.Matches(std::to_string(num + 1)));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(AnyOfTest);
+
+// Tests that AnyOf(m1, ..., mn) matches any value that matches at
+// least one of the given matchers.
+TEST(AnyOfTest, MatchesWhenAnyMatches) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(2));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_TRUE(m.Matches(-1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_TRUE(m.Matches(-1));
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(0));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_TRUE(m.Matches(0));
+  EXPECT_TRUE(m.Matches(11));
+  EXPECT_TRUE(m.Matches(3));
+  EXPECT_FALSE(m.Matches(2));
+
+  // The following tests for varying number of sub-matchers. Due to the way
+  // the sub-matchers are handled it is enough to test every sub-matcher once
+  // with sub-matchers using the same matcher type. Varying matcher types are
+  // checked for above.
+  AnyOfMatches(2, AnyOf(1, 2));
+  AnyOfMatches(3, AnyOf(1, 2, 3));
+  AnyOfMatches(4, AnyOf(1, 2, 3, 4));
+  AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
+  AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
+  AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
+  AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
+  AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
+  AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+}
+
+// Tests the variadic version of the AnyOfMatcher.
+TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
+  // Also make sure AnyOf is defined in the right namespace and does not depend
+  // on ADL.
+  Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+
+  EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11)"));
+  AnyOfMatches(11, m);
+  AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+                         31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+                         45, 46, 47, 48, 49, 50));
+  AnyOfStringMatches(
+      50, AnyOf("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
+                "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
+                "23", "24", "25", "26", "27", "28", "29", "30", "31", "32",
+                "33", "34", "35", "36", "37", "38", "39", "40", "41", "42",
+                "43", "44", "45", "46", "47", "48", "49", "50"));
+}
+
+TEST(ConditionalTest, MatchesFirstIfCondition) {
+  Matcher<std::string> eq_red = Eq("red");
+  Matcher<std::string> ne_red = Ne("red");
+  Matcher<std::string> m = Conditional(true, eq_red, ne_red);
+  EXPECT_TRUE(m.Matches("red"));
+  EXPECT_FALSE(m.Matches("green"));
+
+  StringMatchResultListener listener;
+  StringMatchResultListener expected;
+  EXPECT_FALSE(m.MatchAndExplain("green", &listener));
+  EXPECT_FALSE(eq_red.MatchAndExplain("green", &expected));
+  EXPECT_THAT(listener.str(), Eq(expected.str()));
+}
+
+TEST(ConditionalTest, MatchesSecondIfCondition) {
+  Matcher<std::string> eq_red = Eq("red");
+  Matcher<std::string> ne_red = Ne("red");
+  Matcher<std::string> m = Conditional(false, eq_red, ne_red);
+  EXPECT_FALSE(m.Matches("red"));
+  EXPECT_TRUE(m.Matches("green"));
+
+  StringMatchResultListener listener;
+  StringMatchResultListener expected;
+  EXPECT_FALSE(m.MatchAndExplain("red", &listener));
+  EXPECT_FALSE(ne_red.MatchAndExplain("red", &expected));
+  EXPECT_THAT(listener.str(), Eq(expected.str()));
+}
+
+// Tests that AnyOf(m1, ..., mn) describes itself properly.
+TEST(AnyOfTest, CanDescribeSelf) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+
+  EXPECT_EQ("(is <= 1) or (is >= 3)", Describe(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_EQ("(is < 0) or (is equal to 1) or (is equal to 2)", Describe(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_EQ("(is < 0) or (is equal to 1) or (is equal to 2) or (is equal to 3)",
+            Describe(m));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_EQ(
+      "(is <= 0) or (is > 10) or (is equal to 3) or (is equal to 5) or (is "
+      "equal to 7)",
+      Describe(m));
+}
+
+// Tests that AnyOf(m1, ..., mn) describes its negation properly.
+TEST(AnyOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_EQ("(isn't <= 1) and (isn't >= 3)", DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_EQ("(isn't < 0) and (isn't equal to 1) and (isn't equal to 2)",
+            DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_EQ(
+      "(isn't < 0) and (isn't equal to 1) and (isn't equal to 2) and (isn't "
+      "equal to 3)",
+      DescribeNegation(m));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_EQ(
+      "(isn't <= 0) and (isn't > 10) and (isn't equal to 3) and (isn't equal "
+      "to 5) and (isn't equal to 7)",
+      DescribeNegation(m));
+}
+
+// Tests that monomorphic matchers are safely cast by the AnyOf matcher.
+TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
+  // greater_than_5 and less_than_10 are monomorphic matchers.
+  Matcher<int> greater_than_5 = Gt(5);
+  Matcher<int> less_than_10 = Lt(10);
+
+  Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
+  Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
+  Matcher<int&> m3 = AnyOf(greater_than_5, m2);
+
+  // Tests that EitherOf works when composing itself.
+  Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
+  Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
+}
+
+TEST_P(AnyOfTestP, ExplainsResult) {
+  Matcher<int> m;
+
+  // Failed match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AnyOf(GreaterThan(10), Lt(0));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  Both matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
+  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ(
+      "which is 5 less than 10, and which is 15 less than 20, "
+      "and which is 25 less than 30",
+      Explain(m, 5));
+
+  // Successful match.  The first matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AnyOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 0));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(30), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
+}
+
+// The following predicate function and predicate functor are for
+// testing the Truly(predicate) matcher.
+
+// Returns non-zero if the input is positive.  Note that the return
+// type of this function is not bool.  It's OK as Truly() accepts any
+// unary function or functor whose return type can be implicitly
+// converted to bool.
+int IsPositive(double x) { return x > 0 ? 1 : 0; }
+
+// This functor returns true if the input is greater than the given
+// number.
+class IsGreaterThan {
+ public:
+  explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
+
+  bool operator()(int n) const { return n > threshold_; }
+
+ private:
+  int threshold_;
+};
+
+// For testing Truly().
+const int foo = 0;
+
+// This predicate returns true if and only if the argument references foo and
+// has a zero value.
+bool ReferencesFooAndIsZero(const int& n) { return (&n == &foo) && (n == 0); }
+
+// Tests that Truly(predicate) matches what satisfies the given
+// predicate.
+TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
+  Matcher<double> m = Truly(IsPositive);
+  EXPECT_TRUE(m.Matches(2.0));
+  EXPECT_FALSE(m.Matches(-1.5));
+}
+
+// Tests that Truly(predicate_functor) works too.
+TEST(TrulyTest, CanBeUsedWithFunctor) {
+  Matcher<int> m = Truly(IsGreaterThan(5));
+  EXPECT_TRUE(m.Matches(6));
+  EXPECT_FALSE(m.Matches(4));
+}
+
+// A class that can be implicitly converted to bool.
+class ConvertibleToBool {
+ public:
+  explicit ConvertibleToBool(int number) : number_(number) {}
+  operator bool() const { return number_ != 0; }
+
+ private:
+  int number_;
+};
+
+ConvertibleToBool IsNotZero(int number) { return ConvertibleToBool(number); }
+
+// Tests that the predicate used in Truly() may return a class that's
+// implicitly convertible to bool, even when the class has no
+// operator!().
+TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
+  Matcher<int> m = Truly(IsNotZero);
+  EXPECT_TRUE(m.Matches(1));
+  EXPECT_FALSE(m.Matches(0));
+}
+
+// Tests that Truly(predicate) can describe itself properly.
+TEST(TrulyTest, CanDescribeSelf) {
+  Matcher<double> m = Truly(IsPositive);
+  EXPECT_EQ("satisfies the given predicate", Describe(m));
+}
+
+// Tests that Truly(predicate) works when the matcher takes its
+// argument by reference.
+TEST(TrulyTest, WorksForByRefArguments) {
+  Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
+  EXPECT_TRUE(m.Matches(foo));
+  int n = 0;
+  EXPECT_FALSE(m.Matches(n));
+}
+
+// Tests that Truly(predicate) provides a helpful reason when it fails.
+TEST(TrulyTest, ExplainsFailures) {
+  StringMatchResultListener listener;
+  EXPECT_FALSE(ExplainMatchResult(Truly(IsPositive), -1, &listener));
+  EXPECT_EQ(listener.str(), "didn't satisfy the given predicate");
+}
+
+// Tests that Matches(m) is a predicate satisfied by whatever that
+// matches matcher m.
+TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
+  EXPECT_TRUE(Matches(Ge(0))(1));
+  EXPECT_FALSE(Matches(Eq('a'))('b'));
+}
+
+// Tests that Matches(m) works when the matcher takes its argument by
+// reference.
+TEST(MatchesTest, WorksOnByRefArguments) {
+  int m = 0, n = 0;
+  EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
+  EXPECT_FALSE(Matches(Ref(m))(n));
+}
+
+// Tests that a Matcher on non-reference type can be used in
+// Matches().
+TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
+  Matcher<int> eq5 = Eq(5);
+  EXPECT_TRUE(Matches(eq5)(5));
+  EXPECT_FALSE(Matches(eq5)(2));
+}
+
+// Tests Value(value, matcher).  Since Value() is a simple wrapper for
+// Matches(), which has been tested already, we don't spend a lot of
+// effort on testing Value().
+TEST(ValueTest, WorksWithPolymorphicMatcher) {
+  EXPECT_TRUE(Value("hi", StartsWith("h")));
+  EXPECT_FALSE(Value(5, Gt(10)));
+}
+
+TEST(ValueTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> is_zero = Eq(0);
+  EXPECT_TRUE(Value(0, is_zero));
+  EXPECT_FALSE(Value('a', is_zero));
+
+  int n = 0;
+  const Matcher<const int&> ref_n = Ref(n);
+  EXPECT_TRUE(Value(n, ref_n));
+  EXPECT_FALSE(Value(1, ref_n));
+}
+
+TEST(AllArgsTest, WorksForTuple) {
+  EXPECT_THAT(std::make_tuple(1, 2L), AllArgs(Lt()));
+  EXPECT_THAT(std::make_tuple(2L, 1), Not(AllArgs(Lt())));
+}
+
+TEST(AllArgsTest, WorksForNonTuple) {
+  EXPECT_THAT(42, AllArgs(Gt(0)));
+  EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
+}
+
+class AllArgsHelper {
+ public:
+  AllArgsHelper() {}
+
+  MOCK_METHOD2(Helper, int(char x, int y));
+
+ private:
+  AllArgsHelper(const AllArgsHelper&) = delete;
+  AllArgsHelper& operator=(const AllArgsHelper&) = delete;
+};
+
+TEST(AllArgsTest, WorksInWithClause) {
+  AllArgsHelper helper;
+  ON_CALL(helper, Helper(_, _)).With(AllArgs(Lt())).WillByDefault(Return(1));
+  EXPECT_CALL(helper, Helper(_, _));
+  EXPECT_CALL(helper, Helper(_, _)).With(AllArgs(Gt())).WillOnce(Return(2));
+
+  EXPECT_EQ(1, helper.Helper('\1', 2));
+  EXPECT_EQ(2, helper.Helper('a', 1));
+}
+
+class OptionalMatchersHelper {
+ public:
+  OptionalMatchersHelper() {}
+
+  MOCK_METHOD0(NoArgs, int());
+
+  MOCK_METHOD1(OneArg, int(int y));
+
+  MOCK_METHOD2(TwoArgs, int(char x, int y));
+
+  MOCK_METHOD1(Overloaded, int(char x));
+  MOCK_METHOD2(Overloaded, int(char x, int y));
+
+ private:
+  OptionalMatchersHelper(const OptionalMatchersHelper&) = delete;
+  OptionalMatchersHelper& operator=(const OptionalMatchersHelper&) = delete;
+};
+
+TEST(AllArgsTest, WorksWithoutMatchers) {
+  OptionalMatchersHelper helper;
+
+  ON_CALL(helper, NoArgs).WillByDefault(Return(10));
+  ON_CALL(helper, OneArg).WillByDefault(Return(20));
+  ON_CALL(helper, TwoArgs).WillByDefault(Return(30));
+
+  EXPECT_EQ(10, helper.NoArgs());
+  EXPECT_EQ(20, helper.OneArg(1));
+  EXPECT_EQ(30, helper.TwoArgs('\1', 2));
+
+  EXPECT_CALL(helper, NoArgs).Times(1);
+  EXPECT_CALL(helper, OneArg).WillOnce(Return(100));
+  EXPECT_CALL(helper, OneArg(17)).WillOnce(Return(200));
+  EXPECT_CALL(helper, TwoArgs).Times(0);
+
+  EXPECT_EQ(10, helper.NoArgs());
+  EXPECT_EQ(100, helper.OneArg(1));
+  EXPECT_EQ(200, helper.OneArg(17));
+}
+
+// Tests floating-point matchers.
+template <typename RawType>
+class FloatingPointTest : public testing::Test {
+ protected:
+  typedef testing::internal::FloatingPoint<RawType> Floating;
+  typedef typename Floating::Bits Bits;
+
+  FloatingPointTest()
+      : max_ulps_(Floating::kMaxUlps),
+        zero_bits_(Floating(0).bits()),
+        one_bits_(Floating(1).bits()),
+        infinity_bits_(Floating(Floating::Infinity()).bits()),
+        close_to_positive_zero_(
+            Floating::ReinterpretBits(zero_bits_ + max_ulps_ / 2)),
+        close_to_negative_zero_(
+            -Floating::ReinterpretBits(zero_bits_ + max_ulps_ - max_ulps_ / 2)),
+        further_from_negative_zero_(-Floating::ReinterpretBits(
+            zero_bits_ + max_ulps_ + 1 - max_ulps_ / 2)),
+        close_to_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_)),
+        further_from_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_ + 1)),
+        infinity_(Floating::Infinity()),
+        close_to_infinity_(
+            Floating::ReinterpretBits(infinity_bits_ - max_ulps_)),
+        further_from_infinity_(
+            Floating::ReinterpretBits(infinity_bits_ - max_ulps_ - 1)),
+        max_(Floating::Max()),
+        nan1_(Floating::ReinterpretBits(Floating::kExponentBitMask | 1)),
+        nan2_(Floating::ReinterpretBits(Floating::kExponentBitMask | 200)) {}
+
+  void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
+
+  // A battery of tests for FloatingEqMatcher::Matches.
+  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
+  void TestMatches(
+      testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) {
+    Matcher<RawType> m1 = matcher_maker(0.0);
+    EXPECT_TRUE(m1.Matches(-0.0));
+    EXPECT_TRUE(m1.Matches(close_to_positive_zero_));
+    EXPECT_TRUE(m1.Matches(close_to_negative_zero_));
+    EXPECT_FALSE(m1.Matches(1.0));
+
+    Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
+    EXPECT_FALSE(m2.Matches(further_from_negative_zero_));
+
+    Matcher<RawType> m3 = matcher_maker(1.0);
+    EXPECT_TRUE(m3.Matches(close_to_one_));
+    EXPECT_FALSE(m3.Matches(further_from_one_));
+
+    // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
+    EXPECT_FALSE(m3.Matches(0.0));
+
+    Matcher<RawType> m4 = matcher_maker(-infinity_);
+    EXPECT_TRUE(m4.Matches(-close_to_infinity_));
+
+    Matcher<RawType> m5 = matcher_maker(infinity_);
+    EXPECT_TRUE(m5.Matches(close_to_infinity_));
+
+    // This is interesting as the representations of infinity_ and nan1_
+    // are only 1 DLP apart.
+    EXPECT_FALSE(m5.Matches(nan1_));
+
+    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
+    // some cases.
+    Matcher<const RawType&> m6 = matcher_maker(0.0);
+    EXPECT_TRUE(m6.Matches(-0.0));
+    EXPECT_TRUE(m6.Matches(close_to_positive_zero_));
+    EXPECT_FALSE(m6.Matches(1.0));
+
+    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
+    // cases.
+    Matcher<RawType&> m7 = matcher_maker(0.0);
+    RawType x = 0.0;
+    EXPECT_TRUE(m7.Matches(x));
+    x = 0.01f;
+    EXPECT_FALSE(m7.Matches(x));
+  }
+
+  // Pre-calculated numbers to be used by the tests.
+
+  const Bits max_ulps_;
+
+  const Bits zero_bits_;      // The bits that represent 0.0.
+  const Bits one_bits_;       // The bits that represent 1.0.
+  const Bits infinity_bits_;  // The bits that represent +infinity.
+
+  // Some numbers close to 0.0.
+  const RawType close_to_positive_zero_;
+  const RawType close_to_negative_zero_;
+  const RawType further_from_negative_zero_;
+
+  // Some numbers close to 1.0.
+  const RawType close_to_one_;
+  const RawType further_from_one_;
+
+  // Some numbers close to +infinity.
+  const RawType infinity_;
+  const RawType close_to_infinity_;
+  const RawType further_from_infinity_;
+
+  // Maximum representable value that's not infinity.
+  const RawType max_;
+
+  // Some NaNs.
+  const RawType nan1_;
+  const RawType nan2_;
+};
+
+// Tests floating-point matchers with fixed epsilons.
+template <typename RawType>
+class FloatingPointNearTest : public FloatingPointTest<RawType> {
+ protected:
+  typedef FloatingPointTest<RawType> ParentType;
+
+  // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
+  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
+  void TestNearMatches(testing::internal::FloatingEqMatcher<RawType> (
+      *matcher_maker)(RawType, RawType)) {
+    Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
+    EXPECT_TRUE(m1.Matches(0.0));
+    EXPECT_TRUE(m1.Matches(-0.0));
+    EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_));
+    EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_));
+    EXPECT_FALSE(m1.Matches(1.0));
+
+    Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
+    EXPECT_TRUE(m2.Matches(0.0));
+    EXPECT_TRUE(m2.Matches(-0.0));
+    EXPECT_TRUE(m2.Matches(1.0));
+    EXPECT_TRUE(m2.Matches(-1.0));
+    EXPECT_FALSE(m2.Matches(ParentType::close_to_one_));
+    EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_));
+
+    // Check that inf matches inf, regardless of the of the specified max
+    // absolute error.
+    Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
+    EXPECT_TRUE(m3.Matches(ParentType::infinity_));
+    EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_));
+    EXPECT_FALSE(m3.Matches(-ParentType::infinity_));
+
+    Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
+    EXPECT_TRUE(m4.Matches(-ParentType::infinity_));
+    EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_));
+    EXPECT_FALSE(m4.Matches(ParentType::infinity_));
+
+    // Test various overflow scenarios.
+    Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
+    EXPECT_TRUE(m5.Matches(ParentType::max_));
+    EXPECT_FALSE(m5.Matches(-ParentType::max_));
+
+    Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
+    EXPECT_FALSE(m6.Matches(ParentType::max_));
+    EXPECT_TRUE(m6.Matches(-ParentType::max_));
+
+    Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
+    EXPECT_TRUE(m7.Matches(ParentType::max_));
+    EXPECT_FALSE(m7.Matches(-ParentType::max_));
+
+    Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
+    EXPECT_FALSE(m8.Matches(ParentType::max_));
+    EXPECT_TRUE(m8.Matches(-ParentType::max_));
+
+    // The difference between max() and -max() normally overflows to infinity,
+    // but it should still match if the max_abs_error is also infinity.
+    Matcher<RawType> m9 =
+        matcher_maker(ParentType::max_, ParentType::infinity_);
+    EXPECT_TRUE(m8.Matches(-ParentType::max_));
+
+    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
+    // some cases.
+    Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
+    EXPECT_TRUE(m10.Matches(-0.0));
+    EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_));
+    EXPECT_FALSE(m10.Matches(ParentType::close_to_one_));
+
+    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
+    // cases.
+    Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
+    RawType x = 0.0;
+    EXPECT_TRUE(m11.Matches(x));
+    x = 1.0f;
+    EXPECT_TRUE(m11.Matches(x));
+    x = -1.0f;
+    EXPECT_TRUE(m11.Matches(x));
+    x = 1.1f;
+    EXPECT_FALSE(m11.Matches(x));
+    x = -1.1f;
+    EXPECT_FALSE(m11.Matches(x));
+  }
+};
+
+// Instantiate FloatingPointTest for testing floats.
+typedef FloatingPointTest<float> FloatTest;
+
+TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) { TestMatches(&FloatEq); }
+
+TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
+  TestMatches(&NanSensitiveFloatEq);
+}
+
+TEST_F(FloatTest, FloatEqCannotMatchNaN) {
+  // FloatEq never matches NaN.
+  Matcher<float> m = FloatEq(nan1_);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
+  // NanSensitiveFloatEq will match NaN.
+  Matcher<float> m = NanSensitiveFloatEq(nan1_);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatTest, FloatEqCanDescribeSelf) {
+  Matcher<float> m1 = FloatEq(2.0f);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<float> m2 = FloatEq(0.5f);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<float> m3 = FloatEq(nan1_);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
+  Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+// Instantiate FloatingPointTest for testing floats with a user-specified
+// max absolute error.
+typedef FloatingPointNearTest<float> FloatNearTest;
+
+TEST_F(FloatNearTest, FloatNearMatches) { TestNearMatches(&FloatNear); }
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) {
+  TestNearMatches(&NanSensitiveFloatNear);
+}
+
+TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
+  Matcher<float> m1 = FloatNear(2.0f, 0.5f);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ("isn't approximately 2 (absolute error > 0.5)",
+            DescribeNegation(m1));
+
+  Matcher<float> m2 = FloatNear(0.5f, 0.5f);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5 (absolute error > 0.5)",
+            DescribeNegation(m2));
+
+  Matcher<float> m3 = FloatNear(nan1_, 0.0);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
+  Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ("isn't approximately 2 (absolute error > 0.5)",
+            DescribeNegation(m1));
+
+  Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5 (absolute error > 0.5)",
+            DescribeNegation(m2));
+
+  Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
+  // FloatNear never matches NaN.
+  Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
+  // NanSensitiveFloatNear will match NaN.
+  Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+// Instantiate FloatingPointTest for testing doubles.
+typedef FloatingPointTest<double> DoubleTest;
+
+TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
+  TestMatches(&DoubleEq);
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
+  TestMatches(&NanSensitiveDoubleEq);
+}
+
+TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
+  // DoubleEq never matches NaN.
+  Matcher<double> m = DoubleEq(nan1_);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
+  // NanSensitiveDoubleEq will match NaN.
+  Matcher<double> m = NanSensitiveDoubleEq(nan1_);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
+  Matcher<double> m1 = DoubleEq(2.0);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<double> m2 = DoubleEq(0.5);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<double> m3 = DoubleEq(nan1_);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
+  Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
+  EXPECT_EQ("is approximately 2", Describe(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
+
+  Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
+  EXPECT_EQ("is approximately 0.5", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
+
+  Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+// Instantiate FloatingPointTest for testing floats with a user-specified
+// max absolute error.
+typedef FloatingPointNearTest<double> DoubleNearTest;
+
+TEST_F(DoubleNearTest, DoubleNearMatches) { TestNearMatches(&DoubleNear); }
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) {
+  TestNearMatches(&NanSensitiveDoubleNear);
+}
+
+TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
+  Matcher<double> m1 = DoubleNear(2.0, 0.5);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ("isn't approximately 2 (absolute error > 0.5)",
+            DescribeNegation(m1));
+
+  Matcher<double> m2 = DoubleNear(0.5, 0.5);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5 (absolute error > 0.5)",
+            DescribeNegation(m2));
+
+  Matcher<double> m3 = DoubleNear(nan1_, 0.0);
+  EXPECT_EQ("never matches", Describe(m3));
+  EXPECT_EQ("is anything", DescribeNegation(m3));
+}
+
+TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
+  EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
+  EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
+  EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
+
+  const std::string explanation =
+      Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
+  // Different C++ implementations may print floating-point numbers
+  // slightly differently.
+  EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" ||  // GCC
+              explanation == "which is 1.2e-010 from 2.1")   // MSVC
+      << " where explanation is \"" << explanation << "\".";
+}
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
+  Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
+  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
+  EXPECT_EQ("isn't approximately 2 (absolute error > 0.5)",
+            DescribeNegation(m1));
+
+  Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
+  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
+  EXPECT_EQ("isn't approximately 0.5 (absolute error > 0.5)",
+            DescribeNegation(m2));
+
+  Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
+  EXPECT_EQ("is NaN", Describe(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
+}
+
+TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
+  // DoubleNear never matches NaN.
+  Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
+  EXPECT_FALSE(m.Matches(nan1_));
+  EXPECT_FALSE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
+  // NanSensitiveDoubleNear will match NaN.
+  Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
+  EXPECT_TRUE(m.Matches(nan1_));
+  EXPECT_TRUE(m.Matches(nan2_));
+  EXPECT_FALSE(m.Matches(1.0));
+}
+
+TEST(NotTest, WorksOnMoveOnlyType) {
+  std::unique_ptr<int> p(new int(3));
+  EXPECT_THAT(p, Pointee(Eq(3)));
+  EXPECT_THAT(p, Not(Pointee(Eq(2))));
+}
+
+TEST(AllOfTest, HugeMatcher) {
+  // Verify that using AllOf with many arguments doesn't cause
+  // the compiler to exceed template instantiation depth limit.
+  EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _,
+                                testing::AllOf(_, _, _, _, _, _, _, _, _, _)));
+}
+
+TEST(AnyOfTest, HugeMatcher) {
+  // Verify that using AnyOf with many arguments doesn't cause
+  // the compiler to exceed template instantiation depth limit.
+  EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _,
+                                testing::AnyOf(_, _, _, _, _, _, _, _, _, _)));
+}
+
+namespace adl_test {
+
+// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf
+// don't issue unqualified recursive calls.  If they do, the argument dependent
+// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found
+// as a candidate and the compilation will break due to an ambiguous overload.
+
+// The matcher must be in the same namespace as AllOf/AnyOf to make argument
+// dependent lookup find those.
+MATCHER(M, "") {
+  (void)arg;
+  return true;
+}
+
+template <typename T1, typename T2>
+bool AllOf(const T1& /*t1*/, const T2& /*t2*/) {
+  return true;
+}
+
+TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
+  EXPECT_THAT(42,
+              testing::AllOf(M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
+}
+
+template <typename T1, typename T2>
+bool AnyOf(const T1&, const T2&) {
+  return true;
+}
+
+TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
+  EXPECT_THAT(42,
+              testing::AnyOf(M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
+}
+
+}  // namespace adl_test
+
+TEST(AllOfTest, WorksOnMoveOnlyType) {
+  std::unique_ptr<int> p(new int(3));
+  EXPECT_THAT(p, AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(5))));
+  EXPECT_THAT(p, Not(AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(3)))));
+}
+
+TEST(AnyOfTest, WorksOnMoveOnlyType) {
+  std::unique_ptr<int> p(new int(3));
+  EXPECT_THAT(p, AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Lt(5))));
+  EXPECT_THAT(p, Not(AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Gt(5)))));
+}
+
+}  // namespace
+}  // namespace gmock_matchers_test
+}  // namespace testing
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/googletest/googlemock/test/gmock-matchers-comparisons_test.cc b/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0cf731ff099bd0fc7aacfb20e3fac207a2003162
--- /dev/null
+++ b/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
@@ -0,0 +1,2359 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
+
+// Silence warning C4244: 'initializing': conversion from 'int' to 'short',
+// possible loss of data and C4100, unreferenced local parameter
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4100)
+#endif
+
+#include <vector>
+
+#include "test/gmock-matchers_test.h"
+
+namespace testing {
+namespace gmock_matchers_test {
+namespace {
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(MonotonicMatcherTest);
+
+TEST_P(MonotonicMatcherTestP, IsPrintable) {
+  stringstream ss;
+  ss << GreaterThan(5);
+  EXPECT_EQ("is > 5", ss.str());
+}
+
+TEST(MatchResultListenerTest, StreamingWorks) {
+  StringMatchResultListener listener;
+  listener << "hi" << 5;
+  EXPECT_EQ("hi5", listener.str());
+
+  listener.Clear();
+  EXPECT_EQ("", listener.str());
+
+  listener << 42;
+  EXPECT_EQ("42", listener.str());
+
+  // Streaming shouldn't crash when the underlying ostream is NULL.
+  DummyMatchResultListener dummy;
+  dummy << "hi" << 5;
+}
+
+TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
+  EXPECT_TRUE(DummyMatchResultListener().stream() == nullptr);
+  EXPECT_TRUE(StreamMatchResultListener(nullptr).stream() == nullptr);
+
+  EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
+}
+
+TEST(MatchResultListenerTest, IsInterestedWorks) {
+  EXPECT_TRUE(StringMatchResultListener().IsInterested());
+  EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
+
+  EXPECT_FALSE(DummyMatchResultListener().IsInterested());
+  EXPECT_FALSE(StreamMatchResultListener(nullptr).IsInterested());
+}
+
+// Makes sure that the MatcherInterface<T> interface doesn't
+// change.
+class EvenMatcherImpl : public MatcherInterface<int> {
+ public:
+  bool MatchAndExplain(int x,
+                       MatchResultListener* /* listener */) const override {
+    return x % 2 == 0;
+  }
+
+  void DescribeTo(ostream* os) const override { *os << "is an even number"; }
+
+  // We deliberately don't define DescribeNegationTo() and
+  // ExplainMatchResultTo() here, to make sure the definition of these
+  // two methods is optional.
+};
+
+// Makes sure that the MatcherInterface API doesn't change.
+TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
+  EvenMatcherImpl m;
+}
+
+// Tests implementing a monomorphic matcher using MatchAndExplain().
+
+class NewEvenMatcherImpl : public MatcherInterface<int> {
+ public:
+  bool MatchAndExplain(int x, MatchResultListener* listener) const override {
+    const bool match = x % 2 == 0;
+    // Verifies that we can stream to a listener directly.
+    *listener << "value % " << 2;
+    if (listener->stream() != nullptr) {
+      // Verifies that we can stream to a listener's underlying stream
+      // too.
+      *listener->stream() << " == " << (x % 2);
+    }
+    return match;
+  }
+
+  void DescribeTo(ostream* os) const override { *os << "is an even number"; }
+};
+
+TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
+  Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
+  EXPECT_TRUE(m.Matches(2));
+  EXPECT_FALSE(m.Matches(3));
+  EXPECT_EQ("value % 2 == 0", Explain(m, 2));
+  EXPECT_EQ("value % 2 == 1", Explain(m, 3));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(MatcherTest);
+
+// Tests default-constructing a matcher.
+TEST(MatcherTest, CanBeDefaultConstructed) { Matcher<double> m; }
+
+// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
+TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
+  const MatcherInterface<int>* impl = new EvenMatcherImpl;
+  Matcher<int> m(impl);
+  EXPECT_TRUE(m.Matches(4));
+  EXPECT_FALSE(m.Matches(5));
+}
+
+// Tests that value can be used in place of Eq(value).
+TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
+  Matcher<int> m1 = 5;
+  EXPECT_TRUE(m1.Matches(5));
+  EXPECT_FALSE(m1.Matches(6));
+}
+
+// Tests that NULL can be used in place of Eq(NULL).
+TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
+  Matcher<int*> m1 = nullptr;
+  EXPECT_TRUE(m1.Matches(nullptr));
+  int n = 0;
+  EXPECT_FALSE(m1.Matches(&n));
+}
+
+// Tests that matchers can be constructed from a variable that is not properly
+// defined. This should be illegal, but many users rely on this accidentally.
+struct Undefined {
+  virtual ~Undefined() = 0;
+  static const int kInt = 1;
+};
+
+TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
+  Matcher<int> m1 = Undefined::kInt;
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_FALSE(m1.Matches(2));
+}
+
+// Test that a matcher parameterized with an abstract class compiles.
+TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&> m = _; }
+
+// Tests that matchers are copyable.
+TEST(MatcherTest, IsCopyable) {
+  // Tests the copy constructor.
+  Matcher<bool> m1 = Eq(false);
+  EXPECT_TRUE(m1.Matches(false));
+  EXPECT_FALSE(m1.Matches(true));
+
+  // Tests the assignment operator.
+  m1 = Eq(true);
+  EXPECT_TRUE(m1.Matches(true));
+  EXPECT_FALSE(m1.Matches(false));
+}
+
+// Tests that Matcher<T>::DescribeTo() calls
+// MatcherInterface<T>::DescribeTo().
+TEST(MatcherTest, CanDescribeItself) {
+  EXPECT_EQ("is an even number", Describe(Matcher<int>(new EvenMatcherImpl)));
+}
+
+// Tests Matcher<T>::MatchAndExplain().
+TEST_P(MatcherTestP, MatchAndExplain) {
+  Matcher<int> m = GreaterThan(0);
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
+  EXPECT_EQ("which is 42 more than 0", listener1.str());
+
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
+  EXPECT_EQ("which is 9 less than 0", listener2.str());
+}
+
+// Tests that a C-string literal can be implicitly converted to a
+// Matcher<std::string> or Matcher<const std::string&>.
+TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
+  Matcher<std::string> m1 = "hi";
+  EXPECT_TRUE(m1.Matches("hi"));
+  EXPECT_FALSE(m1.Matches("hello"));
+
+  Matcher<const std::string&> m2 = "hi";
+  EXPECT_TRUE(m2.Matches("hi"));
+  EXPECT_FALSE(m2.Matches("hello"));
+}
+
+// Tests that a string object can be implicitly converted to a
+// Matcher<std::string> or Matcher<const std::string&>.
+TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
+  Matcher<std::string> m1 = std::string("hi");
+  EXPECT_TRUE(m1.Matches("hi"));
+  EXPECT_FALSE(m1.Matches("hello"));
+
+  Matcher<const std::string&> m2 = std::string("hi");
+  EXPECT_TRUE(m2.Matches("hi"));
+  EXPECT_FALSE(m2.Matches("hello"));
+}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Tests that a C-string literal can be implicitly converted to a
+// Matcher<StringView> or Matcher<const StringView&>.
+TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
+  Matcher<internal::StringView> m1 = "cats";
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const internal::StringView&> m2 = "cats";
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that a std::string object can be implicitly converted to a
+// Matcher<StringView> or Matcher<const StringView&>.
+TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
+  Matcher<internal::StringView> m1 = std::string("cats");
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const internal::StringView&> m2 = std::string("cats");
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that a StringView object can be implicitly converted to a
+// Matcher<StringView> or Matcher<const StringView&>.
+TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
+  Matcher<internal::StringView> m1 = internal::StringView("cats");
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const internal::StringView&> m2 = internal::StringView("cats");
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+// Tests that a std::reference_wrapper<std::string> object can be implicitly
+// converted to a Matcher<std::string> or Matcher<const std::string&> via Eq().
+TEST(StringMatcherTest,
+     CanBeImplicitlyConstructedFromEqReferenceWrapperString) {
+  std::string value = "cats";
+  Matcher<std::string> m1 = Eq(std::ref(value));
+  EXPECT_TRUE(m1.Matches("cats"));
+  EXPECT_FALSE(m1.Matches("dogs"));
+
+  Matcher<const std::string&> m2 = Eq(std::ref(value));
+  EXPECT_TRUE(m2.Matches("cats"));
+  EXPECT_FALSE(m2.Matches("dogs"));
+}
+
+// Tests that MakeMatcher() constructs a Matcher<T> from a
+// MatcherInterface* without requiring the user to explicitly
+// write the type.
+TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
+  const MatcherInterface<int>* dummy_impl = new EvenMatcherImpl;
+  Matcher<int> m = MakeMatcher(dummy_impl);
+}
+
+// Tests that MakePolymorphicMatcher() can construct a polymorphic
+// matcher from its implementation using the old API.
+const int g_bar = 1;
+class ReferencesBarOrIsZeroImpl {
+ public:
+  template <typename T>
+  bool MatchAndExplain(const T& x, MatchResultListener* /* listener */) const {
+    const void* p = &x;
+    return p == &g_bar || x == 0;
+  }
+
+  void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "doesn't reference g_bar and is not zero";
+  }
+};
+
+// This function verifies that MakePolymorphicMatcher() returns a
+// PolymorphicMatcher<T> where T is the argument's type.
+PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
+  return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
+}
+
+TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
+  // Using a polymorphic matcher to match a reference type.
+  Matcher<const int&> m1 = ReferencesBarOrIsZero();
+  EXPECT_TRUE(m1.Matches(0));
+  // Verifies that the identity of a by-reference argument is preserved.
+  EXPECT_TRUE(m1.Matches(g_bar));
+  EXPECT_FALSE(m1.Matches(1));
+  EXPECT_EQ("g_bar or zero", Describe(m1));
+
+  // Using a polymorphic matcher to match a value type.
+  Matcher<double> m2 = ReferencesBarOrIsZero();
+  EXPECT_TRUE(m2.Matches(0.0));
+  EXPECT_FALSE(m2.Matches(0.1));
+  EXPECT_EQ("g_bar or zero", Describe(m2));
+}
+
+// Tests implementing a polymorphic matcher using MatchAndExplain().
+
+class PolymorphicIsEvenImpl {
+ public:
+  void DescribeTo(ostream* os) const { *os << "is even"; }
+
+  void DescribeNegationTo(ostream* os) const { *os << "is odd"; }
+
+  template <typename T>
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
+    // Verifies that we can stream to the listener directly.
+    *listener << "% " << 2;
+    if (listener->stream() != nullptr) {
+      // Verifies that we can stream to the listener's underlying stream
+      // too.
+      *listener->stream() << " == " << (x % 2);
+    }
+    return (x % 2) == 0;
+  }
+};
+
+PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
+  return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
+}
+
+TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
+  // Using PolymorphicIsEven() as a Matcher<int>.
+  const Matcher<int> m1 = PolymorphicIsEven();
+  EXPECT_TRUE(m1.Matches(42));
+  EXPECT_FALSE(m1.Matches(43));
+  EXPECT_EQ("is even", Describe(m1));
+
+  const Matcher<int> not_m1 = Not(m1);
+  EXPECT_EQ("is odd", Describe(not_m1));
+
+  EXPECT_EQ("% 2 == 0", Explain(m1, 42));
+
+  // Using PolymorphicIsEven() as a Matcher<char>.
+  const Matcher<char> m2 = PolymorphicIsEven();
+  EXPECT_TRUE(m2.Matches('\x42'));
+  EXPECT_FALSE(m2.Matches('\x43'));
+  EXPECT_EQ("is even", Describe(m2));
+
+  const Matcher<char> not_m2 = Not(m2);
+  EXPECT_EQ("is odd", Describe(not_m2));
+
+  EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(MatcherCastTest);
+
+// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
+TEST_P(MatcherCastTestP, FromPolymorphicMatcher) {
+  Matcher<int16_t> m;
+  if (use_gtest_matcher_) {
+    m = MatcherCast<int16_t>(GtestGreaterThan(int64_t{5}));
+  } else {
+    m = MatcherCast<int16_t>(Gt(int64_t{5}));
+  }
+  EXPECT_TRUE(m.Matches(6));
+  EXPECT_FALSE(m.Matches(4));
+}
+
+// For testing casting matchers between compatible types.
+class IntValue {
+ public:
+  // An int can be statically (although not implicitly) cast to a
+  // IntValue.
+  explicit IntValue(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+
+ private:
+  int value_;
+};
+
+// For testing casting matchers between compatible types.
+bool IsPositiveIntValue(const IntValue& foo) { return foo.value() > 0; }
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
+// can be statically converted to U.
+TEST(MatcherCastTest, FromCompatibleType) {
+  Matcher<double> m1 = Eq(2.0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(2));
+  EXPECT_FALSE(m2.Matches(3));
+
+  Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
+  Matcher<int> m4 = MatcherCast<int>(m3);
+  // In the following, the arguments 1 and 0 are statically converted
+  // to IntValue objects, and then tested by the IsPositiveIntValue()
+  // predicate.
+  EXPECT_TRUE(m4.Matches(1));
+  EXPECT_FALSE(m4.Matches(0));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
+TEST(MatcherCastTest, FromConstReferenceToNonReference) {
+  Matcher<const int&> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
+TEST(MatcherCastTest, FromReferenceToNonReference) {
+  Matcher<int&> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromNonReferenceToConstReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<const int&> m2 = MatcherCast<const int&>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromNonReferenceToReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int&> m2 = MatcherCast<int&>(m1);
+  int n = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  n = 1;
+  EXPECT_FALSE(m2.Matches(n));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
+TEST(MatcherCastTest, FromSameType) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int> m2 = MatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a value of the same type as the
+// value type of the Matcher.
+TEST(MatcherCastTest, FromAValue) {
+  Matcher<int> m = MatcherCast<int>(42);
+  EXPECT_TRUE(m.Matches(42));
+  EXPECT_FALSE(m.Matches(239));
+}
+
+// Tests that MatcherCast<T>(m) works when m is a value of the type implicitly
+// convertible to the value type of the Matcher.
+TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
+  const int kExpected = 'c';
+  Matcher<int> m = MatcherCast<int>('c');
+  EXPECT_TRUE(m.Matches(kExpected));
+  EXPECT_FALSE(m.Matches(kExpected + 1));
+}
+
+struct NonImplicitlyConstructibleTypeWithOperatorEq {
+  friend bool operator==(
+      const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */,
+      int rhs) {
+    return 42 == rhs;
+  }
+  friend bool operator==(
+      int lhs,
+      const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */) {
+    return lhs == 42;
+  }
+};
+
+// Tests that MatcherCast<T>(m) works when m is a neither a matcher nor
+// implicitly convertible to the value type of the Matcher, but the value type
+// of the matcher has operator==() overload accepting m.
+TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
+  Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m1 =
+      MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(42);
+  EXPECT_TRUE(m1.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
+
+  Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m2 =
+      MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(239);
+  EXPECT_FALSE(m2.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
+
+  // When updating the following lines please also change the comment to
+  // namespace convertible_from_any.
+  Matcher<int> m3 =
+      MatcherCast<int>(NonImplicitlyConstructibleTypeWithOperatorEq());
+  EXPECT_TRUE(m3.Matches(42));
+  EXPECT_FALSE(m3.Matches(239));
+}
+
+// ConvertibleFromAny does not work with MSVC. resulting in
+// error C2440: 'initializing': cannot convert from 'Eq' to 'M'
+// No constructor could take the source type, or constructor overload
+// resolution was ambiguous
+
+#if !defined _MSC_VER
+
+// The below ConvertibleFromAny struct is implicitly constructible from anything
+// and when in the same namespace can interact with other tests. In particular,
+// if it is in the same namespace as other tests and one removes
+//   NonImplicitlyConstructibleTypeWithOperatorEq::operator==(int lhs, ...);
+// then the corresponding test still compiles (and it should not!) by implicitly
+// converting NonImplicitlyConstructibleTypeWithOperatorEq to ConvertibleFromAny
+// in m3.Matcher().
+namespace convertible_from_any {
+// Implicitly convertible from any type.
+struct ConvertibleFromAny {
+  ConvertibleFromAny(int a_value) : value(a_value) {}
+  template <typename T>
+  ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
+    ADD_FAILURE() << "Conversion constructor called";
+  }
+  int value;
+};
+
+bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
+  return a.value == b.value;
+}
+
+ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
+  return os << a.value;
+}
+
+TEST(MatcherCastTest, ConversionConstructorIsUsed) {
+  Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+TEST(MatcherCastTest, FromConvertibleFromAny) {
+  Matcher<ConvertibleFromAny> m =
+      MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+}  // namespace convertible_from_any
+
+#endif  // !defined _MSC_VER
+
+struct IntReferenceWrapper {
+  IntReferenceWrapper(const int& a_value) : value(&a_value) {}
+  const int* value;
+};
+
+bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
+  return a.value == b.value;
+}
+
+TEST(MatcherCastTest, ValueIsNotCopied) {
+  int n = 42;
+  Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
+  // Verify that the matcher holds a reference to n, not to its temporary copy.
+  EXPECT_TRUE(m.Matches(n));
+}
+
+class Base {
+ public:
+  virtual ~Base() {}
+  Base() {}
+
+ private:
+  Base(const Base&) = delete;
+  Base& operator=(const Base&) = delete;
+};
+
+class Derived : public Base {
+ public:
+  Derived() : Base() {}
+  int i;
+};
+
+class OtherDerived : public Base {};
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(SafeMatcherCastTest);
+
+// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
+TEST_P(SafeMatcherCastTestP, FromPolymorphicMatcher) {
+  Matcher<char> m2;
+  if (use_gtest_matcher_) {
+    m2 = SafeMatcherCast<char>(GtestGreaterThan(32));
+  } else {
+    m2 = SafeMatcherCast<char>(Gt(32));
+  }
+  EXPECT_TRUE(m2.Matches('A'));
+  EXPECT_FALSE(m2.Matches('\n'));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
+// T and U are arithmetic types and T can be losslessly converted to
+// U.
+TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
+  Matcher<double> m1 = DoubleEq(1.0);
+  Matcher<float> m2 = SafeMatcherCast<float>(m1);
+  EXPECT_TRUE(m2.Matches(1.0f));
+  EXPECT_FALSE(m2.Matches(2.0f));
+
+  Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
+  EXPECT_TRUE(m3.Matches('a'));
+  EXPECT_FALSE(m3.Matches('b'));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
+// are pointers or references to a derived and a base class, correspondingly.
+TEST(SafeMatcherCastTest, FromBaseClass) {
+  Derived d, d2;
+  Matcher<Base*> m1 = Eq(&d);
+  Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
+  EXPECT_TRUE(m2.Matches(&d));
+  EXPECT_FALSE(m2.Matches(&d2));
+
+  Matcher<Base&> m3 = Ref(d);
+  Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
+  EXPECT_TRUE(m4.Matches(d));
+  EXPECT_FALSE(m4.Matches(d2));
+}
+
+// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
+TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
+  int n = 0;
+  Matcher<const int&> m1 = Ref(n);
+  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
+  int n1 = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  EXPECT_FALSE(m2.Matches(n1));
+}
+
+// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
+  Matcher<std::unique_ptr<int>> m1 = IsNull();
+  Matcher<const std::unique_ptr<int>&> m2 =
+      SafeMatcherCast<const std::unique_ptr<int>&>(m1);
+  EXPECT_TRUE(m2.Matches(std::unique_ptr<int>()));
+  EXPECT_FALSE(m2.Matches(std::unique_ptr<int>(new int)));
+}
+
+// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
+  int n = 0;
+  EXPECT_TRUE(m2.Matches(n));
+  n = 1;
+  EXPECT_FALSE(m2.Matches(n));
+}
+
+// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
+TEST(SafeMatcherCastTest, FromSameType) {
+  Matcher<int> m1 = Eq(0);
+  Matcher<int> m2 = SafeMatcherCast<int>(m1);
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
+}
+
+#if !defined _MSC_VER
+
+namespace convertible_from_any {
+TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
+  Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+
+TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
+  Matcher<ConvertibleFromAny> m =
+      SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
+  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
+  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
+}
+}  // namespace convertible_from_any
+
+#endif  // !defined _MSC_VER
+
+TEST(SafeMatcherCastTest, ValueIsNotCopied) {
+  int n = 42;
+  Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
+  // Verify that the matcher holds a reference to n, not to its temporary copy.
+  EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(ExpectThat, TakesLiterals) {
+  EXPECT_THAT(1, 1);
+  EXPECT_THAT(1.0, 1.0);
+  EXPECT_THAT(std::string(), "");
+}
+
+TEST(ExpectThat, TakesFunctions) {
+  struct Helper {
+    static void Func() {}
+  };
+  void (*func)() = Helper::Func;
+  EXPECT_THAT(func, Helper::Func);
+  EXPECT_THAT(func, &Helper::Func);
+}
+
+// Tests that A<T>() matches any value of type T.
+TEST(ATest, MatchesAnyValue) {
+  // Tests a matcher for a value type.
+  Matcher<double> m1 = A<double>();
+  EXPECT_TRUE(m1.Matches(91.43));
+  EXPECT_TRUE(m1.Matches(-15.32));
+
+  // Tests a matcher for a reference type.
+  int a = 2;
+  int b = -6;
+  Matcher<int&> m2 = A<int&>();
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+TEST(ATest, WorksForDerivedClass) {
+  Base base;
+  Derived derived;
+  EXPECT_THAT(&base, A<Base*>());
+  // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
+  EXPECT_THAT(&derived, A<Base*>());
+  EXPECT_THAT(&derived, A<Derived*>());
+}
+
+// Tests that A<T>() describes itself properly.
+TEST(ATest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(A<bool>())); }
+
+// Tests that An<T>() matches any value of type T.
+TEST(AnTest, MatchesAnyValue) {
+  // Tests a matcher for a value type.
+  Matcher<int> m1 = An<int>();
+  EXPECT_TRUE(m1.Matches(9143));
+  EXPECT_TRUE(m1.Matches(-1532));
+
+  // Tests a matcher for a reference type.
+  int a = 2;
+  int b = -6;
+  Matcher<int&> m2 = An<int&>();
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+// Tests that An<T>() describes itself properly.
+TEST(AnTest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(An<int>())); }
+
+// Tests that _ can be used as a matcher for any type and matches any
+// value of that type.
+TEST(UnderscoreTest, MatchesAnyValue) {
+  // Uses _ as a matcher for a value type.
+  Matcher<int> m1 = _;
+  EXPECT_TRUE(m1.Matches(123));
+  EXPECT_TRUE(m1.Matches(-242));
+
+  // Uses _ as a matcher for a reference type.
+  bool a = false;
+  const bool b = true;
+  Matcher<const bool&> m2 = _;
+  EXPECT_TRUE(m2.Matches(a));
+  EXPECT_TRUE(m2.Matches(b));
+}
+
+// Tests that _ describes itself properly.
+TEST(UnderscoreTest, CanDescribeSelf) {
+  Matcher<int> m = _;
+  EXPECT_EQ("is anything", Describe(m));
+}
+
+// Tests that Eq(x) matches any value equal to x.
+TEST(EqTest, MatchesEqualValue) {
+  // 2 C-strings with same content but different addresses.
+  const char a1[] = "hi";
+  const char a2[] = "hi";
+
+  Matcher<const char*> m1 = Eq(a1);
+  EXPECT_TRUE(m1.Matches(a1));
+  EXPECT_FALSE(m1.Matches(a2));
+}
+
+// Tests that Eq(v) describes itself properly.
+
+class Unprintable {
+ public:
+  Unprintable() : c_('a') {}
+
+  bool operator==(const Unprintable& /* rhs */) const { return true; }
+  // -Wunused-private-field: dummy accessor for `c_`.
+  char dummy_c() { return c_; }
+
+ private:
+  char c_;
+};
+
+TEST(EqTest, CanDescribeSelf) {
+  Matcher<Unprintable> m = Eq(Unprintable());
+  EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
+}
+
+// Tests that Eq(v) can be used to match any type that supports
+// comparing with type T, where T is v's type.
+TEST(EqTest, IsPolymorphic) {
+  Matcher<int> m1 = Eq(1);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_FALSE(m1.Matches(2));
+
+  Matcher<char> m2 = Eq(1);
+  EXPECT_TRUE(m2.Matches('\1'));
+  EXPECT_FALSE(m2.Matches('a'));
+}
+
+// Tests that TypedEq<T>(v) matches values of type T that's equal to v.
+TEST(TypedEqTest, ChecksEqualityForGivenType) {
+  Matcher<char> m1 = TypedEq<char>('a');
+  EXPECT_TRUE(m1.Matches('a'));
+  EXPECT_FALSE(m1.Matches('b'));
+
+  Matcher<int> m2 = TypedEq<int>(6);
+  EXPECT_TRUE(m2.Matches(6));
+  EXPECT_FALSE(m2.Matches(7));
+}
+
+// Tests that TypedEq(v) describes itself properly.
+TEST(TypedEqTest, CanDescribeSelf) {
+  EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
+}
+
+// Tests that TypedEq<T>(v) has type Matcher<T>.
+
+// Type<T>::IsTypeOf(v) compiles if and only if the type of value v is T, where
+// T is a "bare" type (i.e. not in the form of const U or U&).  If v's type is
+// not T, the compiler will generate a message about "undefined reference".
+template <typename T>
+struct Type {
+  static bool IsTypeOf(const T& /* v */) { return true; }
+
+  template <typename T2>
+  static void IsTypeOf(T2 v);
+};
+
+TEST(TypedEqTest, HasSpecifiedType) {
+  // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
+  Type<Matcher<int>>::IsTypeOf(TypedEq<int>(5));
+  Type<Matcher<double>>::IsTypeOf(TypedEq<double>(5));
+}
+
+// Tests that Ge(v) matches anything >= v.
+TEST(GeTest, ImplementsGreaterThanOrEqual) {
+  Matcher<int> m1 = Ge(0);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_TRUE(m1.Matches(0));
+  EXPECT_FALSE(m1.Matches(-1));
+}
+
+// Tests that Ge(v) describes itself properly.
+TEST(GeTest, CanDescribeSelf) {
+  Matcher<int> m = Ge(5);
+  EXPECT_EQ("is >= 5", Describe(m));
+}
+
+// Tests that Gt(v) matches anything > v.
+TEST(GtTest, ImplementsGreaterThan) {
+  Matcher<double> m1 = Gt(0);
+  EXPECT_TRUE(m1.Matches(1.0));
+  EXPECT_FALSE(m1.Matches(0.0));
+  EXPECT_FALSE(m1.Matches(-1.0));
+}
+
+// Tests that Gt(v) describes itself properly.
+TEST(GtTest, CanDescribeSelf) {
+  Matcher<int> m = Gt(5);
+  EXPECT_EQ("is > 5", Describe(m));
+}
+
+// Tests that Le(v) matches anything <= v.
+TEST(LeTest, ImplementsLessThanOrEqual) {
+  Matcher<char> m1 = Le('b');
+  EXPECT_TRUE(m1.Matches('a'));
+  EXPECT_TRUE(m1.Matches('b'));
+  EXPECT_FALSE(m1.Matches('c'));
+}
+
+// Tests that Le(v) describes itself properly.
+TEST(LeTest, CanDescribeSelf) {
+  Matcher<int> m = Le(5);
+  EXPECT_EQ("is <= 5", Describe(m));
+}
+
+// Tests that Lt(v) matches anything < v.
+TEST(LtTest, ImplementsLessThan) {
+  Matcher<const std::string&> m1 = Lt("Hello");
+  EXPECT_TRUE(m1.Matches("Abc"));
+  EXPECT_FALSE(m1.Matches("Hello"));
+  EXPECT_FALSE(m1.Matches("Hello, world!"));
+}
+
+// Tests that Lt(v) describes itself properly.
+TEST(LtTest, CanDescribeSelf) {
+  Matcher<int> m = Lt(5);
+  EXPECT_EQ("is < 5", Describe(m));
+}
+
+// Tests that Ne(v) matches anything != v.
+TEST(NeTest, ImplementsNotEqual) {
+  Matcher<int> m1 = Ne(0);
+  EXPECT_TRUE(m1.Matches(1));
+  EXPECT_TRUE(m1.Matches(-1));
+  EXPECT_FALSE(m1.Matches(0));
+}
+
+// Tests that Ne(v) describes itself properly.
+TEST(NeTest, CanDescribeSelf) {
+  Matcher<int> m = Ne(5);
+  EXPECT_EQ("isn't equal to 5", Describe(m));
+}
+
+class MoveOnly {
+ public:
+  explicit MoveOnly(int i) : i_(i) {}
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly(MoveOnly&&) = default;
+  MoveOnly& operator=(const MoveOnly&) = delete;
+  MoveOnly& operator=(MoveOnly&&) = default;
+
+  bool operator==(const MoveOnly& other) const { return i_ == other.i_; }
+  bool operator!=(const MoveOnly& other) const { return i_ != other.i_; }
+  bool operator<(const MoveOnly& other) const { return i_ < other.i_; }
+  bool operator<=(const MoveOnly& other) const { return i_ <= other.i_; }
+  bool operator>(const MoveOnly& other) const { return i_ > other.i_; }
+  bool operator>=(const MoveOnly& other) const { return i_ >= other.i_; }
+
+ private:
+  int i_;
+};
+
+struct MoveHelper {
+  MOCK_METHOD1(Call, void(MoveOnly));
+};
+
+// Disable this test in VS 2015 (version 14), where it fails when SEH is enabled
+#if defined(_MSC_VER) && (_MSC_VER < 1910)
+TEST(ComparisonBaseTest, DISABLED_WorksWithMoveOnly) {
+#else
+TEST(ComparisonBaseTest, WorksWithMoveOnly) {
+#endif
+  MoveOnly m{0};
+  MoveHelper helper;
+
+  EXPECT_CALL(helper, Call(Eq(ByRef(m))));
+  helper.Call(MoveOnly(0));
+  EXPECT_CALL(helper, Call(Ne(ByRef(m))));
+  helper.Call(MoveOnly(1));
+  EXPECT_CALL(helper, Call(Le(ByRef(m))));
+  helper.Call(MoveOnly(0));
+  EXPECT_CALL(helper, Call(Lt(ByRef(m))));
+  helper.Call(MoveOnly(-1));
+  EXPECT_CALL(helper, Call(Ge(ByRef(m))));
+  helper.Call(MoveOnly(0));
+  EXPECT_CALL(helper, Call(Gt(ByRef(m))));
+  helper.Call(MoveOnly(1));
+}
+
+TEST(IsEmptyTest, MatchesContainer) {
+  const Matcher<std::vector<int>> m = IsEmpty();
+  std::vector<int> a = {};
+  std::vector<int> b = {1};
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+TEST(IsEmptyTest, MatchesStdString) {
+  const Matcher<std::string> m = IsEmpty();
+  std::string a = "z";
+  std::string b = "";
+  EXPECT_FALSE(m.Matches(a));
+  EXPECT_TRUE(m.Matches(b));
+}
+
+TEST(IsEmptyTest, MatchesCString) {
+  const Matcher<const char*> m = IsEmpty();
+  const char a[] = "";
+  const char b[] = "x";
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+// Tests that IsNull() matches any NULL pointer of any type.
+TEST(IsNullTest, MatchesNullPointer) {
+  Matcher<int*> m1 = IsNull();
+  int* p1 = nullptr;
+  int n = 0;
+  EXPECT_TRUE(m1.Matches(p1));
+  EXPECT_FALSE(m1.Matches(&n));
+
+  Matcher<const char*> m2 = IsNull();
+  const char* p2 = nullptr;
+  EXPECT_TRUE(m2.Matches(p2));
+  EXPECT_FALSE(m2.Matches("hi"));
+
+  Matcher<void*> m3 = IsNull();
+  void* p3 = nullptr;
+  EXPECT_TRUE(m3.Matches(p3));
+  EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
+}
+
+TEST(IsNullTest, StdFunction) {
+  const Matcher<std::function<void()>> m = IsNull();
+
+  EXPECT_TRUE(m.Matches(std::function<void()>()));
+  EXPECT_FALSE(m.Matches([] {}));
+}
+
+// Tests that IsNull() describes itself properly.
+TEST(IsNullTest, CanDescribeSelf) {
+  Matcher<int*> m = IsNull();
+  EXPECT_EQ("is NULL", Describe(m));
+  EXPECT_EQ("isn't NULL", DescribeNegation(m));
+}
+
+// Tests that NotNull() matches any non-NULL pointer of any type.
+TEST(NotNullTest, MatchesNonNullPointer) {
+  Matcher<int*> m1 = NotNull();
+  int* p1 = nullptr;
+  int n = 0;
+  EXPECT_FALSE(m1.Matches(p1));
+  EXPECT_TRUE(m1.Matches(&n));
+
+  Matcher<const char*> m2 = NotNull();
+  const char* p2 = nullptr;
+  EXPECT_FALSE(m2.Matches(p2));
+  EXPECT_TRUE(m2.Matches("hi"));
+}
+
+TEST(NotNullTest, LinkedPtr) {
+  const Matcher<std::shared_ptr<int>> m = NotNull();
+  const std::shared_ptr<int> null_p;
+  const std::shared_ptr<int> non_null_p(new int);
+
+  EXPECT_FALSE(m.Matches(null_p));
+  EXPECT_TRUE(m.Matches(non_null_p));
+}
+
+TEST(NotNullTest, ReferenceToConstLinkedPtr) {
+  const Matcher<const std::shared_ptr<double>&> m = NotNull();
+  const std::shared_ptr<double> null_p;
+  const std::shared_ptr<double> non_null_p(new double);
+
+  EXPECT_FALSE(m.Matches(null_p));
+  EXPECT_TRUE(m.Matches(non_null_p));
+}
+
+TEST(NotNullTest, StdFunction) {
+  const Matcher<std::function<void()>> m = NotNull();
+
+  EXPECT_TRUE(m.Matches([] {}));
+  EXPECT_FALSE(m.Matches(std::function<void()>()));
+}
+
+// Tests that NotNull() describes itself properly.
+TEST(NotNullTest, CanDescribeSelf) {
+  Matcher<int*> m = NotNull();
+  EXPECT_EQ("isn't NULL", Describe(m));
+}
+
+// Tests that Ref(variable) matches an argument that references
+// 'variable'.
+TEST(RefTest, MatchesSameVariable) {
+  int a = 0;
+  int b = 0;
+  Matcher<int&> m = Ref(a);
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+// Tests that Ref(variable) describes itself properly.
+TEST(RefTest, CanDescribeSelf) {
+  int n = 5;
+  Matcher<int&> m = Ref(n);
+  stringstream ss;
+  ss << "references the variable @" << &n << " 5";
+  EXPECT_EQ(ss.str(), Describe(m));
+}
+
+// Test that Ref(non_const_varialbe) can be used as a matcher for a
+// const reference.
+TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
+  int a = 0;
+  int b = 0;
+  Matcher<const int&> m = Ref(a);
+  EXPECT_TRUE(m.Matches(a));
+  EXPECT_FALSE(m.Matches(b));
+}
+
+// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
+// used wherever Ref(base) can be used (Ref(derived) is a sub-type
+// of Ref(base), but not vice versa.
+
+TEST(RefTest, IsCovariant) {
+  Base base, base2;
+  Derived derived;
+  Matcher<const Base&> m1 = Ref(base);
+  EXPECT_TRUE(m1.Matches(base));
+  EXPECT_FALSE(m1.Matches(base2));
+  EXPECT_FALSE(m1.Matches(derived));
+
+  m1 = Ref(derived);
+  EXPECT_TRUE(m1.Matches(derived));
+  EXPECT_FALSE(m1.Matches(base));
+  EXPECT_FALSE(m1.Matches(base2));
+}
+
+TEST(RefTest, ExplainsResult) {
+  int n = 0;
+  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
+              StartsWith("which is located @"));
+
+  int m = 0;
+  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
+              StartsWith("which is located @"));
+}
+
+// Tests string comparison matchers.
+
+template <typename T = std::string>
+std::string FromStringLike(internal::StringLike<T> str) {
+  return std::string(str);
+}
+
+TEST(StringLike, TestConversions) {
+  EXPECT_EQ("foo", FromStringLike("foo"));
+  EXPECT_EQ("foo", FromStringLike(std::string("foo")));
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  EXPECT_EQ("foo", FromStringLike(internal::StringView("foo")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Non deducible types.
+  EXPECT_EQ("", FromStringLike({}));
+  EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'}));
+  const char buf[] = "foo";
+  EXPECT_EQ("foo", FromStringLike({buf, buf + 3}));
+}
+
+TEST(StrEqTest, MatchesEqualString) {
+  Matcher<const char*> m = StrEq(std::string("Hello"));
+  EXPECT_TRUE(m.Matches("Hello"));
+  EXPECT_FALSE(m.Matches("hello"));
+  EXPECT_FALSE(m.Matches(nullptr));
+
+  Matcher<const std::string&> m2 = StrEq("Hello");
+  EXPECT_TRUE(m2.Matches("Hello"));
+  EXPECT_FALSE(m2.Matches("Hi"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView&> m3 =
+      StrEq(internal::StringView("Hello"));
+  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
+  EXPECT_FALSE(m3.Matches(internal::StringView()));
+
+  Matcher<const internal::StringView&> m_empty = StrEq("");
+  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
+  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
+  EXPECT_FALSE(m_empty.Matches(internal::StringView("hello")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(StrEqTest, CanDescribeSelf) {
+  Matcher<std::string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
+  EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
+            Describe(m));
+
+  std::string str("01204500800");
+  str[3] = '\0';
+  Matcher<std::string> m2 = StrEq(str);
+  EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
+  str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
+  Matcher<std::string> m3 = StrEq(str);
+  EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
+}
+
+TEST(StrNeTest, MatchesUnequalString) {
+  Matcher<const char*> m = StrNe("Hello");
+  EXPECT_TRUE(m.Matches(""));
+  EXPECT_TRUE(m.Matches(nullptr));
+  EXPECT_FALSE(m.Matches("Hello"));
+
+  Matcher<std::string> m2 = StrNe(std::string("Hello"));
+  EXPECT_TRUE(m2.Matches("hello"));
+  EXPECT_FALSE(m2.Matches("Hello"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView> m3 = StrNe(internal::StringView("Hello"));
+  EXPECT_TRUE(m3.Matches(internal::StringView("")));
+  EXPECT_TRUE(m3.Matches(internal::StringView()));
+  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(StrNeTest, CanDescribeSelf) {
+  Matcher<const char*> m = StrNe("Hi");
+  EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
+}
+
+TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
+  Matcher<const char*> m = StrCaseEq(std::string("Hello"));
+  EXPECT_TRUE(m.Matches("Hello"));
+  EXPECT_TRUE(m.Matches("hello"));
+  EXPECT_FALSE(m.Matches("Hi"));
+  EXPECT_FALSE(m.Matches(nullptr));
+
+  Matcher<const std::string&> m2 = StrCaseEq("Hello");
+  EXPECT_TRUE(m2.Matches("hello"));
+  EXPECT_FALSE(m2.Matches("Hi"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView&> m3 =
+      StrCaseEq(internal::StringView("Hello"));
+  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
+  EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
+  EXPECT_FALSE(m3.Matches(internal::StringView()));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
+  std::string str1("oabocdooeoo");
+  std::string str2("OABOCDOOEOO");
+  Matcher<const std::string&> m0 = StrCaseEq(str1);
+  EXPECT_FALSE(m0.Matches(str2 + std::string(1, '\0')));
+
+  str1[3] = str2[3] = '\0';
+  Matcher<const std::string&> m1 = StrCaseEq(str1);
+  EXPECT_TRUE(m1.Matches(str2));
+
+  str1[0] = str1[6] = str1[7] = str1[10] = '\0';
+  str2[0] = str2[6] = str2[7] = str2[10] = '\0';
+  Matcher<const std::string&> m2 = StrCaseEq(str1);
+  str1[9] = str2[9] = '\0';
+  EXPECT_FALSE(m2.Matches(str2));
+
+  Matcher<const std::string&> m3 = StrCaseEq(str1);
+  EXPECT_TRUE(m3.Matches(str2));
+
+  EXPECT_FALSE(m3.Matches(str2 + "x"));
+  str2.append(1, '\0');
+  EXPECT_FALSE(m3.Matches(str2));
+  EXPECT_FALSE(m3.Matches(std::string(str2, 0, 9)));
+}
+
+TEST(StrCaseEqTest, CanDescribeSelf) {
+  Matcher<std::string> m = StrCaseEq("Hi");
+  EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
+}
+
+TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
+  Matcher<const char*> m = StrCaseNe("Hello");
+  EXPECT_TRUE(m.Matches("Hi"));
+  EXPECT_TRUE(m.Matches(nullptr));
+  EXPECT_FALSE(m.Matches("Hello"));
+  EXPECT_FALSE(m.Matches("hello"));
+
+  Matcher<std::string> m2 = StrCaseNe(std::string("Hello"));
+  EXPECT_TRUE(m2.Matches(""));
+  EXPECT_FALSE(m2.Matches("Hello"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView> m3 =
+      StrCaseNe(internal::StringView("Hello"));
+  EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
+  EXPECT_TRUE(m3.Matches(internal::StringView()));
+  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(StrCaseNeTest, CanDescribeSelf) {
+  Matcher<const char*> m = StrCaseNe("Hi");
+  EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
+}
+
+// Tests that HasSubstr() works for matching string-typed values.
+TEST(HasSubstrTest, WorksForStringClasses) {
+  const Matcher<std::string> m1 = HasSubstr("foo");
+  EXPECT_TRUE(m1.Matches(std::string("I love food.")));
+  EXPECT_FALSE(m1.Matches(std::string("tofo")));
+
+  const Matcher<const std::string&> m2 = HasSubstr("foo");
+  EXPECT_TRUE(m2.Matches(std::string("I love food.")));
+  EXPECT_FALSE(m2.Matches(std::string("tofo")));
+
+  const Matcher<std::string> m_empty = HasSubstr("");
+  EXPECT_TRUE(m_empty.Matches(std::string()));
+  EXPECT_TRUE(m_empty.Matches(std::string("not empty")));
+}
+
+// Tests that HasSubstr() works for matching C-string-typed values.
+TEST(HasSubstrTest, WorksForCStrings) {
+  const Matcher<char*> m1 = HasSubstr("foo");
+  EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
+  EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const char*> m2 = HasSubstr("foo");
+  EXPECT_TRUE(m2.Matches("I love food."));
+  EXPECT_FALSE(m2.Matches("tofo"));
+  EXPECT_FALSE(m2.Matches(nullptr));
+
+  const Matcher<const char*> m_empty = HasSubstr("");
+  EXPECT_TRUE(m_empty.Matches("not empty"));
+  EXPECT_TRUE(m_empty.Matches(""));
+  EXPECT_FALSE(m_empty.Matches(nullptr));
+}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Tests that HasSubstr() works for matching StringView-typed values.
+TEST(HasSubstrTest, WorksForStringViewClasses) {
+  const Matcher<internal::StringView> m1 =
+      HasSubstr(internal::StringView("foo"));
+  EXPECT_TRUE(m1.Matches(internal::StringView("I love food.")));
+  EXPECT_FALSE(m1.Matches(internal::StringView("tofo")));
+  EXPECT_FALSE(m1.Matches(internal::StringView()));
+
+  const Matcher<const internal::StringView&> m2 = HasSubstr("foo");
+  EXPECT_TRUE(m2.Matches(internal::StringView("I love food.")));
+  EXPECT_FALSE(m2.Matches(internal::StringView("tofo")));
+  EXPECT_FALSE(m2.Matches(internal::StringView()));
+
+  const Matcher<const internal::StringView&> m3 = HasSubstr("");
+  EXPECT_TRUE(m3.Matches(internal::StringView("foo")));
+  EXPECT_TRUE(m3.Matches(internal::StringView("")));
+  EXPECT_TRUE(m3.Matches(internal::StringView()));
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+// Tests that HasSubstr(s) describes itself properly.
+TEST(HasSubstrTest, CanDescribeSelf) {
+  Matcher<std::string> m = HasSubstr("foo\n\"");
+  EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(KeyTest);
+
+TEST(KeyTest, CanDescribeSelf) {
+  Matcher<const pair<std::string, int>&> m = Key("foo");
+  EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
+  EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
+}
+
+TEST_P(KeyTestP, ExplainsResult) {
+  Matcher<pair<int, bool>> m = Key(GreaterThan(10));
+  EXPECT_EQ("whose first field is a value which is 5 less than 10",
+            Explain(m, make_pair(5, true)));
+  EXPECT_EQ("whose first field is a value which is 5 more than 10",
+            Explain(m, make_pair(15, true)));
+}
+
+TEST(KeyTest, MatchesCorrectly) {
+  pair<int, std::string> p(25, "foo");
+  EXPECT_THAT(p, Key(25));
+  EXPECT_THAT(p, Not(Key(42)));
+  EXPECT_THAT(p, Key(Ge(20)));
+  EXPECT_THAT(p, Not(Key(Lt(25))));
+}
+
+TEST(KeyTest, WorksWithMoveOnly) {
+  pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
+  EXPECT_THAT(p, Key(Eq(nullptr)));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(PairTest);
+
+template <size_t I>
+struct Tag {};
+
+struct PairWithGet {
+  int member_1;
+  std::string member_2;
+  using first_type = int;
+  using second_type = std::string;
+
+  const int& GetImpl(Tag<0>) const { return member_1; }
+  const std::string& GetImpl(Tag<1>) const { return member_2; }
+};
+template <size_t I>
+auto get(const PairWithGet& value) -> decltype(value.GetImpl(Tag<I>())) {
+  return value.GetImpl(Tag<I>());
+}
+TEST(PairTest, MatchesPairWithGetCorrectly) {
+  PairWithGet p{25, "foo"};
+  EXPECT_THAT(p, Key(25));
+  EXPECT_THAT(p, Not(Key(42)));
+  EXPECT_THAT(p, Key(Ge(20)));
+  EXPECT_THAT(p, Not(Key(Lt(25))));
+
+  std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
+  EXPECT_THAT(v, Contains(Key(29)));
+}
+
+TEST(KeyTest, SafelyCastsInnerMatcher) {
+  Matcher<int> is_positive = Gt(0);
+  Matcher<int> is_negative = Lt(0);
+  pair<char, bool> p('a', true);
+  EXPECT_THAT(p, Key(is_positive));
+  EXPECT_THAT(p, Not(Key(is_negative)));
+}
+
+TEST(KeyTest, InsideContainsUsingMap) {
+  map<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+  EXPECT_THAT(container, Contains(Key(1)));
+  EXPECT_THAT(container, Not(Contains(Key(3))));
+}
+
+TEST(KeyTest, InsideContainsUsingMultimap) {
+  multimap<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+
+  EXPECT_THAT(container, Not(Contains(Key(25))));
+  container.insert(make_pair(25, 'd'));
+  EXPECT_THAT(container, Contains(Key(25)));
+  container.insert(make_pair(25, 'e'));
+  EXPECT_THAT(container, Contains(Key(25)));
+
+  EXPECT_THAT(container, Contains(Key(1)));
+  EXPECT_THAT(container, Not(Contains(Key(3))));
+}
+
+TEST(PairTest, Typing) {
+  // Test verifies the following type conversions can be compiled.
+  Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
+  Matcher<const pair<const char*, int>> m2 = Pair("foo", 42);
+  Matcher<pair<const char*, int>> m3 = Pair("foo", 42);
+
+  Matcher<pair<int, const std::string>> m4 = Pair(25, "42");
+  Matcher<pair<const std::string, int>> m5 = Pair("25", 42);
+}
+
+TEST(PairTest, CanDescribeSelf) {
+  Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
+  EXPECT_EQ(
+      "has a first field that is equal to \"foo\""
+      ", and has a second field that is equal to 42",
+      Describe(m1));
+  EXPECT_EQ(
+      "has a first field that isn't equal to \"foo\""
+      ", or has a second field that isn't equal to 42",
+      DescribeNegation(m1));
+  // Double and triple negation (1 or 2 times not and description of negation).
+  Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
+  EXPECT_EQ(
+      "has a first field that isn't equal to 13"
+      ", and has a second field that is equal to 42",
+      DescribeNegation(m2));
+}
+
+TEST_P(PairTestP, CanExplainMatchResultTo) {
+  // If neither field matches, Pair() should explain about the first
+  // field.
+  const Matcher<pair<int, int>> m = Pair(GreaterThan(0), GreaterThan(0));
+  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
+            Explain(m, make_pair(-1, -2)));
+
+  // If the first field matches but the second doesn't, Pair() should
+  // explain about the second field.
+  EXPECT_EQ("whose second field does not match, which is 2 less than 0",
+            Explain(m, make_pair(1, -2)));
+
+  // If the first field doesn't match but the second does, Pair()
+  // should explain about the first field.
+  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
+            Explain(m, make_pair(-1, 2)));
+
+  // If both fields match, Pair() should explain about them both.
+  EXPECT_EQ(
+      "whose both fields match, where the first field is a value "
+      "which is 1 more than 0, and the second field is a value "
+      "which is 2 more than 0",
+      Explain(m, make_pair(1, 2)));
+
+  // If only the first match has an explanation, only this explanation should
+  // be printed.
+  const Matcher<pair<int, int>> explain_first = Pair(GreaterThan(0), 0);
+  EXPECT_EQ(
+      "whose both fields match, where the first field is a value "
+      "which is 1 more than 0",
+      Explain(explain_first, make_pair(1, 0)));
+
+  // If only the second match has an explanation, only this explanation should
+  // be printed.
+  const Matcher<pair<int, int>> explain_second = Pair(0, GreaterThan(0));
+  EXPECT_EQ(
+      "whose both fields match, where the second field is a value "
+      "which is 1 more than 0",
+      Explain(explain_second, make_pair(0, 1)));
+}
+
+TEST(PairTest, MatchesCorrectly) {
+  pair<int, std::string> p(25, "foo");
+
+  // Both fields match.
+  EXPECT_THAT(p, Pair(25, "foo"));
+  EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
+
+  // 'first' doesnt' match, but 'second' matches.
+  EXPECT_THAT(p, Not(Pair(42, "foo")));
+  EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
+
+  // 'first' matches, but 'second' doesn't match.
+  EXPECT_THAT(p, Not(Pair(25, "bar")));
+  EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
+
+  // Neither field matches.
+  EXPECT_THAT(p, Not(Pair(13, "bar")));
+  EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
+}
+
+TEST(PairTest, WorksWithMoveOnly) {
+  pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
+  p.second.reset(new int(7));
+  EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr)));
+}
+
+TEST(PairTest, SafelyCastsInnerMatchers) {
+  Matcher<int> is_positive = Gt(0);
+  Matcher<int> is_negative = Lt(0);
+  pair<char, bool> p('a', true);
+  EXPECT_THAT(p, Pair(is_positive, _));
+  EXPECT_THAT(p, Not(Pair(is_negative, _)));
+  EXPECT_THAT(p, Pair(_, is_positive));
+  EXPECT_THAT(p, Not(Pair(_, is_negative)));
+}
+
+TEST(PairTest, InsideContainsUsingMap) {
+  map<int, char> container;
+  container.insert(make_pair(1, 'a'));
+  container.insert(make_pair(2, 'b'));
+  container.insert(make_pair(4, 'c'));
+  EXPECT_THAT(container, Contains(Pair(1, 'a')));
+  EXPECT_THAT(container, Contains(Pair(1, _)));
+  EXPECT_THAT(container, Contains(Pair(_, 'a')));
+  EXPECT_THAT(container, Not(Contains(Pair(3, _))));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(FieldsAreTest);
+
+TEST(FieldsAreTest, MatchesCorrectly) {
+  std::tuple<int, std::string, double> p(25, "foo", .5);
+
+  // All fields match.
+  EXPECT_THAT(p, FieldsAre(25, "foo", .5));
+  EXPECT_THAT(p, FieldsAre(Ge(20), HasSubstr("o"), DoubleEq(.5)));
+
+  // Some don't match.
+  EXPECT_THAT(p, Not(FieldsAre(26, "foo", .5)));
+  EXPECT_THAT(p, Not(FieldsAre(25, "fo", .5)));
+  EXPECT_THAT(p, Not(FieldsAre(25, "foo", .6)));
+}
+
+TEST(FieldsAreTest, CanDescribeSelf) {
+  Matcher<const pair<std::string, int>&> m1 = FieldsAre("foo", 42);
+  EXPECT_EQ(
+      "has field #0 that is equal to \"foo\""
+      ", and has field #1 that is equal to 42",
+      Describe(m1));
+  EXPECT_EQ(
+      "has field #0 that isn't equal to \"foo\""
+      ", or has field #1 that isn't equal to 42",
+      DescribeNegation(m1));
+}
+
+TEST_P(FieldsAreTestP, CanExplainMatchResultTo) {
+  // The first one that fails is the one that gives the error.
+  Matcher<std::tuple<int, int, int>> m =
+      FieldsAre(GreaterThan(0), GreaterThan(0), GreaterThan(0));
+
+  EXPECT_EQ("whose field #0 does not match, which is 1 less than 0",
+            Explain(m, std::make_tuple(-1, -2, -3)));
+  EXPECT_EQ("whose field #1 does not match, which is 2 less than 0",
+            Explain(m, std::make_tuple(1, -2, -3)));
+  EXPECT_EQ("whose field #2 does not match, which is 3 less than 0",
+            Explain(m, std::make_tuple(1, 2, -3)));
+
+  // If they all match, we get a long explanation of success.
+  EXPECT_EQ(
+      "whose all elements match, "
+      "where field #0 is a value which is 1 more than 0"
+      ", and field #1 is a value which is 2 more than 0"
+      ", and field #2 is a value which is 3 more than 0",
+      Explain(m, std::make_tuple(1, 2, 3)));
+
+  // Only print those that have an explanation.
+  m = FieldsAre(GreaterThan(0), 0, GreaterThan(0));
+  EXPECT_EQ(
+      "whose all elements match, "
+      "where field #0 is a value which is 1 more than 0"
+      ", and field #2 is a value which is 3 more than 0",
+      Explain(m, std::make_tuple(1, 0, 3)));
+
+  // If only one has an explanation, then print that one.
+  m = FieldsAre(0, GreaterThan(0), 0);
+  EXPECT_EQ(
+      "whose all elements match, "
+      "where field #1 is a value which is 1 more than 0",
+      Explain(m, std::make_tuple(0, 1, 0)));
+}
+
+#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
+TEST(FieldsAreTest, StructuredBindings) {
+  // testing::FieldsAre can also match aggregates and such with C++17 and up.
+  struct MyType {
+    int i;
+    std::string str;
+  };
+  EXPECT_THAT((MyType{17, "foo"}), FieldsAre(Eq(17), HasSubstr("oo")));
+
+  // Test all the supported arities.
+  struct MyVarType1 {
+    int a;
+  };
+  EXPECT_THAT(MyVarType1{}, FieldsAre(0));
+  struct MyVarType2 {
+    int a, b;
+  };
+  EXPECT_THAT(MyVarType2{}, FieldsAre(0, 0));
+  struct MyVarType3 {
+    int a, b, c;
+  };
+  EXPECT_THAT(MyVarType3{}, FieldsAre(0, 0, 0));
+  struct MyVarType4 {
+    int a, b, c, d;
+  };
+  EXPECT_THAT(MyVarType4{}, FieldsAre(0, 0, 0, 0));
+  struct MyVarType5 {
+    int a, b, c, d, e;
+  };
+  EXPECT_THAT(MyVarType5{}, FieldsAre(0, 0, 0, 0, 0));
+  struct MyVarType6 {
+    int a, b, c, d, e, f;
+  };
+  EXPECT_THAT(MyVarType6{}, FieldsAre(0, 0, 0, 0, 0, 0));
+  struct MyVarType7 {
+    int a, b, c, d, e, f, g;
+  };
+  EXPECT_THAT(MyVarType7{}, FieldsAre(0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType8 {
+    int a, b, c, d, e, f, g, h;
+  };
+  EXPECT_THAT(MyVarType8{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType9 {
+    int a, b, c, d, e, f, g, h, i;
+  };
+  EXPECT_THAT(MyVarType9{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType10 {
+    int a, b, c, d, e, f, g, h, i, j;
+  };
+  EXPECT_THAT(MyVarType10{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType11 {
+    int a, b, c, d, e, f, g, h, i, j, k;
+  };
+  EXPECT_THAT(MyVarType11{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType12 {
+    int a, b, c, d, e, f, g, h, i, j, k, l;
+  };
+  EXPECT_THAT(MyVarType12{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType13 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m;
+  };
+  EXPECT_THAT(MyVarType13{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType14 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n;
+  };
+  EXPECT_THAT(MyVarType14{},
+              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType15 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o;
+  };
+  EXPECT_THAT(MyVarType15{},
+              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType16 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
+  };
+  EXPECT_THAT(MyVarType16{},
+              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType17 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q;
+  };
+  EXPECT_THAT(MyVarType17{},
+              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType18 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r;
+  };
+  EXPECT_THAT(MyVarType18{},
+              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  struct MyVarType19 {
+    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s;
+  };
+  EXPECT_THAT(MyVarType19{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                       0, 0, 0, 0, 0));
+}
+#endif
+
+TEST(PairTest, UseGetInsteadOfMembers) {
+  PairWithGet pair{7, "ABC"};
+  EXPECT_THAT(pair, Pair(7, "ABC"));
+  EXPECT_THAT(pair, Pair(Ge(7), HasSubstr("AB")));
+  EXPECT_THAT(pair, Not(Pair(Lt(7), "ABC")));
+
+  std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
+  EXPECT_THAT(v,
+              ElementsAre(Pair(11, std::string("Foo")), Pair(Ge(10), Not(""))));
+}
+
+// Tests StartsWith(s).
+
+TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
+  const Matcher<const char*> m1 = StartsWith(std::string(""));
+  EXPECT_TRUE(m1.Matches("Hi"));
+  EXPECT_TRUE(m1.Matches(""));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const std::string&> m2 = StartsWith("Hi");
+  EXPECT_TRUE(m2.Matches("Hi"));
+  EXPECT_TRUE(m2.Matches("Hi Hi!"));
+  EXPECT_TRUE(m2.Matches("High"));
+  EXPECT_FALSE(m2.Matches("H"));
+  EXPECT_FALSE(m2.Matches(" Hi"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  const Matcher<internal::StringView> m_empty =
+      StartsWith(internal::StringView(""));
+  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
+  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
+  EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(StartsWithTest, CanDescribeSelf) {
+  Matcher<const std::string> m = StartsWith("Hi");
+  EXPECT_EQ("starts with \"Hi\"", Describe(m));
+}
+
+// Tests EndsWith(s).
+
+TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
+  const Matcher<const char*> m1 = EndsWith("");
+  EXPECT_TRUE(m1.Matches("Hi"));
+  EXPECT_TRUE(m1.Matches(""));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const std::string&> m2 = EndsWith(std::string("Hi"));
+  EXPECT_TRUE(m2.Matches("Hi"));
+  EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
+  EXPECT_TRUE(m2.Matches("Super Hi"));
+  EXPECT_FALSE(m2.Matches("i"));
+  EXPECT_FALSE(m2.Matches("Hi "));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  const Matcher<const internal::StringView&> m4 =
+      EndsWith(internal::StringView(""));
+  EXPECT_TRUE(m4.Matches("Hi"));
+  EXPECT_TRUE(m4.Matches(""));
+  EXPECT_TRUE(m4.Matches(internal::StringView()));
+  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(EndsWithTest, CanDescribeSelf) {
+  Matcher<const std::string> m = EndsWith("Hi");
+  EXPECT_EQ("ends with \"Hi\"", Describe(m));
+}
+
+// Tests WhenBase64Unescaped.
+
+TEST(WhenBase64UnescapedTest, MatchesUnescapedBase64Strings) {
+  const Matcher<const char*> m1 = WhenBase64Unescaped(EndsWith("!"));
+  EXPECT_FALSE(m1.Matches("invalid base64"));
+  EXPECT_FALSE(m1.Matches("aGVsbG8gd29ybGQ="));  // hello world
+  EXPECT_TRUE(m1.Matches("aGVsbG8gd29ybGQh"));   // hello world!
+
+  const Matcher<const std::string&> m2 = WhenBase64Unescaped(EndsWith("!"));
+  EXPECT_FALSE(m2.Matches("invalid base64"));
+  EXPECT_FALSE(m2.Matches("aGVsbG8gd29ybGQ="));  // hello world
+  EXPECT_TRUE(m2.Matches("aGVsbG8gd29ybGQh"));   // hello world!
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  const Matcher<const internal::StringView&> m3 =
+      WhenBase64Unescaped(EndsWith("!"));
+  EXPECT_FALSE(m3.Matches("invalid base64"));
+  EXPECT_FALSE(m3.Matches("aGVsbG8gd29ybGQ="));  // hello world
+  EXPECT_TRUE(m3.Matches("aGVsbG8gd29ybGQh"));   // hello world!
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(WhenBase64UnescapedTest, CanDescribeSelf) {
+  const Matcher<const char*> m = WhenBase64Unescaped(EndsWith("!"));
+  EXPECT_EQ("matches after Base64Unescape ends with \"!\"", Describe(m));
+}
+
+// Tests MatchesRegex().
+
+TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
+  const Matcher<const char*> m1 = MatchesRegex("a.*z");
+  EXPECT_TRUE(m1.Matches("az"));
+  EXPECT_TRUE(m1.Matches("abcz"));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z"));
+  EXPECT_TRUE(m2.Matches("azbz"));
+  EXPECT_FALSE(m2.Matches("az1"));
+  EXPECT_FALSE(m2.Matches("1az"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  const Matcher<const internal::StringView&> m3 = MatchesRegex("a.*z");
+  EXPECT_TRUE(m3.Matches(internal::StringView("az")));
+  EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
+  EXPECT_FALSE(m3.Matches(internal::StringView("1az")));
+  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  const Matcher<const internal::StringView&> m4 =
+      MatchesRegex(internal::StringView(""));
+  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+  EXPECT_TRUE(m4.Matches(internal::StringView()));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(MatchesRegexTest, CanDescribeSelf) {
+  Matcher<const std::string> m1 = MatchesRegex(std::string("Hi.*"));
+  EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
+
+  Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
+  EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView> m3 = MatchesRegex(new RE("0.*"));
+  EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+// Tests ContainsRegex().
+
+TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
+  const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z"));
+  EXPECT_TRUE(m1.Matches("az"));
+  EXPECT_TRUE(m1.Matches("0abcz1"));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z"));
+  EXPECT_TRUE(m2.Matches("azbz"));
+  EXPECT_TRUE(m2.Matches("az1"));
+  EXPECT_FALSE(m2.Matches("1a"));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  const Matcher<const internal::StringView&> m3 = ContainsRegex(new RE("a.*z"));
+  EXPECT_TRUE(m3.Matches(internal::StringView("azbz")));
+  EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
+  EXPECT_FALSE(m3.Matches(internal::StringView("1a")));
+  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  const Matcher<const internal::StringView&> m4 =
+      ContainsRegex(internal::StringView(""));
+  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+  EXPECT_TRUE(m4.Matches(internal::StringView()));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+TEST(ContainsRegexTest, CanDescribeSelf) {
+  Matcher<const std::string> m1 = ContainsRegex("Hi.*");
+  EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
+
+  Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
+  EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  Matcher<const internal::StringView> m3 = ContainsRegex(new RE("0.*"));
+  EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+}
+
+// Tests for wide strings.
+#if GTEST_HAS_STD_WSTRING
+TEST(StdWideStrEqTest, MatchesEqual) {
+  Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(nullptr));
+
+  Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"Hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+
+  Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
+  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
+
+  ::std::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::std::wstring&> m4 = StrEq(str);
+  EXPECT_TRUE(m4.Matches(str));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::std::wstring&> m5 = StrEq(str);
+  EXPECT_TRUE(m5.Matches(str));
+}
+
+TEST(StdWideStrEqTest, CanDescribeSelf) {
+  Matcher<::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
+  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
+            Describe(m));
+
+  Matcher<::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
+  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", Describe(m2));
+
+  ::std::wstring str(L"01204500800");
+  str[3] = L'\0';
+  Matcher<const ::std::wstring&> m4 = StrEq(str);
+  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
+  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
+  Matcher<const ::std::wstring&> m5 = StrEq(str);
+  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
+}
+
+TEST(StdWideStrNeTest, MatchesUnequalString) {
+  Matcher<const wchar_t*> m = StrNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L""));
+  EXPECT_TRUE(m.Matches(nullptr));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+
+  Matcher<::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(StdWideStrNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrNe(L"Hi");
+  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
+}
+
+TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"Hello"));
+  EXPECT_TRUE(m.Matches(L"hello"));
+  EXPECT_FALSE(m.Matches(L"Hi"));
+  EXPECT_FALSE(m.Matches(nullptr));
+
+  Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
+  EXPECT_TRUE(m2.Matches(L"hello"));
+  EXPECT_FALSE(m2.Matches(L"Hi"));
+}
+
+TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
+  ::std::wstring str1(L"oabocdooeoo");
+  ::std::wstring str2(L"OABOCDOOEOO");
+  Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
+  EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
+
+  str1[3] = str2[3] = L'\0';
+  Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
+  EXPECT_TRUE(m1.Matches(str2));
+
+  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
+  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
+  Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
+  str1[9] = str2[9] = L'\0';
+  EXPECT_FALSE(m2.Matches(str2));
+
+  Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
+  EXPECT_TRUE(m3.Matches(str2));
+
+  EXPECT_FALSE(m3.Matches(str2 + L"x"));
+  str2.append(1, L'\0');
+  EXPECT_FALSE(m3.Matches(str2));
+  EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
+}
+
+TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
+  Matcher<::std::wstring> m = StrCaseEq(L"Hi");
+  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
+  EXPECT_TRUE(m.Matches(L"Hi"));
+  EXPECT_TRUE(m.Matches(nullptr));
+  EXPECT_FALSE(m.Matches(L"Hello"));
+  EXPECT_FALSE(m.Matches(L"hello"));
+
+  Matcher<::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
+  EXPECT_TRUE(m2.Matches(L""));
+  EXPECT_FALSE(m2.Matches(L"Hello"));
+}
+
+TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
+  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
+  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
+}
+
+// Tests that HasSubstr() works for matching wstring-typed values.
+TEST(StdWideHasSubstrTest, WorksForStringClasses) {
+  const Matcher<::std::wstring> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
+
+  const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
+  EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
+}
+
+// Tests that HasSubstr() works for matching C-wide-string-typed values.
+TEST(StdWideHasSubstrTest, WorksForCStrings) {
+  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
+  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
+  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
+  EXPECT_TRUE(m2.Matches(L"I love food."));
+  EXPECT_FALSE(m2.Matches(L"tofo"));
+  EXPECT_FALSE(m2.Matches(nullptr));
+}
+
+// Tests that HasSubstr(s) describes itself properly.
+TEST(StdWideHasSubstrTest, CanDescribeSelf) {
+  Matcher<::std::wstring> m = HasSubstr(L"foo\n\"");
+  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
+}
+
+// Tests StartsWith(s).
+
+TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
+  const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
+  EXPECT_TRUE(m2.Matches(L"High"));
+  EXPECT_FALSE(m2.Matches(L"H"));
+  EXPECT_FALSE(m2.Matches(L" Hi"));
+}
+
+TEST(StdWideStartsWithTest, CanDescribeSelf) {
+  Matcher<const ::std::wstring> m = StartsWith(L"Hi");
+  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
+}
+
+// Tests EndsWith(s).
+
+TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
+  const Matcher<const wchar_t*> m1 = EndsWith(L"");
+  EXPECT_TRUE(m1.Matches(L"Hi"));
+  EXPECT_TRUE(m1.Matches(L""));
+  EXPECT_FALSE(m1.Matches(nullptr));
+
+  const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Hi"));
+  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
+  EXPECT_TRUE(m2.Matches(L"Super Hi"));
+  EXPECT_FALSE(m2.Matches(L"i"));
+  EXPECT_FALSE(m2.Matches(L"Hi "));
+}
+
+TEST(StdWideEndsWithTest, CanDescribeSelf) {
+  Matcher<const ::std::wstring> m = EndsWith(L"Hi");
+  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
+  EXPECT_EQ("% 2 == 0", listener1.str());
+
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
+  EXPECT_EQ("", listener2.str());
+}
+
+TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> is_even = PolymorphicIsEven();
+  StringMatchResultListener listener1;
+  EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
+  EXPECT_EQ("% 2 == 0", listener1.str());
+
+  const Matcher<const double&> is_zero = Eq(0);
+  StringMatchResultListener listener2;
+  EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
+  EXPECT_EQ("", listener2.str());
+}
+
+MATCHER(ConstructNoArg, "") { return true; }
+MATCHER_P(Construct1Arg, arg1, "") { return true; }
+MATCHER_P2(Construct2Args, arg1, arg2, "") { return true; }
+
+TEST(MatcherConstruct, ExplicitVsImplicit) {
+  {
+    // No arg constructor can be constructed with empty brace.
+    ConstructNoArgMatcher m = {};
+    (void)m;
+    // And with no args
+    ConstructNoArgMatcher m2;
+    (void)m2;
+  }
+  {
+    // The one arg constructor has an explicit constructor.
+    // This is to prevent the implicit conversion.
+    using M = Construct1ArgMatcherP<int>;
+    EXPECT_TRUE((std::is_constructible<M, int>::value));
+    EXPECT_FALSE((std::is_convertible<int, M>::value));
+  }
+  {
+    // Multiple arg matchers can be constructed with an implicit construction.
+    Construct2ArgsMatcherP2<int, double> m = {1, 2.2};
+    (void)m;
+  }
+}
+
+MATCHER_P(Really, inner_matcher, "") {
+  return ExplainMatchResult(inner_matcher, arg, result_listener);
+}
+
+TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
+  EXPECT_THAT(0, Really(Eq(0)));
+}
+
+TEST(DescribeMatcherTest, WorksWithValue) {
+  EXPECT_EQ("is equal to 42", DescribeMatcher<int>(42));
+  EXPECT_EQ("isn't equal to 42", DescribeMatcher<int>(42, true));
+}
+
+TEST(DescribeMatcherTest, WorksWithMonomorphicMatcher) {
+  const Matcher<int> monomorphic = Le(0);
+  EXPECT_EQ("is <= 0", DescribeMatcher<int>(monomorphic));
+  EXPECT_EQ("isn't <= 0", DescribeMatcher<int>(monomorphic, true));
+}
+
+TEST(DescribeMatcherTest, WorksWithPolymorphicMatcher) {
+  EXPECT_EQ("is even", DescribeMatcher<int>(PolymorphicIsEven()));
+  EXPECT_EQ("is odd", DescribeMatcher<int>(PolymorphicIsEven(), true));
+}
+
+MATCHER_P(FieldIIs, inner_matcher, "") {
+  return ExplainMatchResult(inner_matcher, arg.i, result_listener);
+}
+
+#if GTEST_HAS_RTTI
+TEST(WhenDynamicCastToTest, SameType) {
+  Derived derived;
+  derived.i = 4;
+
+  // Right type. A pointer is passed down.
+  Base* as_base_ptr = &derived;
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
+  EXPECT_THAT(as_base_ptr,
+              Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
+}
+
+TEST(WhenDynamicCastToTest, WrongTypes) {
+  Base base;
+  Derived derived;
+  OtherDerived other_derived;
+
+  // Wrong types. NULL is passed.
+  EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+  EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
+  Base* as_base_ptr = &derived;
+  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
+  as_base_ptr = &other_derived;
+  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+TEST(WhenDynamicCastToTest, AlreadyNull) {
+  // Already NULL.
+  Base* as_base_ptr = nullptr;
+  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
+}
+
+struct AmbiguousCastTypes {
+  class VirtualDerived : public virtual Base {};
+  class DerivedSub1 : public VirtualDerived {};
+  class DerivedSub2 : public VirtualDerived {};
+  class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
+};
+
+TEST(WhenDynamicCastToTest, AmbiguousCast) {
+  AmbiguousCastTypes::DerivedSub1 sub1;
+  AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
+  // Multiply derived from Base. dynamic_cast<> returns NULL.
+  Base* as_base_ptr =
+      static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
+  EXPECT_THAT(as_base_ptr,
+              WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
+  as_base_ptr = &sub1;
+  EXPECT_THAT(
+      as_base_ptr,
+      WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
+}
+
+TEST(WhenDynamicCastToTest, Describe) {
+  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+  const std::string prefix =
+      "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
+  EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
+  EXPECT_EQ(prefix + "does not point to a value that is anything",
+            DescribeNegation(matcher));
+}
+
+TEST(WhenDynamicCastToTest, Explain) {
+  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
+  Base* null = nullptr;
+  EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
+  Derived derived;
+  EXPECT_TRUE(matcher.Matches(&derived));
+  EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
+
+  // With references, the matcher itself can fail. Test for that one.
+  Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
+  EXPECT_THAT(Explain(ref_matcher, derived),
+              HasSubstr("which cannot be dynamic_cast"));
+}
+
+TEST(WhenDynamicCastToTest, GoodReference) {
+  Derived derived;
+  derived.i = 4;
+  Base& as_base_ref = derived;
+  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
+  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
+}
+
+TEST(WhenDynamicCastToTest, BadReference) {
+  Derived derived;
+  Base& as_base_ref = derived;
+  EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
+}
+#endif  // GTEST_HAS_RTTI
+
+class DivisibleByImpl {
+ public:
+  explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
+
+  // For testing using ExplainMatchResultTo() with polymorphic matchers.
+  template <typename T>
+  bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
+    *listener << "which is " << (n % divider_) << " modulo " << divider_;
+    return (n % divider_) == 0;
+  }
+
+  void DescribeTo(ostream* os) const { *os << "is divisible by " << divider_; }
+
+  void DescribeNegationTo(ostream* os) const {
+    *os << "is not divisible by " << divider_;
+  }
+
+  void set_divider(int a_divider) { divider_ = a_divider; }
+  int divider() const { return divider_; }
+
+ private:
+  int divider_;
+};
+
+PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
+  return MakePolymorphicMatcher(DivisibleByImpl(n));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_False_False) {
+  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
+  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_False_True) {
+  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
+  EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
+}
+
+// Tests that when AllOf() fails, only the first failing matcher is
+// asked to explain why.
+TEST(ExplainMatchResultTest, AllOf_True_False) {
+  const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
+  EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
+}
+
+// Tests that when AllOf() succeeds, all matchers are asked to explain
+// why.
+TEST(ExplainMatchResultTest, AllOf_True_True) {
+  const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
+  EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
+}
+
+TEST(ExplainMatchResultTest, AllOf_True_True_2) {
+  const Matcher<int> m = AllOf(Ge(2), Le(3));
+  EXPECT_EQ("", Explain(m, 2));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(ExplainmatcherResultTest);
+
+TEST_P(ExplainmatcherResultTestP, MonomorphicMatcher) {
+  const Matcher<int> m = GreaterThan(5);
+  EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
+}
+
+// Tests PolymorphicMatcher::mutable_impl().
+TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
+  PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
+  DivisibleByImpl& impl = m.mutable_impl();
+  EXPECT_EQ(42, impl.divider());
+
+  impl.set_divider(0);
+  EXPECT_EQ(0, m.mutable_impl().divider());
+}
+
+// Tests PolymorphicMatcher::impl().
+TEST(PolymorphicMatcherTest, CanAccessImpl) {
+  const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
+  const DivisibleByImpl& impl = m.impl();
+  EXPECT_EQ(42, impl.divider());
+}
+
+}  // namespace
+}  // namespace gmock_matchers_test
+}  // namespace testing
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/googletest/googlemock/test/gmock-matchers_test.cc b/googletest/googlemock/test/gmock-matchers-containers_test.cc
similarity index 31%
rename from googletest/googlemock/test/gmock-matchers_test.cc
rename to googletest/googlemock/test/gmock-matchers-containers_test.cc
index 1f48a76c287a9a01a3f2b33a9aa5271f1969fd02..98787f25e0279e2515894d5a5898c95afcd6c6ab 100644
--- a/googletest/googlemock/test/gmock-matchers_test.cc
+++ b/googletest/googlemock/test/gmock-matchers-containers_test.cc
@@ -27,3160 +27,71 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
 
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file tests some commonly used argument matchers.
-
-// Silence warning C4244: 'initializing': conversion from 'int' to 'short',
-// possible loss of data and C4100, unreferenced local parameter
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4244)
-# pragma warning(disable:4100)
-#endif
-
-#include "gmock/gmock-matchers.h"
-
-#include <string.h>
-#include <time.h>
-
-#include <array>
-#include <cstdint>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "gmock/gmock-more-matchers.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest-spi.h"
-#include "gtest/gtest.h"
-
-namespace testing {
-namespace gmock_matchers_test {
-namespace {
-
-using std::greater;
-using std::less;
-using std::list;
-using std::make_pair;
-using std::map;
-using std::multimap;
-using std::multiset;
-using std::ostream;
-using std::pair;
-using std::set;
-using std::stringstream;
-using std::vector;
-using testing::internal::DummyMatchResultListener;
-using testing::internal::ElementMatcherPair;
-using testing::internal::ElementMatcherPairs;
-using testing::internal::ElementsAreArrayMatcher;
-using testing::internal::ExplainMatchFailureTupleTo;
-using testing::internal::FloatingEqMatcher;
-using testing::internal::FormatMatcherDescription;
-using testing::internal::IsReadableTypeName;
-using testing::internal::MatchMatrix;
-using testing::internal::PredicateFormatterFromMatcher;
-using testing::internal::RE;
-using testing::internal::StreamMatchResultListener;
-using testing::internal::Strings;
-
-// Helper for testing container-valued matchers in mock method context. It is
-// important to test matchers in this context, since it requires additional type
-// deduction beyond what EXPECT_THAT does, thus making it more restrictive.
-struct ContainerHelper {
-  MOCK_METHOD1(Call, void(std::vector<std::unique_ptr<int>>));
-};
-
-std::vector<std::unique_ptr<int>> MakeUniquePtrs(const std::vector<int>& ints) {
-  std::vector<std::unique_ptr<int>> pointers;
-  for (int i : ints) pointers.emplace_back(new int(i));
-  return pointers;
-}
-
-// For testing ExplainMatchResultTo().
-class GreaterThanMatcher : public MatcherInterface<int> {
- public:
-  explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
-
-  void DescribeTo(ostream* os) const override { *os << "is > " << rhs_; }
-
-  bool MatchAndExplain(int lhs, MatchResultListener* listener) const override {
-    const int diff = lhs - rhs_;
-    if (diff > 0) {
-      *listener << "which is " << diff << " more than " << rhs_;
-    } else if (diff == 0) {
-      *listener << "which is the same as " << rhs_;
-    } else {
-      *listener << "which is " << -diff << " less than " << rhs_;
-    }
-
-    return lhs > rhs_;
-  }
-
- private:
-  int rhs_;
-};
-
-Matcher<int> GreaterThan(int n) {
-  return MakeMatcher(new GreaterThanMatcher(n));
-}
-
-std::string OfType(const std::string& type_name) {
-#if GTEST_HAS_RTTI
-  return IsReadableTypeName(type_name) ? " (of type " + type_name + ")" : "";
-#else
-  return "";
-#endif
-}
-
-// Returns the description of the given matcher.
-template <typename T>
-std::string Describe(const Matcher<T>& m) {
-  return DescribeMatcher<T>(m);
-}
-
-// Returns the description of the negation of the given matcher.
-template <typename T>
-std::string DescribeNegation(const Matcher<T>& m) {
-  return DescribeMatcher<T>(m, true);
-}
-
-// Returns the reason why x matches, or doesn't match, m.
-template <typename MatcherType, typename Value>
-std::string Explain(const MatcherType& m, const Value& x) {
-  StringMatchResultListener listener;
-  ExplainMatchResult(m, x, &listener);
-  return listener.str();
-}
-
-TEST(MonotonicMatcherTest, IsPrintable) {
-  stringstream ss;
-  ss << GreaterThan(5);
-  EXPECT_EQ("is > 5", ss.str());
-}
-
-TEST(MatchResultListenerTest, StreamingWorks) {
-  StringMatchResultListener listener;
-  listener << "hi" << 5;
-  EXPECT_EQ("hi5", listener.str());
-
-  listener.Clear();
-  EXPECT_EQ("", listener.str());
-
-  listener << 42;
-  EXPECT_EQ("42", listener.str());
-
-  // Streaming shouldn't crash when the underlying ostream is NULL.
-  DummyMatchResultListener dummy;
-  dummy << "hi" << 5;
-}
-
-TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
-  EXPECT_TRUE(DummyMatchResultListener().stream() == nullptr);
-  EXPECT_TRUE(StreamMatchResultListener(nullptr).stream() == nullptr);
-
-  EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
-}
-
-TEST(MatchResultListenerTest, IsInterestedWorks) {
-  EXPECT_TRUE(StringMatchResultListener().IsInterested());
-  EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
-
-  EXPECT_FALSE(DummyMatchResultListener().IsInterested());
-  EXPECT_FALSE(StreamMatchResultListener(nullptr).IsInterested());
-}
-
-// Makes sure that the MatcherInterface<T> interface doesn't
-// change.
-class EvenMatcherImpl : public MatcherInterface<int> {
- public:
-  bool MatchAndExplain(int x,
-                       MatchResultListener* /* listener */) const override {
-    return x % 2 == 0;
-  }
-
-  void DescribeTo(ostream* os) const override { *os << "is an even number"; }
-
-  // We deliberately don't define DescribeNegationTo() and
-  // ExplainMatchResultTo() here, to make sure the definition of these
-  // two methods is optional.
-};
-
-// Makes sure that the MatcherInterface API doesn't change.
-TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
-  EvenMatcherImpl m;
-}
-
-// Tests implementing a monomorphic matcher using MatchAndExplain().
-
-class NewEvenMatcherImpl : public MatcherInterface<int> {
- public:
-  bool MatchAndExplain(int x, MatchResultListener* listener) const override {
-    const bool match = x % 2 == 0;
-    // Verifies that we can stream to a listener directly.
-    *listener << "value % " << 2;
-    if (listener->stream() != nullptr) {
-      // Verifies that we can stream to a listener's underlying stream
-      // too.
-      *listener->stream() << " == " << (x % 2);
-    }
-    return match;
-  }
-
-  void DescribeTo(ostream* os) const override { *os << "is an even number"; }
-};
-
-TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
-  Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(3));
-  EXPECT_EQ("value % 2 == 0", Explain(m, 2));
-  EXPECT_EQ("value % 2 == 1", Explain(m, 3));
-}
-
-// Tests default-constructing a matcher.
-TEST(MatcherTest, CanBeDefaultConstructed) {
-  Matcher<double> m;
-}
-
-// Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
-TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
-  const MatcherInterface<int>* impl = new EvenMatcherImpl;
-  Matcher<int> m(impl);
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(5));
-}
-
-// Tests that value can be used in place of Eq(value).
-TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
-  Matcher<int> m1 = 5;
-  EXPECT_TRUE(m1.Matches(5));
-  EXPECT_FALSE(m1.Matches(6));
-}
-
-// Tests that NULL can be used in place of Eq(NULL).
-TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
-  Matcher<int*> m1 = nullptr;
-  EXPECT_TRUE(m1.Matches(nullptr));
-  int n = 0;
-  EXPECT_FALSE(m1.Matches(&n));
-}
-
-// Tests that matchers can be constructed from a variable that is not properly
-// defined. This should be illegal, but many users rely on this accidentally.
-struct Undefined {
-  virtual ~Undefined() = 0;
-  static const int kInt = 1;
-};
-
-TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
-  Matcher<int> m1 = Undefined::kInt;
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_FALSE(m1.Matches(2));
-}
-
-// Test that a matcher parameterized with an abstract class compiles.
-TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&> m = _; }
-
-// Tests that matchers are copyable.
-TEST(MatcherTest, IsCopyable) {
-  // Tests the copy constructor.
-  Matcher<bool> m1 = Eq(false);
-  EXPECT_TRUE(m1.Matches(false));
-  EXPECT_FALSE(m1.Matches(true));
-
-  // Tests the assignment operator.
-  m1 = Eq(true);
-  EXPECT_TRUE(m1.Matches(true));
-  EXPECT_FALSE(m1.Matches(false));
-}
-
-// Tests that Matcher<T>::DescribeTo() calls
-// MatcherInterface<T>::DescribeTo().
-TEST(MatcherTest, CanDescribeItself) {
-  EXPECT_EQ("is an even number",
-            Describe(Matcher<int>(new EvenMatcherImpl)));
-}
-
-// Tests Matcher<T>::MatchAndExplain().
-TEST(MatcherTest, MatchAndExplain) {
-  Matcher<int> m = GreaterThan(0);
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
-  EXPECT_EQ("which is 42 more than 0", listener1.str());
-
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
-  EXPECT_EQ("which is 9 less than 0", listener2.str());
-}
-
-// Tests that a C-string literal can be implicitly converted to a
-// Matcher<std::string> or Matcher<const std::string&>.
-TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
-  Matcher<std::string> m1 = "hi";
-  EXPECT_TRUE(m1.Matches("hi"));
-  EXPECT_FALSE(m1.Matches("hello"));
-
-  Matcher<const std::string&> m2 = "hi";
-  EXPECT_TRUE(m2.Matches("hi"));
-  EXPECT_FALSE(m2.Matches("hello"));
-}
-
-// Tests that a string object can be implicitly converted to a
-// Matcher<std::string> or Matcher<const std::string&>.
-TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
-  Matcher<std::string> m1 = std::string("hi");
-  EXPECT_TRUE(m1.Matches("hi"));
-  EXPECT_FALSE(m1.Matches("hello"));
-
-  Matcher<const std::string&> m2 = std::string("hi");
-  EXPECT_TRUE(m2.Matches("hi"));
-  EXPECT_FALSE(m2.Matches("hello"));
-}
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-// Tests that a C-string literal can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
-TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
-  Matcher<internal::StringView> m1 = "cats";
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const internal::StringView&> m2 = "cats";
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-
-// Tests that a std::string object can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
-TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
-  Matcher<internal::StringView> m1 = std::string("cats");
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const internal::StringView&> m2 = std::string("cats");
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-
-// Tests that a StringView object can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
-TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
-  Matcher<internal::StringView> m1 = internal::StringView("cats");
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const internal::StringView&> m2 = internal::StringView("cats");
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-// Tests that a std::reference_wrapper<std::string> object can be implicitly
-// converted to a Matcher<std::string> or Matcher<const std::string&> via Eq().
-TEST(StringMatcherTest,
-     CanBeImplicitlyConstructedFromEqReferenceWrapperString) {
-  std::string value = "cats";
-  Matcher<std::string> m1 = Eq(std::ref(value));
-  EXPECT_TRUE(m1.Matches("cats"));
-  EXPECT_FALSE(m1.Matches("dogs"));
-
-  Matcher<const std::string&> m2 = Eq(std::ref(value));
-  EXPECT_TRUE(m2.Matches("cats"));
-  EXPECT_FALSE(m2.Matches("dogs"));
-}
-
-// Tests that MakeMatcher() constructs a Matcher<T> from a
-// MatcherInterface* without requiring the user to explicitly
-// write the type.
-TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
-  const MatcherInterface<int>* dummy_impl = new EvenMatcherImpl;
-  Matcher<int> m = MakeMatcher(dummy_impl);
-}
-
-// Tests that MakePolymorphicMatcher() can construct a polymorphic
-// matcher from its implementation using the old API.
-const int g_bar = 1;
-class ReferencesBarOrIsZeroImpl {
- public:
-  template <typename T>
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* /* listener */) const {
-    const void* p = &x;
-    return p == &g_bar || x == 0;
-  }
-
-  void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "doesn't reference g_bar and is not zero";
-  }
-};
-
-// This function verifies that MakePolymorphicMatcher() returns a
-// PolymorphicMatcher<T> where T is the argument's type.
-PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
-  return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
-}
-
-TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
-  // Using a polymorphic matcher to match a reference type.
-  Matcher<const int&> m1 = ReferencesBarOrIsZero();
-  EXPECT_TRUE(m1.Matches(0));
-  // Verifies that the identity of a by-reference argument is preserved.
-  EXPECT_TRUE(m1.Matches(g_bar));
-  EXPECT_FALSE(m1.Matches(1));
-  EXPECT_EQ("g_bar or zero", Describe(m1));
-
-  // Using a polymorphic matcher to match a value type.
-  Matcher<double> m2 = ReferencesBarOrIsZero();
-  EXPECT_TRUE(m2.Matches(0.0));
-  EXPECT_FALSE(m2.Matches(0.1));
-  EXPECT_EQ("g_bar or zero", Describe(m2));
-}
-
-// Tests implementing a polymorphic matcher using MatchAndExplain().
-
-class PolymorphicIsEvenImpl {
- public:
-  void DescribeTo(ostream* os) const { *os << "is even"; }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "is odd";
-  }
-
-  template <typename T>
-  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
-    // Verifies that we can stream to the listener directly.
-    *listener << "% " << 2;
-    if (listener->stream() != nullptr) {
-      // Verifies that we can stream to the listener's underlying stream
-      // too.
-      *listener->stream() << " == " << (x % 2);
-    }
-    return (x % 2) == 0;
-  }
-};
-
-PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
-  return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
-}
-
-TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
-  // Using PolymorphicIsEven() as a Matcher<int>.
-  const Matcher<int> m1 = PolymorphicIsEven();
-  EXPECT_TRUE(m1.Matches(42));
-  EXPECT_FALSE(m1.Matches(43));
-  EXPECT_EQ("is even", Describe(m1));
-
-  const Matcher<int> not_m1 = Not(m1);
-  EXPECT_EQ("is odd", Describe(not_m1));
-
-  EXPECT_EQ("% 2 == 0", Explain(m1, 42));
-
-  // Using PolymorphicIsEven() as a Matcher<char>.
-  const Matcher<char> m2 = PolymorphicIsEven();
-  EXPECT_TRUE(m2.Matches('\x42'));
-  EXPECT_FALSE(m2.Matches('\x43'));
-  EXPECT_EQ("is even", Describe(m2));
-
-  const Matcher<char> not_m2 = Not(m2);
-  EXPECT_EQ("is odd", Describe(not_m2));
-
-  EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
-TEST(MatcherCastTest, FromPolymorphicMatcher) {
-  Matcher<int> m = MatcherCast<int>(Eq(5));
-  EXPECT_TRUE(m.Matches(5));
-  EXPECT_FALSE(m.Matches(6));
-}
-
-// For testing casting matchers between compatible types.
-class IntValue {
- public:
-  // An int can be statically (although not implicitly) cast to a
-  // IntValue.
-  explicit IntValue(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
- private:
-  int value_;
-};
-
-// For testing casting matchers between compatible types.
-bool IsPositiveIntValue(const IntValue& foo) {
-  return foo.value() > 0;
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
-// can be statically converted to U.
-TEST(MatcherCastTest, FromCompatibleType) {
-  Matcher<double> m1 = Eq(2.0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(2));
-  EXPECT_FALSE(m2.Matches(3));
-
-  Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
-  Matcher<int> m4 = MatcherCast<int>(m3);
-  // In the following, the arguments 1 and 0 are statically converted
-  // to IntValue objects, and then tested by the IsPositiveIntValue()
-  // predicate.
-  EXPECT_TRUE(m4.Matches(1));
-  EXPECT_FALSE(m4.Matches(0));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
-TEST(MatcherCastTest, FromConstReferenceToNonReference) {
-  Matcher<const int&> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
-TEST(MatcherCastTest, FromReferenceToNonReference) {
-  Matcher<int&> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromNonReferenceToConstReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<const int&> m2 = MatcherCast<const int&>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromNonReferenceToReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int&> m2 = MatcherCast<int&>(m1);
-  int n = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  n = 1;
-  EXPECT_FALSE(m2.Matches(n));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
-TEST(MatcherCastTest, FromSameType) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a value of the same type as the
-// value type of the Matcher.
-TEST(MatcherCastTest, FromAValue) {
-  Matcher<int> m = MatcherCast<int>(42);
-  EXPECT_TRUE(m.Matches(42));
-  EXPECT_FALSE(m.Matches(239));
-}
-
-// Tests that MatcherCast<T>(m) works when m is a value of the type implicitly
-// convertible to the value type of the Matcher.
-TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
-  const int kExpected = 'c';
-  Matcher<int> m = MatcherCast<int>('c');
-  EXPECT_TRUE(m.Matches(kExpected));
-  EXPECT_FALSE(m.Matches(kExpected + 1));
-}
-
-struct NonImplicitlyConstructibleTypeWithOperatorEq {
-  friend bool operator==(
-      const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */,
-      int rhs) {
-    return 42 == rhs;
-  }
-  friend bool operator==(
-      int lhs,
-      const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */) {
-    return lhs == 42;
-  }
-};
-
-// Tests that MatcherCast<T>(m) works when m is a neither a matcher nor
-// implicitly convertible to the value type of the Matcher, but the value type
-// of the matcher has operator==() overload accepting m.
-TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
-  Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m1 =
-      MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(42);
-  EXPECT_TRUE(m1.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
-
-  Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m2 =
-      MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(239);
-  EXPECT_FALSE(m2.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
-
-  // When updating the following lines please also change the comment to
-  // namespace convertible_from_any.
-  Matcher<int> m3 =
-      MatcherCast<int>(NonImplicitlyConstructibleTypeWithOperatorEq());
-  EXPECT_TRUE(m3.Matches(42));
-  EXPECT_FALSE(m3.Matches(239));
-}
-
-// ConvertibleFromAny does not work with MSVC. resulting in
-// error C2440: 'initializing': cannot convert from 'Eq' to 'M'
-// No constructor could take the source type, or constructor overload
-// resolution was ambiguous
-
-#if !defined _MSC_VER
-
-// The below ConvertibleFromAny struct is implicitly constructible from anything
-// and when in the same namespace can interact with other tests. In particular,
-// if it is in the same namespace as other tests and one removes
-//   NonImplicitlyConstructibleTypeWithOperatorEq::operator==(int lhs, ...);
-// then the corresponding test still compiles (and it should not!) by implicitly
-// converting NonImplicitlyConstructibleTypeWithOperatorEq to ConvertibleFromAny
-// in m3.Matcher().
-namespace convertible_from_any {
-// Implicitly convertible from any type.
-struct ConvertibleFromAny {
-  ConvertibleFromAny(int a_value) : value(a_value) {}
-  template <typename T>
-  ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
-    ADD_FAILURE() << "Conversion constructor called";
-  }
-  int value;
-};
-
-bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
-  return a.value == b.value;
-}
-
-ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
-  return os << a.value;
-}
-
-TEST(MatcherCastTest, ConversionConstructorIsUsed) {
-  Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-TEST(MatcherCastTest, FromConvertibleFromAny) {
-  Matcher<ConvertibleFromAny> m =
-      MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-}  // namespace convertible_from_any
-
-#endif  // !defined _MSC_VER
-
-struct IntReferenceWrapper {
-  IntReferenceWrapper(const int& a_value) : value(&a_value) {}
-  const int* value;
-};
-
-bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
-  return a.value == b.value;
-}
-
-TEST(MatcherCastTest, ValueIsNotCopied) {
-  int n = 42;
-  Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
-  // Verify that the matcher holds a reference to n, not to its temporary copy.
-  EXPECT_TRUE(m.Matches(n));
-}
-
-class Base {
- public:
-  virtual ~Base() {}
-  Base() {}
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
-};
-
-class Derived : public Base {
- public:
-  Derived() : Base() {}
-  int i;
-};
-
-class OtherDerived : public Base {};
-
-// Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
-TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
-  Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
-  EXPECT_TRUE(m2.Matches(' '));
-  EXPECT_FALSE(m2.Matches('\n'));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
-// T and U are arithmetic types and T can be losslessly converted to
-// U.
-TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
-  Matcher<double> m1 = DoubleEq(1.0);
-  Matcher<float> m2 = SafeMatcherCast<float>(m1);
-  EXPECT_TRUE(m2.Matches(1.0f));
-  EXPECT_FALSE(m2.Matches(2.0f));
-
-  Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
-  EXPECT_TRUE(m3.Matches('a'));
-  EXPECT_FALSE(m3.Matches('b'));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
-// are pointers or references to a derived and a base class, correspondingly.
-TEST(SafeMatcherCastTest, FromBaseClass) {
-  Derived d, d2;
-  Matcher<Base*> m1 = Eq(&d);
-  Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
-  EXPECT_TRUE(m2.Matches(&d));
-  EXPECT_FALSE(m2.Matches(&d2));
-
-  Matcher<Base&> m3 = Ref(d);
-  Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
-  EXPECT_TRUE(m4.Matches(d));
-  EXPECT_FALSE(m4.Matches(d2));
-}
-
-// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
-TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
-  int n = 0;
-  Matcher<const int&> m1 = Ref(n);
-  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
-  int n1 = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  EXPECT_FALSE(m2.Matches(n1));
-}
-
-// Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
-  Matcher<std::unique_ptr<int>> m1 = IsNull();
-  Matcher<const std::unique_ptr<int>&> m2 =
-      SafeMatcherCast<const std::unique_ptr<int>&>(m1);
-  EXPECT_TRUE(m2.Matches(std::unique_ptr<int>()));
-  EXPECT_FALSE(m2.Matches(std::unique_ptr<int>(new int)));
-}
-
-// Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
-  int n = 0;
-  EXPECT_TRUE(m2.Matches(n));
-  n = 1;
-  EXPECT_FALSE(m2.Matches(n));
-}
-
-// Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
-TEST(SafeMatcherCastTest, FromSameType) {
-  Matcher<int> m1 = Eq(0);
-  Matcher<int> m2 = SafeMatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_FALSE(m2.Matches(1));
-}
-
-#if !defined _MSC_VER
-
-namespace convertible_from_any {
-TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
-  Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-
-TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
-  Matcher<ConvertibleFromAny> m =
-      SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
-  EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
-  EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
-}
-}  // namespace convertible_from_any
-
-#endif  // !defined _MSC_VER
-
-TEST(SafeMatcherCastTest, ValueIsNotCopied) {
-  int n = 42;
-  Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
-  // Verify that the matcher holds a reference to n, not to its temporary copy.
-  EXPECT_TRUE(m.Matches(n));
-}
-
-TEST(ExpectThat, TakesLiterals) {
-  EXPECT_THAT(1, 1);
-  EXPECT_THAT(1.0, 1.0);
-  EXPECT_THAT(std::string(), "");
-}
-
-TEST(ExpectThat, TakesFunctions) {
-  struct Helper {
-    static void Func() {}
-  };
-  void (*func)() = Helper::Func;
-  EXPECT_THAT(func, Helper::Func);
-  EXPECT_THAT(func, &Helper::Func);
-}
-
-// Tests that A<T>() matches any value of type T.
-TEST(ATest, MatchesAnyValue) {
-  // Tests a matcher for a value type.
-  Matcher<double> m1 = A<double>();
-  EXPECT_TRUE(m1.Matches(91.43));
-  EXPECT_TRUE(m1.Matches(-15.32));
-
-  // Tests a matcher for a reference type.
-  int a = 2;
-  int b = -6;
-  Matcher<int&> m2 = A<int&>();
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-TEST(ATest, WorksForDerivedClass) {
-  Base base;
-  Derived derived;
-  EXPECT_THAT(&base, A<Base*>());
-  // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
-  EXPECT_THAT(&derived, A<Base*>());
-  EXPECT_THAT(&derived, A<Derived*>());
-}
-
-// Tests that A<T>() describes itself properly.
-TEST(ATest, CanDescribeSelf) {
-  EXPECT_EQ("is anything", Describe(A<bool>()));
-}
-
-// Tests that An<T>() matches any value of type T.
-TEST(AnTest, MatchesAnyValue) {
-  // Tests a matcher for a value type.
-  Matcher<int> m1 = An<int>();
-  EXPECT_TRUE(m1.Matches(9143));
-  EXPECT_TRUE(m1.Matches(-1532));
-
-  // Tests a matcher for a reference type.
-  int a = 2;
-  int b = -6;
-  Matcher<int&> m2 = An<int&>();
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-// Tests that An<T>() describes itself properly.
-TEST(AnTest, CanDescribeSelf) {
-  EXPECT_EQ("is anything", Describe(An<int>()));
-}
-
-// Tests that _ can be used as a matcher for any type and matches any
-// value of that type.
-TEST(UnderscoreTest, MatchesAnyValue) {
-  // Uses _ as a matcher for a value type.
-  Matcher<int> m1 = _;
-  EXPECT_TRUE(m1.Matches(123));
-  EXPECT_TRUE(m1.Matches(-242));
-
-  // Uses _ as a matcher for a reference type.
-  bool a = false;
-  const bool b = true;
-  Matcher<const bool&> m2 = _;
-  EXPECT_TRUE(m2.Matches(a));
-  EXPECT_TRUE(m2.Matches(b));
-}
-
-// Tests that _ describes itself properly.
-TEST(UnderscoreTest, CanDescribeSelf) {
-  Matcher<int> m = _;
-  EXPECT_EQ("is anything", Describe(m));
-}
-
-// Tests that Eq(x) matches any value equal to x.
-TEST(EqTest, MatchesEqualValue) {
-  // 2 C-strings with same content but different addresses.
-  const char a1[] = "hi";
-  const char a2[] = "hi";
-
-  Matcher<const char*> m1 = Eq(a1);
-  EXPECT_TRUE(m1.Matches(a1));
-  EXPECT_FALSE(m1.Matches(a2));
-}
-
-// Tests that Eq(v) describes itself properly.
-
-class Unprintable {
- public:
-  Unprintable() : c_('a') {}
-
-  bool operator==(const Unprintable& /* rhs */) const { return true; }
-  // -Wunused-private-field: dummy accessor for `c_`.
-  char dummy_c() { return c_; }
- private:
-  char c_;
-};
-
-TEST(EqTest, CanDescribeSelf) {
-  Matcher<Unprintable> m = Eq(Unprintable());
-  EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
-}
-
-// Tests that Eq(v) can be used to match any type that supports
-// comparing with type T, where T is v's type.
-TEST(EqTest, IsPolymorphic) {
-  Matcher<int> m1 = Eq(1);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_FALSE(m1.Matches(2));
-
-  Matcher<char> m2 = Eq(1);
-  EXPECT_TRUE(m2.Matches('\1'));
-  EXPECT_FALSE(m2.Matches('a'));
-}
-
-// Tests that TypedEq<T>(v) matches values of type T that's equal to v.
-TEST(TypedEqTest, ChecksEqualityForGivenType) {
-  Matcher<char> m1 = TypedEq<char>('a');
-  EXPECT_TRUE(m1.Matches('a'));
-  EXPECT_FALSE(m1.Matches('b'));
-
-  Matcher<int> m2 = TypedEq<int>(6);
-  EXPECT_TRUE(m2.Matches(6));
-  EXPECT_FALSE(m2.Matches(7));
-}
-
-// Tests that TypedEq(v) describes itself properly.
-TEST(TypedEqTest, CanDescribeSelf) {
-  EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
-}
-
-// Tests that TypedEq<T>(v) has type Matcher<T>.
-
-// Type<T>::IsTypeOf(v) compiles if and only if the type of value v is T, where
-// T is a "bare" type (i.e. not in the form of const U or U&).  If v's type is
-// not T, the compiler will generate a message about "undefined reference".
-template <typename T>
-struct Type {
-  static bool IsTypeOf(const T& /* v */) { return true; }
-
-  template <typename T2>
-  static void IsTypeOf(T2 v);
-};
-
-TEST(TypedEqTest, HasSpecifiedType) {
-  // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
-  Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
-  Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
-}
-
-// Tests that Ge(v) matches anything >= v.
-TEST(GeTest, ImplementsGreaterThanOrEqual) {
-  Matcher<int> m1 = Ge(0);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_TRUE(m1.Matches(0));
-  EXPECT_FALSE(m1.Matches(-1));
-}
-
-// Tests that Ge(v) describes itself properly.
-TEST(GeTest, CanDescribeSelf) {
-  Matcher<int> m = Ge(5);
-  EXPECT_EQ("is >= 5", Describe(m));
-}
-
-// Tests that Gt(v) matches anything > v.
-TEST(GtTest, ImplementsGreaterThan) {
-  Matcher<double> m1 = Gt(0);
-  EXPECT_TRUE(m1.Matches(1.0));
-  EXPECT_FALSE(m1.Matches(0.0));
-  EXPECT_FALSE(m1.Matches(-1.0));
-}
-
-// Tests that Gt(v) describes itself properly.
-TEST(GtTest, CanDescribeSelf) {
-  Matcher<int> m = Gt(5);
-  EXPECT_EQ("is > 5", Describe(m));
-}
-
-// Tests that Le(v) matches anything <= v.
-TEST(LeTest, ImplementsLessThanOrEqual) {
-  Matcher<char> m1 = Le('b');
-  EXPECT_TRUE(m1.Matches('a'));
-  EXPECT_TRUE(m1.Matches('b'));
-  EXPECT_FALSE(m1.Matches('c'));
-}
-
-// Tests that Le(v) describes itself properly.
-TEST(LeTest, CanDescribeSelf) {
-  Matcher<int> m = Le(5);
-  EXPECT_EQ("is <= 5", Describe(m));
-}
-
-// Tests that Lt(v) matches anything < v.
-TEST(LtTest, ImplementsLessThan) {
-  Matcher<const std::string&> m1 = Lt("Hello");
-  EXPECT_TRUE(m1.Matches("Abc"));
-  EXPECT_FALSE(m1.Matches("Hello"));
-  EXPECT_FALSE(m1.Matches("Hello, world!"));
-}
-
-// Tests that Lt(v) describes itself properly.
-TEST(LtTest, CanDescribeSelf) {
-  Matcher<int> m = Lt(5);
-  EXPECT_EQ("is < 5", Describe(m));
-}
-
-// Tests that Ne(v) matches anything != v.
-TEST(NeTest, ImplementsNotEqual) {
-  Matcher<int> m1 = Ne(0);
-  EXPECT_TRUE(m1.Matches(1));
-  EXPECT_TRUE(m1.Matches(-1));
-  EXPECT_FALSE(m1.Matches(0));
-}
-
-// Tests that Ne(v) describes itself properly.
-TEST(NeTest, CanDescribeSelf) {
-  Matcher<int> m = Ne(5);
-  EXPECT_EQ("isn't equal to 5", Describe(m));
-}
-
-class MoveOnly {
- public:
-  explicit MoveOnly(int i) : i_(i) {}
-  MoveOnly(const MoveOnly&) = delete;
-  MoveOnly(MoveOnly&&) = default;
-  MoveOnly& operator=(const MoveOnly&) = delete;
-  MoveOnly& operator=(MoveOnly&&) = default;
-
-  bool operator==(const MoveOnly& other) const { return i_ == other.i_; }
-  bool operator!=(const MoveOnly& other) const { return i_ != other.i_; }
-  bool operator<(const MoveOnly& other) const { return i_ < other.i_; }
-  bool operator<=(const MoveOnly& other) const { return i_ <= other.i_; }
-  bool operator>(const MoveOnly& other) const { return i_ > other.i_; }
-  bool operator>=(const MoveOnly& other) const { return i_ >= other.i_; }
-
- private:
-  int i_;
-};
-
-struct MoveHelper {
-  MOCK_METHOD1(Call, void(MoveOnly));
-};
-
-// Disable this test in VS 2015 (version 14), where it fails when SEH is enabled
-#if defined(_MSC_VER) && (_MSC_VER < 1910)
-TEST(ComparisonBaseTest, DISABLED_WorksWithMoveOnly) {
-#else
-TEST(ComparisonBaseTest, WorksWithMoveOnly) {
-#endif
-  MoveOnly m{0};
-  MoveHelper helper;
-
-  EXPECT_CALL(helper, Call(Eq(ByRef(m))));
-  helper.Call(MoveOnly(0));
-  EXPECT_CALL(helper, Call(Ne(ByRef(m))));
-  helper.Call(MoveOnly(1));
-  EXPECT_CALL(helper, Call(Le(ByRef(m))));
-  helper.Call(MoveOnly(0));
-  EXPECT_CALL(helper, Call(Lt(ByRef(m))));
-  helper.Call(MoveOnly(-1));
-  EXPECT_CALL(helper, Call(Ge(ByRef(m))));
-  helper.Call(MoveOnly(0));
-  EXPECT_CALL(helper, Call(Gt(ByRef(m))));
-  helper.Call(MoveOnly(1));
-}
-
-// Tests that IsNull() matches any NULL pointer of any type.
-TEST(IsNullTest, MatchesNullPointer) {
-  Matcher<int*> m1 = IsNull();
-  int* p1 = nullptr;
-  int n = 0;
-  EXPECT_TRUE(m1.Matches(p1));
-  EXPECT_FALSE(m1.Matches(&n));
-
-  Matcher<const char*> m2 = IsNull();
-  const char* p2 = nullptr;
-  EXPECT_TRUE(m2.Matches(p2));
-  EXPECT_FALSE(m2.Matches("hi"));
-
-  Matcher<void*> m3 = IsNull();
-  void* p3 = nullptr;
-  EXPECT_TRUE(m3.Matches(p3));
-  EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
-}
-
-TEST(IsNullTest, StdFunction) {
-  const Matcher<std::function<void()>> m = IsNull();
-
-  EXPECT_TRUE(m.Matches(std::function<void()>()));
-  EXPECT_FALSE(m.Matches([]{}));
-}
-
-// Tests that IsNull() describes itself properly.
-TEST(IsNullTest, CanDescribeSelf) {
-  Matcher<int*> m = IsNull();
-  EXPECT_EQ("is NULL", Describe(m));
-  EXPECT_EQ("isn't NULL", DescribeNegation(m));
-}
-
-// Tests that NotNull() matches any non-NULL pointer of any type.
-TEST(NotNullTest, MatchesNonNullPointer) {
-  Matcher<int*> m1 = NotNull();
-  int* p1 = nullptr;
-  int n = 0;
-  EXPECT_FALSE(m1.Matches(p1));
-  EXPECT_TRUE(m1.Matches(&n));
-
-  Matcher<const char*> m2 = NotNull();
-  const char* p2 = nullptr;
-  EXPECT_FALSE(m2.Matches(p2));
-  EXPECT_TRUE(m2.Matches("hi"));
-}
-
-TEST(NotNullTest, LinkedPtr) {
-  const Matcher<std::shared_ptr<int>> m = NotNull();
-  const std::shared_ptr<int> null_p;
-  const std::shared_ptr<int> non_null_p(new int);
-
-  EXPECT_FALSE(m.Matches(null_p));
-  EXPECT_TRUE(m.Matches(non_null_p));
-}
-
-TEST(NotNullTest, ReferenceToConstLinkedPtr) {
-  const Matcher<const std::shared_ptr<double>&> m = NotNull();
-  const std::shared_ptr<double> null_p;
-  const std::shared_ptr<double> non_null_p(new double);
-
-  EXPECT_FALSE(m.Matches(null_p));
-  EXPECT_TRUE(m.Matches(non_null_p));
-}
-
-TEST(NotNullTest, StdFunction) {
-  const Matcher<std::function<void()>> m = NotNull();
-
-  EXPECT_TRUE(m.Matches([]{}));
-  EXPECT_FALSE(m.Matches(std::function<void()>()));
-}
-
-// Tests that NotNull() describes itself properly.
-TEST(NotNullTest, CanDescribeSelf) {
-  Matcher<int*> m = NotNull();
-  EXPECT_EQ("isn't NULL", Describe(m));
-}
-
-// Tests that Ref(variable) matches an argument that references
-// 'variable'.
-TEST(RefTest, MatchesSameVariable) {
-  int a = 0;
-  int b = 0;
-  Matcher<int&> m = Ref(a);
-  EXPECT_TRUE(m.Matches(a));
-  EXPECT_FALSE(m.Matches(b));
-}
-
-// Tests that Ref(variable) describes itself properly.
-TEST(RefTest, CanDescribeSelf) {
-  int n = 5;
-  Matcher<int&> m = Ref(n);
-  stringstream ss;
-  ss << "references the variable @" << &n << " 5";
-  EXPECT_EQ(ss.str(), Describe(m));
-}
-
-// Test that Ref(non_const_varialbe) can be used as a matcher for a
-// const reference.
-TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
-  int a = 0;
-  int b = 0;
-  Matcher<const int&> m = Ref(a);
-  EXPECT_TRUE(m.Matches(a));
-  EXPECT_FALSE(m.Matches(b));
-}
-
-// Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
-// used wherever Ref(base) can be used (Ref(derived) is a sub-type
-// of Ref(base), but not vice versa.
-
-TEST(RefTest, IsCovariant) {
-  Base base, base2;
-  Derived derived;
-  Matcher<const Base&> m1 = Ref(base);
-  EXPECT_TRUE(m1.Matches(base));
-  EXPECT_FALSE(m1.Matches(base2));
-  EXPECT_FALSE(m1.Matches(derived));
-
-  m1 = Ref(derived);
-  EXPECT_TRUE(m1.Matches(derived));
-  EXPECT_FALSE(m1.Matches(base));
-  EXPECT_FALSE(m1.Matches(base2));
-}
-
-TEST(RefTest, ExplainsResult) {
-  int n = 0;
-  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
-              StartsWith("which is located @"));
-
-  int m = 0;
-  EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
-              StartsWith("which is located @"));
-}
-
-// Tests string comparison matchers.
-
-template <typename T = std::string>
-std::string FromStringLike(internal::StringLike<T> str) {
-  return std::string(str);
-}
-
-TEST(StringLike, TestConversions) {
-  EXPECT_EQ("foo", FromStringLike("foo"));
-  EXPECT_EQ("foo", FromStringLike(std::string("foo")));
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  EXPECT_EQ("foo", FromStringLike(internal::StringView("foo")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-  // Non deducible types.
-  EXPECT_EQ("", FromStringLike({}));
-  EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'}));
-  const char buf[] = "foo";
-  EXPECT_EQ("foo", FromStringLike({buf, buf + 3}));
-}
-
-TEST(StrEqTest, MatchesEqualString) {
-  Matcher<const char*> m = StrEq(std::string("Hello"));
-  EXPECT_TRUE(m.Matches("Hello"));
-  EXPECT_FALSE(m.Matches("hello"));
-  EXPECT_FALSE(m.Matches(nullptr));
-
-  Matcher<const std::string&> m2 = StrEq("Hello");
-  EXPECT_TRUE(m2.Matches("Hello"));
-  EXPECT_FALSE(m2.Matches("Hi"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView&> m3 =
-      StrEq(internal::StringView("Hello"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
-
-  Matcher<const internal::StringView&> m_empty = StrEq("");
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
-  EXPECT_FALSE(m_empty.Matches(internal::StringView("hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(StrEqTest, CanDescribeSelf) {
-  Matcher<std::string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
-  EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
-      Describe(m));
-
-  std::string str("01204500800");
-  str[3] = '\0';
-  Matcher<std::string> m2 = StrEq(str);
-  EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
-  str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
-  Matcher<std::string> m3 = StrEq(str);
-  EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
-}
-
-TEST(StrNeTest, MatchesUnequalString) {
-  Matcher<const char*> m = StrNe("Hello");
-  EXPECT_TRUE(m.Matches(""));
-  EXPECT_TRUE(m.Matches(nullptr));
-  EXPECT_FALSE(m.Matches("Hello"));
-
-  Matcher<std::string> m2 = StrNe(std::string("Hello"));
-  EXPECT_TRUE(m2.Matches("hello"));
-  EXPECT_FALSE(m2.Matches("Hello"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView> m3 = StrNe(internal::StringView("Hello"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(StrNeTest, CanDescribeSelf) {
-  Matcher<const char*> m = StrNe("Hi");
-  EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
-}
-
-TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
-  Matcher<const char*> m = StrCaseEq(std::string("Hello"));
-  EXPECT_TRUE(m.Matches("Hello"));
-  EXPECT_TRUE(m.Matches("hello"));
-  EXPECT_FALSE(m.Matches("Hi"));
-  EXPECT_FALSE(m.Matches(nullptr));
-
-  Matcher<const std::string&> m2 = StrCaseEq("Hello");
-  EXPECT_TRUE(m2.Matches("hello"));
-  EXPECT_FALSE(m2.Matches("Hi"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView&> m3 =
-      StrCaseEq(internal::StringView("Hello"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
-  std::string str1("oabocdooeoo");
-  std::string str2("OABOCDOOEOO");
-  Matcher<const std::string&> m0 = StrCaseEq(str1);
-  EXPECT_FALSE(m0.Matches(str2 + std::string(1, '\0')));
-
-  str1[3] = str2[3] = '\0';
-  Matcher<const std::string&> m1 = StrCaseEq(str1);
-  EXPECT_TRUE(m1.Matches(str2));
-
-  str1[0] = str1[6] = str1[7] = str1[10] = '\0';
-  str2[0] = str2[6] = str2[7] = str2[10] = '\0';
-  Matcher<const std::string&> m2 = StrCaseEq(str1);
-  str1[9] = str2[9] = '\0';
-  EXPECT_FALSE(m2.Matches(str2));
-
-  Matcher<const std::string&> m3 = StrCaseEq(str1);
-  EXPECT_TRUE(m3.Matches(str2));
-
-  EXPECT_FALSE(m3.Matches(str2 + "x"));
-  str2.append(1, '\0');
-  EXPECT_FALSE(m3.Matches(str2));
-  EXPECT_FALSE(m3.Matches(std::string(str2, 0, 9)));
-}
-
-TEST(StrCaseEqTest, CanDescribeSelf) {
-  Matcher<std::string> m = StrCaseEq("Hi");
-  EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
-}
-
-TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
-  Matcher<const char*> m = StrCaseNe("Hello");
-  EXPECT_TRUE(m.Matches("Hi"));
-  EXPECT_TRUE(m.Matches(nullptr));
-  EXPECT_FALSE(m.Matches("Hello"));
-  EXPECT_FALSE(m.Matches("hello"));
-
-  Matcher<std::string> m2 = StrCaseNe(std::string("Hello"));
-  EXPECT_TRUE(m2.Matches(""));
-  EXPECT_FALSE(m2.Matches("Hello"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView> m3 =
-      StrCaseNe(internal::StringView("Hello"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(StrCaseNeTest, CanDescribeSelf) {
-  Matcher<const char*> m = StrCaseNe("Hi");
-  EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
-}
-
-// Tests that HasSubstr() works for matching string-typed values.
-TEST(HasSubstrTest, WorksForStringClasses) {
-  const Matcher<std::string> m1 = HasSubstr("foo");
-  EXPECT_TRUE(m1.Matches(std::string("I love food.")));
-  EXPECT_FALSE(m1.Matches(std::string("tofo")));
-
-  const Matcher<const std::string&> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches(std::string("I love food.")));
-  EXPECT_FALSE(m2.Matches(std::string("tofo")));
-
-  const Matcher<std::string> m_empty = HasSubstr("");
-  EXPECT_TRUE(m_empty.Matches(std::string()));
-  EXPECT_TRUE(m_empty.Matches(std::string("not empty")));
-}
-
-// Tests that HasSubstr() works for matching C-string-typed values.
-TEST(HasSubstrTest, WorksForCStrings) {
-  const Matcher<char*> m1 = HasSubstr("foo");
-  EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
-  EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const char*> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches("I love food."));
-  EXPECT_FALSE(m2.Matches("tofo"));
-  EXPECT_FALSE(m2.Matches(nullptr));
-
-  const Matcher<const char*> m_empty = HasSubstr("");
-  EXPECT_TRUE(m_empty.Matches("not empty"));
-  EXPECT_TRUE(m_empty.Matches(""));
-  EXPECT_FALSE(m_empty.Matches(nullptr));
-}
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-// Tests that HasSubstr() works for matching StringView-typed values.
-TEST(HasSubstrTest, WorksForStringViewClasses) {
-  const Matcher<internal::StringView> m1 =
-      HasSubstr(internal::StringView("foo"));
-  EXPECT_TRUE(m1.Matches(internal::StringView("I love food.")));
-  EXPECT_FALSE(m1.Matches(internal::StringView("tofo")));
-  EXPECT_FALSE(m1.Matches(internal::StringView()));
-
-  const Matcher<const internal::StringView&> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches(internal::StringView("I love food.")));
-  EXPECT_FALSE(m2.Matches(internal::StringView("tofo")));
-  EXPECT_FALSE(m2.Matches(internal::StringView()));
-
-  const Matcher<const internal::StringView&> m3 = HasSubstr("");
-  EXPECT_TRUE(m3.Matches(internal::StringView("foo")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
-}
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-// Tests that HasSubstr(s) describes itself properly.
-TEST(HasSubstrTest, CanDescribeSelf) {
-  Matcher<std::string> m = HasSubstr("foo\n\"");
-  EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
-}
-
-TEST(KeyTest, CanDescribeSelf) {
-  Matcher<const pair<std::string, int>&> m = Key("foo");
-  EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
-  EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
-}
-
-TEST(KeyTest, ExplainsResult) {
-  Matcher<pair<int, bool> > m = Key(GreaterThan(10));
-  EXPECT_EQ("whose first field is a value which is 5 less than 10",
-            Explain(m, make_pair(5, true)));
-  EXPECT_EQ("whose first field is a value which is 5 more than 10",
-            Explain(m, make_pair(15, true)));
-}
-
-TEST(KeyTest, MatchesCorrectly) {
-  pair<int, std::string> p(25, "foo");
-  EXPECT_THAT(p, Key(25));
-  EXPECT_THAT(p, Not(Key(42)));
-  EXPECT_THAT(p, Key(Ge(20)));
-  EXPECT_THAT(p, Not(Key(Lt(25))));
-}
-
-TEST(KeyTest, WorksWithMoveOnly) {
-  pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
-  EXPECT_THAT(p, Key(Eq(nullptr)));
-}
-
-template <size_t I>
-struct Tag {};
-
-struct PairWithGet {
-  int member_1;
-  std::string member_2;
-  using first_type = int;
-  using second_type = std::string;
-
-  const int& GetImpl(Tag<0>) const { return member_1; }
-  const std::string& GetImpl(Tag<1>) const { return member_2; }
-};
-template <size_t I>
-auto get(const PairWithGet& value) -> decltype(value.GetImpl(Tag<I>())) {
-  return value.GetImpl(Tag<I>());
-}
-TEST(PairTest, MatchesPairWithGetCorrectly) {
-  PairWithGet p{25, "foo"};
-  EXPECT_THAT(p, Key(25));
-  EXPECT_THAT(p, Not(Key(42)));
-  EXPECT_THAT(p, Key(Ge(20)));
-  EXPECT_THAT(p, Not(Key(Lt(25))));
-
-  std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
-  EXPECT_THAT(v, Contains(Key(29)));
-}
-
-TEST(KeyTest, SafelyCastsInnerMatcher) {
-  Matcher<int> is_positive = Gt(0);
-  Matcher<int> is_negative = Lt(0);
-  pair<char, bool> p('a', true);
-  EXPECT_THAT(p, Key(is_positive));
-  EXPECT_THAT(p, Not(Key(is_negative)));
-}
-
-TEST(KeyTest, InsideContainsUsingMap) {
-  map<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-  EXPECT_THAT(container, Contains(Key(1)));
-  EXPECT_THAT(container, Not(Contains(Key(3))));
-}
-
-TEST(KeyTest, InsideContainsUsingMultimap) {
-  multimap<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-
-  EXPECT_THAT(container, Not(Contains(Key(25))));
-  container.insert(make_pair(25, 'd'));
-  EXPECT_THAT(container, Contains(Key(25)));
-  container.insert(make_pair(25, 'e'));
-  EXPECT_THAT(container, Contains(Key(25)));
-
-  EXPECT_THAT(container, Contains(Key(1)));
-  EXPECT_THAT(container, Not(Contains(Key(3))));
-}
-
-TEST(PairTest, Typing) {
-  // Test verifies the following type conversions can be compiled.
-  Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
-  Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
-  Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
-
-  Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
-  Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
-}
-
-TEST(PairTest, CanDescribeSelf) {
-  Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
-  EXPECT_EQ("has a first field that is equal to \"foo\""
-            ", and has a second field that is equal to 42",
-            Describe(m1));
-  EXPECT_EQ("has a first field that isn't equal to \"foo\""
-            ", or has a second field that isn't equal to 42",
-            DescribeNegation(m1));
-  // Double and triple negation (1 or 2 times not and description of negation).
-  Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
-  EXPECT_EQ("has a first field that isn't equal to 13"
-            ", and has a second field that is equal to 42",
-            DescribeNegation(m2));
-}
-
-TEST(PairTest, CanExplainMatchResultTo) {
-  // If neither field matches, Pair() should explain about the first
-  // field.
-  const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
-  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
-            Explain(m, make_pair(-1, -2)));
-
-  // If the first field matches but the second doesn't, Pair() should
-  // explain about the second field.
-  EXPECT_EQ("whose second field does not match, which is 2 less than 0",
-            Explain(m, make_pair(1, -2)));
-
-  // If the first field doesn't match but the second does, Pair()
-  // should explain about the first field.
-  EXPECT_EQ("whose first field does not match, which is 1 less than 0",
-            Explain(m, make_pair(-1, 2)));
-
-  // If both fields match, Pair() should explain about them both.
-  EXPECT_EQ("whose both fields match, where the first field is a value "
-            "which is 1 more than 0, and the second field is a value "
-            "which is 2 more than 0",
-            Explain(m, make_pair(1, 2)));
-
-  // If only the first match has an explanation, only this explanation should
-  // be printed.
-  const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
-  EXPECT_EQ("whose both fields match, where the first field is a value "
-            "which is 1 more than 0",
-            Explain(explain_first, make_pair(1, 0)));
-
-  // If only the second match has an explanation, only this explanation should
-  // be printed.
-  const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
-  EXPECT_EQ("whose both fields match, where the second field is a value "
-            "which is 1 more than 0",
-            Explain(explain_second, make_pair(0, 1)));
-}
-
-TEST(PairTest, MatchesCorrectly) {
-  pair<int, std::string> p(25, "foo");
-
-  // Both fields match.
-  EXPECT_THAT(p, Pair(25, "foo"));
-  EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
-
-  // 'first' doesnt' match, but 'second' matches.
-  EXPECT_THAT(p, Not(Pair(42, "foo")));
-  EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
-
-  // 'first' matches, but 'second' doesn't match.
-  EXPECT_THAT(p, Not(Pair(25, "bar")));
-  EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
-
-  // Neither field matches.
-  EXPECT_THAT(p, Not(Pair(13, "bar")));
-  EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
-}
-
-TEST(PairTest, WorksWithMoveOnly) {
-  pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
-  p.second.reset(new int(7));
-  EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr)));
-}
-
-TEST(PairTest, SafelyCastsInnerMatchers) {
-  Matcher<int> is_positive = Gt(0);
-  Matcher<int> is_negative = Lt(0);
-  pair<char, bool> p('a', true);
-  EXPECT_THAT(p, Pair(is_positive, _));
-  EXPECT_THAT(p, Not(Pair(is_negative, _)));
-  EXPECT_THAT(p, Pair(_, is_positive));
-  EXPECT_THAT(p, Not(Pair(_, is_negative)));
-}
-
-TEST(PairTest, InsideContainsUsingMap) {
-  map<int, char> container;
-  container.insert(make_pair(1, 'a'));
-  container.insert(make_pair(2, 'b'));
-  container.insert(make_pair(4, 'c'));
-  EXPECT_THAT(container, Contains(Pair(1, 'a')));
-  EXPECT_THAT(container, Contains(Pair(1, _)));
-  EXPECT_THAT(container, Contains(Pair(_, 'a')));
-  EXPECT_THAT(container, Not(Contains(Pair(3, _))));
-}
-
-TEST(FieldsAreTest, MatchesCorrectly) {
-  std::tuple<int, std::string, double> p(25, "foo", .5);
-
-  // All fields match.
-  EXPECT_THAT(p, FieldsAre(25, "foo", .5));
-  EXPECT_THAT(p, FieldsAre(Ge(20), HasSubstr("o"), DoubleEq(.5)));
-
-  // Some don't match.
-  EXPECT_THAT(p, Not(FieldsAre(26, "foo", .5)));
-  EXPECT_THAT(p, Not(FieldsAre(25, "fo", .5)));
-  EXPECT_THAT(p, Not(FieldsAre(25, "foo", .6)));
-}
-
-TEST(FieldsAreTest, CanDescribeSelf) {
-  Matcher<const pair<std::string, int>&> m1 = FieldsAre("foo", 42);
-  EXPECT_EQ(
-      "has field #0 that is equal to \"foo\""
-      ", and has field #1 that is equal to 42",
-      Describe(m1));
-  EXPECT_EQ(
-      "has field #0 that isn't equal to \"foo\""
-      ", or has field #1 that isn't equal to 42",
-      DescribeNegation(m1));
-}
-
-TEST(FieldsAreTest, CanExplainMatchResultTo) {
-  // The first one that fails is the one that gives the error.
-  Matcher<std::tuple<int, int, int>> m =
-      FieldsAre(GreaterThan(0), GreaterThan(0), GreaterThan(0));
-
-  EXPECT_EQ("whose field #0 does not match, which is 1 less than 0",
-            Explain(m, std::make_tuple(-1, -2, -3)));
-  EXPECT_EQ("whose field #1 does not match, which is 2 less than 0",
-            Explain(m, std::make_tuple(1, -2, -3)));
-  EXPECT_EQ("whose field #2 does not match, which is 3 less than 0",
-            Explain(m, std::make_tuple(1, 2, -3)));
-
-  // If they all match, we get a long explanation of success.
-  EXPECT_EQ(
-      "whose all elements match, "
-      "where field #0 is a value which is 1 more than 0"
-      ", and field #1 is a value which is 2 more than 0"
-      ", and field #2 is a value which is 3 more than 0",
-      Explain(m, std::make_tuple(1, 2, 3)));
-
-  // Only print those that have an explanation.
-  m = FieldsAre(GreaterThan(0), 0, GreaterThan(0));
-  EXPECT_EQ(
-      "whose all elements match, "
-      "where field #0 is a value which is 1 more than 0"
-      ", and field #2 is a value which is 3 more than 0",
-      Explain(m, std::make_tuple(1, 0, 3)));
-
-  // If only one has an explanation, then print that one.
-  m = FieldsAre(0, GreaterThan(0), 0);
-  EXPECT_EQ(
-      "whose all elements match, "
-      "where field #1 is a value which is 1 more than 0",
-      Explain(m, std::make_tuple(0, 1, 0)));
-}
-
-#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
-TEST(FieldsAreTest, StructuredBindings) {
-  // testing::FieldsAre can also match aggregates and such with C++17 and up.
-  struct MyType {
-    int i;
-    std::string str;
-  };
-  EXPECT_THAT((MyType{17, "foo"}), FieldsAre(Eq(17), HasSubstr("oo")));
-
-  // Test all the supported arities.
-  struct MyVarType1 {
-    int a;
-  };
-  EXPECT_THAT(MyVarType1{}, FieldsAre(0));
-  struct MyVarType2 {
-    int a, b;
-  };
-  EXPECT_THAT(MyVarType2{}, FieldsAre(0, 0));
-  struct MyVarType3 {
-    int a, b, c;
-  };
-  EXPECT_THAT(MyVarType3{}, FieldsAre(0, 0, 0));
-  struct MyVarType4 {
-    int a, b, c, d;
-  };
-  EXPECT_THAT(MyVarType4{}, FieldsAre(0, 0, 0, 0));
-  struct MyVarType5 {
-    int a, b, c, d, e;
-  };
-  EXPECT_THAT(MyVarType5{}, FieldsAre(0, 0, 0, 0, 0));
-  struct MyVarType6 {
-    int a, b, c, d, e, f;
-  };
-  EXPECT_THAT(MyVarType6{}, FieldsAre(0, 0, 0, 0, 0, 0));
-  struct MyVarType7 {
-    int a, b, c, d, e, f, g;
-  };
-  EXPECT_THAT(MyVarType7{}, FieldsAre(0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType8 {
-    int a, b, c, d, e, f, g, h;
-  };
-  EXPECT_THAT(MyVarType8{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType9 {
-    int a, b, c, d, e, f, g, h, i;
-  };
-  EXPECT_THAT(MyVarType9{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType10 {
-    int a, b, c, d, e, f, g, h, i, j;
-  };
-  EXPECT_THAT(MyVarType10{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType11 {
-    int a, b, c, d, e, f, g, h, i, j, k;
-  };
-  EXPECT_THAT(MyVarType11{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType12 {
-    int a, b, c, d, e, f, g, h, i, j, k, l;
-  };
-  EXPECT_THAT(MyVarType12{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType13 {
-    int a, b, c, d, e, f, g, h, i, j, k, l, m;
-  };
-  EXPECT_THAT(MyVarType13{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType14 {
-    int a, b, c, d, e, f, g, h, i, j, k, l, m, n;
-  };
-  EXPECT_THAT(MyVarType14{},
-              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType15 {
-    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o;
-  };
-  EXPECT_THAT(MyVarType15{},
-              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-  struct MyVarType16 {
-    int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
-  };
-  EXPECT_THAT(MyVarType16{},
-              FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-}
-#endif
-
-TEST(ContainsTest, WorksWithMoveOnly) {
-  ContainerHelper helper;
-  EXPECT_CALL(helper, Call(Contains(Pointee(2))));
-  helper.Call(MakeUniquePtrs({1, 2}));
-}
-
-TEST(PairTest, UseGetInsteadOfMembers) {
-  PairWithGet pair{7, "ABC"};
-  EXPECT_THAT(pair, Pair(7, "ABC"));
-  EXPECT_THAT(pair, Pair(Ge(7), HasSubstr("AB")));
-  EXPECT_THAT(pair, Not(Pair(Lt(7), "ABC")));
-
-  std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
-  EXPECT_THAT(v,
-              ElementsAre(Pair(11, std::string("Foo")), Pair(Ge(10), Not(""))));
-}
-
-// Tests StartsWith(s).
-
-TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
-  const Matcher<const char*> m1 = StartsWith(std::string(""));
-  EXPECT_TRUE(m1.Matches("Hi"));
-  EXPECT_TRUE(m1.Matches(""));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const std::string&> m2 = StartsWith("Hi");
-  EXPECT_TRUE(m2.Matches("Hi"));
-  EXPECT_TRUE(m2.Matches("Hi Hi!"));
-  EXPECT_TRUE(m2.Matches("High"));
-  EXPECT_FALSE(m2.Matches("H"));
-  EXPECT_FALSE(m2.Matches(" Hi"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  const Matcher<internal::StringView> m_empty =
-      StartsWith(internal::StringView(""));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(StartsWithTest, CanDescribeSelf) {
-  Matcher<const std::string> m = StartsWith("Hi");
-  EXPECT_EQ("starts with \"Hi\"", Describe(m));
-}
-
-// Tests EndsWith(s).
-
-TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
-  const Matcher<const char*> m1 = EndsWith("");
-  EXPECT_TRUE(m1.Matches("Hi"));
-  EXPECT_TRUE(m1.Matches(""));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const std::string&> m2 = EndsWith(std::string("Hi"));
-  EXPECT_TRUE(m2.Matches("Hi"));
-  EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
-  EXPECT_TRUE(m2.Matches("Super Hi"));
-  EXPECT_FALSE(m2.Matches("i"));
-  EXPECT_FALSE(m2.Matches("Hi "));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  const Matcher<const internal::StringView&> m4 =
-      EndsWith(internal::StringView(""));
-  EXPECT_TRUE(m4.Matches("Hi"));
-  EXPECT_TRUE(m4.Matches(""));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(EndsWithTest, CanDescribeSelf) {
-  Matcher<const std::string> m = EndsWith("Hi");
-  EXPECT_EQ("ends with \"Hi\"", Describe(m));
-}
-
-// Tests MatchesRegex().
-
-TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
-  const Matcher<const char*> m1 = MatchesRegex("a.*z");
-  EXPECT_TRUE(m1.Matches("az"));
-  EXPECT_TRUE(m1.Matches("abcz"));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z"));
-  EXPECT_TRUE(m2.Matches("azbz"));
-  EXPECT_FALSE(m2.Matches("az1"));
-  EXPECT_FALSE(m2.Matches("1az"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  const Matcher<const internal::StringView&> m3 = MatchesRegex("a.*z");
-  EXPECT_TRUE(m3.Matches(internal::StringView("az")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("1az")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
-  const Matcher<const internal::StringView&> m4 =
-      MatchesRegex(internal::StringView(""));
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(MatchesRegexTest, CanDescribeSelf) {
-  Matcher<const std::string> m1 = MatchesRegex(std::string("Hi.*"));
-  EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
-
-  Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
-  EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView> m3 = MatchesRegex(new RE("0.*"));
-  EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-// Tests ContainsRegex().
-
-TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
-  const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z"));
-  EXPECT_TRUE(m1.Matches("az"));
-  EXPECT_TRUE(m1.Matches("0abcz1"));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z"));
-  EXPECT_TRUE(m2.Matches("azbz"));
-  EXPECT_TRUE(m2.Matches("az1"));
-  EXPECT_FALSE(m2.Matches("1a"));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  const Matcher<const internal::StringView&> m3 =
-      ContainsRegex(new RE("a.*z"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("azbz")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("1a")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
-  const Matcher<const internal::StringView&> m4 =
-      ContainsRegex(internal::StringView(""));
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-TEST(ContainsRegexTest, CanDescribeSelf) {
-  Matcher<const std::string> m1 = ContainsRegex("Hi.*");
-  EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
-
-  Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
-  EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  Matcher<const internal::StringView> m3 = ContainsRegex(new RE("0.*"));
-  EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
-// Tests for wide strings.
-#if GTEST_HAS_STD_WSTRING
-TEST(StdWideStrEqTest, MatchesEqual) {
-  Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(nullptr));
-
-  Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"Hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-
-  Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
-  EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
-
-  ::std::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::std::wstring&> m4 = StrEq(str);
-  EXPECT_TRUE(m4.Matches(str));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::std::wstring&> m5 = StrEq(str);
-  EXPECT_TRUE(m5.Matches(str));
-}
-
-TEST(StdWideStrEqTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
-  EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
-    Describe(m));
-
-  Matcher< ::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
-  EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"",
-    Describe(m2));
-
-  ::std::wstring str(L"01204500800");
-  str[3] = L'\0';
-  Matcher<const ::std::wstring&> m4 = StrEq(str);
-  EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
-  str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
-  Matcher<const ::std::wstring&> m5 = StrEq(str);
-  EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
-}
-
-TEST(StdWideStrNeTest, MatchesUnequalString) {
-  Matcher<const wchar_t*> m = StrNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L""));
-  EXPECT_TRUE(m.Matches(nullptr));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-
-  Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(StdWideStrNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrNe(L"Hi");
-  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
-}
-
-TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"Hello"));
-  EXPECT_TRUE(m.Matches(L"hello"));
-  EXPECT_FALSE(m.Matches(L"Hi"));
-  EXPECT_FALSE(m.Matches(nullptr));
-
-  Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
-  EXPECT_TRUE(m2.Matches(L"hello"));
-  EXPECT_FALSE(m2.Matches(L"Hi"));
-}
-
-TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
-  ::std::wstring str1(L"oabocdooeoo");
-  ::std::wstring str2(L"OABOCDOOEOO");
-  Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
-  EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
-
-  str1[3] = str2[3] = L'\0';
-  Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
-  EXPECT_TRUE(m1.Matches(str2));
-
-  str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
-  str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
-  Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
-  str1[9] = str2[9] = L'\0';
-  EXPECT_FALSE(m2.Matches(str2));
-
-  Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
-  EXPECT_TRUE(m3.Matches(str2));
-
-  EXPECT_FALSE(m3.Matches(str2 + L"x"));
-  str2.append(1, L'\0');
-  EXPECT_FALSE(m3.Matches(str2));
-  EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
-}
-
-TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = StrCaseEq(L"Hi");
-  EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
-  EXPECT_TRUE(m.Matches(L"Hi"));
-  EXPECT_TRUE(m.Matches(nullptr));
-  EXPECT_FALSE(m.Matches(L"Hello"));
-  EXPECT_FALSE(m.Matches(L"hello"));
-
-  Matcher< ::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
-  EXPECT_TRUE(m2.Matches(L""));
-  EXPECT_FALSE(m2.Matches(L"Hello"));
-}
-
-TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
-  Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
-  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
-}
-
-// Tests that HasSubstr() works for matching wstring-typed values.
-TEST(StdWideHasSubstrTest, WorksForStringClasses) {
-  const Matcher< ::std::wstring> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
-
-  const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
-  EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
-}
-
-// Tests that HasSubstr() works for matching C-wide-string-typed values.
-TEST(StdWideHasSubstrTest, WorksForCStrings) {
-  const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
-  EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
-  EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
-  EXPECT_TRUE(m2.Matches(L"I love food."));
-  EXPECT_FALSE(m2.Matches(L"tofo"));
-  EXPECT_FALSE(m2.Matches(nullptr));
-}
-
-// Tests that HasSubstr(s) describes itself properly.
-TEST(StdWideHasSubstrTest, CanDescribeSelf) {
-  Matcher< ::std::wstring> m = HasSubstr(L"foo\n\"");
-  EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
-}
-
-// Tests StartsWith(s).
-
-TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
-  const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
-  EXPECT_TRUE(m2.Matches(L"High"));
-  EXPECT_FALSE(m2.Matches(L"H"));
-  EXPECT_FALSE(m2.Matches(L" Hi"));
-}
-
-TEST(StdWideStartsWithTest, CanDescribeSelf) {
-  Matcher<const ::std::wstring> m = StartsWith(L"Hi");
-  EXPECT_EQ("starts with L\"Hi\"", Describe(m));
-}
-
-// Tests EndsWith(s).
-
-TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
-  const Matcher<const wchar_t*> m1 = EndsWith(L"");
-  EXPECT_TRUE(m1.Matches(L"Hi"));
-  EXPECT_TRUE(m1.Matches(L""));
-  EXPECT_FALSE(m1.Matches(nullptr));
-
-  const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Hi"));
-  EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
-  EXPECT_TRUE(m2.Matches(L"Super Hi"));
-  EXPECT_FALSE(m2.Matches(L"i"));
-  EXPECT_FALSE(m2.Matches(L"Hi "));
-}
-
-TEST(StdWideEndsWithTest, CanDescribeSelf) {
-  Matcher<const ::std::wstring> m = EndsWith(L"Hi");
-  EXPECT_EQ("ends with L\"Hi\"", Describe(m));
-}
-
-#endif  // GTEST_HAS_STD_WSTRING
-
-typedef ::std::tuple<long, int> Tuple2;  // NOLINT
-
-// Tests that Eq() matches a 2-tuple where the first field == the
-// second field.
-TEST(Eq2Test, MatchesEqualArguments) {
-  Matcher<const Tuple2&> m = Eq();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Eq() describes itself properly.
-TEST(Eq2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Eq();
-  EXPECT_EQ("are an equal pair", Describe(m));
-}
-
-// Tests that Ge() matches a 2-tuple where the first field >= the
-// second field.
-TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
-  Matcher<const Tuple2&> m = Ge();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Ge() describes itself properly.
-TEST(Ge2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Ge();
-  EXPECT_EQ("are a pair where the first >= the second", Describe(m));
-}
-
-// Tests that Gt() matches a 2-tuple where the first field > the
-// second field.
-TEST(Gt2Test, MatchesGreaterThanArguments) {
-  Matcher<const Tuple2&> m = Gt();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
-}
-
-// Tests that Gt() describes itself properly.
-TEST(Gt2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Gt();
-  EXPECT_EQ("are a pair where the first > the second", Describe(m));
-}
-
-// Tests that Le() matches a 2-tuple where the first field <= the
-// second field.
-TEST(Le2Test, MatchesLessThanOrEqualArguments) {
-  Matcher<const Tuple2&> m = Le();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
-}
-
-// Tests that Le() describes itself properly.
-TEST(Le2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Le();
-  EXPECT_EQ("are a pair where the first <= the second", Describe(m));
-}
-
-// Tests that Lt() matches a 2-tuple where the first field < the
-// second field.
-TEST(Lt2Test, MatchesLessThanArguments) {
-  Matcher<const Tuple2&> m = Lt();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
-}
-
-// Tests that Lt() describes itself properly.
-TEST(Lt2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Lt();
-  EXPECT_EQ("are a pair where the first < the second", Describe(m));
-}
-
-// Tests that Ne() matches a 2-tuple where the first field != the
-// second field.
-TEST(Ne2Test, MatchesUnequalArguments) {
-  Matcher<const Tuple2&> m = Ne();
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
-  EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
-  EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
-}
-
-// Tests that Ne() describes itself properly.
-TEST(Ne2Test, CanDescribeSelf) {
-  Matcher<const Tuple2&> m = Ne();
-  EXPECT_EQ("are an unequal pair", Describe(m));
-}
-
-TEST(PairMatchBaseTest, WorksWithMoveOnly) {
-  using Pointers = std::tuple<std::unique_ptr<int>, std::unique_ptr<int>>;
-  Matcher<Pointers> matcher = Eq();
-  Pointers pointers;
-  // Tested values don't matter; the point is that matcher does not copy the
-  // matched values.
-  EXPECT_TRUE(matcher.Matches(pointers));
-}
-
-// Tests that IsNan() matches a NaN, with float.
-TEST(IsNan, FloatMatchesNan) {
-  float quiet_nan = std::numeric_limits<float>::quiet_NaN();
-  float other_nan = std::nanf("1");
-  float real_value = 1.0f;
-
-  Matcher<float> m = IsNan();
-  EXPECT_TRUE(m.Matches(quiet_nan));
-  EXPECT_TRUE(m.Matches(other_nan));
-  EXPECT_FALSE(m.Matches(real_value));
-
-  Matcher<float&> m_ref = IsNan();
-  EXPECT_TRUE(m_ref.Matches(quiet_nan));
-  EXPECT_TRUE(m_ref.Matches(other_nan));
-  EXPECT_FALSE(m_ref.Matches(real_value));
-
-  Matcher<const float&> m_cref = IsNan();
-  EXPECT_TRUE(m_cref.Matches(quiet_nan));
-  EXPECT_TRUE(m_cref.Matches(other_nan));
-  EXPECT_FALSE(m_cref.Matches(real_value));
-}
-
-// Tests that IsNan() matches a NaN, with double.
-TEST(IsNan, DoubleMatchesNan) {
-  double quiet_nan = std::numeric_limits<double>::quiet_NaN();
-  double other_nan = std::nan("1");
-  double real_value = 1.0;
-
-  Matcher<double> m = IsNan();
-  EXPECT_TRUE(m.Matches(quiet_nan));
-  EXPECT_TRUE(m.Matches(other_nan));
-  EXPECT_FALSE(m.Matches(real_value));
-
-  Matcher<double&> m_ref = IsNan();
-  EXPECT_TRUE(m_ref.Matches(quiet_nan));
-  EXPECT_TRUE(m_ref.Matches(other_nan));
-  EXPECT_FALSE(m_ref.Matches(real_value));
-
-  Matcher<const double&> m_cref = IsNan();
-  EXPECT_TRUE(m_cref.Matches(quiet_nan));
-  EXPECT_TRUE(m_cref.Matches(other_nan));
-  EXPECT_FALSE(m_cref.Matches(real_value));
-}
-
-// Tests that IsNan() matches a NaN, with long double.
-TEST(IsNan, LongDoubleMatchesNan) {
-  long double quiet_nan = std::numeric_limits<long double>::quiet_NaN();
-  long double other_nan = std::nan("1");
-  long double real_value = 1.0;
-
-  Matcher<long double> m = IsNan();
-  EXPECT_TRUE(m.Matches(quiet_nan));
-  EXPECT_TRUE(m.Matches(other_nan));
-  EXPECT_FALSE(m.Matches(real_value));
-
-  Matcher<long double&> m_ref = IsNan();
-  EXPECT_TRUE(m_ref.Matches(quiet_nan));
-  EXPECT_TRUE(m_ref.Matches(other_nan));
-  EXPECT_FALSE(m_ref.Matches(real_value));
-
-  Matcher<const long double&> m_cref = IsNan();
-  EXPECT_TRUE(m_cref.Matches(quiet_nan));
-  EXPECT_TRUE(m_cref.Matches(other_nan));
-  EXPECT_FALSE(m_cref.Matches(real_value));
-}
-
-// Tests that IsNan() works with Not.
-TEST(IsNan, NotMatchesNan) {
-  Matcher<float> mf = Not(IsNan());
-  EXPECT_FALSE(mf.Matches(std::numeric_limits<float>::quiet_NaN()));
-  EXPECT_FALSE(mf.Matches(std::nanf("1")));
-  EXPECT_TRUE(mf.Matches(1.0));
-
-  Matcher<double> md = Not(IsNan());
-  EXPECT_FALSE(md.Matches(std::numeric_limits<double>::quiet_NaN()));
-  EXPECT_FALSE(md.Matches(std::nan("1")));
-  EXPECT_TRUE(md.Matches(1.0));
-
-  Matcher<long double> mld = Not(IsNan());
-  EXPECT_FALSE(mld.Matches(std::numeric_limits<long double>::quiet_NaN()));
-  EXPECT_FALSE(mld.Matches(std::nanl("1")));
-  EXPECT_TRUE(mld.Matches(1.0));
-}
-
-// Tests that IsNan() can describe itself.
-TEST(IsNan, CanDescribeSelf) {
-  Matcher<float> mf = IsNan();
-  EXPECT_EQ("is NaN", Describe(mf));
-
-  Matcher<double> md = IsNan();
-  EXPECT_EQ("is NaN", Describe(md));
-
-  Matcher<long double> mld = IsNan();
-  EXPECT_EQ("is NaN", Describe(mld));
-}
-
-// Tests that IsNan() can describe itself with Not.
-TEST(IsNan, CanDescribeSelfWithNot) {
-  Matcher<float> mf = Not(IsNan());
-  EXPECT_EQ("isn't NaN", Describe(mf));
-
-  Matcher<double> md = Not(IsNan());
-  EXPECT_EQ("isn't NaN", Describe(md));
-
-  Matcher<long double> mld = Not(IsNan());
-  EXPECT_EQ("isn't NaN", Describe(mld));
-}
-
-// Tests that FloatEq() matches a 2-tuple where
-// FloatEq(first field) matches the second field.
-TEST(FloatEq2Test, MatchesEqualArguments) {
-  typedef ::std::tuple<float, float> Tpl;
-  Matcher<const Tpl&> m = FloatEq();
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(0.3f, 0.1f + 0.1f + 0.1f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
-}
-
-// Tests that FloatEq() describes itself properly.
-TEST(FloatEq2Test, CanDescribeSelf) {
-  Matcher<const ::std::tuple<float, float>&> m = FloatEq();
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that NanSensitiveFloatEq() matches a 2-tuple where
-// NanSensitiveFloatEq(first field) matches the second field.
-TEST(NanSensitiveFloatEqTest, MatchesEqualArgumentsWithNaN) {
-  typedef ::std::tuple<float, float> Tpl;
-  Matcher<const Tpl&> m = NanSensitiveFloatEq();
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
-                            std::numeric_limits<float>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
-}
-
-// Tests that NanSensitiveFloatEq() describes itself properly.
-TEST(NanSensitiveFloatEqTest, CanDescribeSelfWithNaNs) {
-  Matcher<const ::std::tuple<float, float>&> m = NanSensitiveFloatEq();
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that DoubleEq() matches a 2-tuple where
-// DoubleEq(first field) matches the second field.
-TEST(DoubleEq2Test, MatchesEqualArguments) {
-  typedef ::std::tuple<double, double> Tpl;
-  Matcher<const Tpl&> m = DoubleEq();
-  EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
-  EXPECT_TRUE(m.Matches(Tpl(0.3, 0.1 + 0.1 + 0.1)));
-  EXPECT_FALSE(m.Matches(Tpl(1.1, 1.0)));
-}
-
-// Tests that DoubleEq() describes itself properly.
-TEST(DoubleEq2Test, CanDescribeSelf) {
-  Matcher<const ::std::tuple<double, double>&> m = DoubleEq();
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that NanSensitiveDoubleEq() matches a 2-tuple where
-// NanSensitiveDoubleEq(first field) matches the second field.
-TEST(NanSensitiveDoubleEqTest, MatchesEqualArgumentsWithNaN) {
-  typedef ::std::tuple<double, double> Tpl;
-  Matcher<const Tpl&> m = NanSensitiveDoubleEq();
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
-                            std::numeric_limits<double>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(1.1f, 1.0f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
-}
-
-// Tests that DoubleEq() describes itself properly.
-TEST(NanSensitiveDoubleEqTest, CanDescribeSelfWithNaNs) {
-  Matcher<const ::std::tuple<double, double>&> m = NanSensitiveDoubleEq();
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that FloatEq() matches a 2-tuple where
-// FloatNear(first field, max_abs_error) matches the second field.
-TEST(FloatNear2Test, MatchesEqualArguments) {
-  typedef ::std::tuple<float, float> Tpl;
-  Matcher<const Tpl&> m = FloatNear(0.5f);
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(1.3f, 1.0f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.8f, 1.0f)));
-}
-
-// Tests that FloatNear() describes itself properly.
-TEST(FloatNear2Test, CanDescribeSelf) {
-  Matcher<const ::std::tuple<float, float>&> m = FloatNear(0.5f);
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that NanSensitiveFloatNear() matches a 2-tuple where
-// NanSensitiveFloatNear(first field) matches the second field.
-TEST(NanSensitiveFloatNearTest, MatchesNearbyArgumentsWithNaN) {
-  typedef ::std::tuple<float, float> Tpl;
-  Matcher<const Tpl&> m = NanSensitiveFloatNear(0.5f);
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(),
-                            std::numeric_limits<float>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<float>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<float>::quiet_NaN(), 1.0f)));
-}
-
-// Tests that NanSensitiveFloatNear() describes itself properly.
-TEST(NanSensitiveFloatNearTest, CanDescribeSelfWithNaNs) {
-  Matcher<const ::std::tuple<float, float>&> m = NanSensitiveFloatNear(0.5f);
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that FloatEq() matches a 2-tuple where
-// DoubleNear(first field, max_abs_error) matches the second field.
-TEST(DoubleNear2Test, MatchesEqualArguments) {
-  typedef ::std::tuple<double, double> Tpl;
-  Matcher<const Tpl&> m = DoubleNear(0.5);
-  EXPECT_TRUE(m.Matches(Tpl(1.0, 1.0)));
-  EXPECT_TRUE(m.Matches(Tpl(1.3, 1.0)));
-  EXPECT_FALSE(m.Matches(Tpl(1.8, 1.0)));
-}
-
-// Tests that DoubleNear() describes itself properly.
-TEST(DoubleNear2Test, CanDescribeSelf) {
-  Matcher<const ::std::tuple<double, double>&> m = DoubleNear(0.5);
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that NanSensitiveDoubleNear() matches a 2-tuple where
-// NanSensitiveDoubleNear(first field) matches the second field.
-TEST(NanSensitiveDoubleNearTest, MatchesNearbyArgumentsWithNaN) {
-  typedef ::std::tuple<double, double> Tpl;
-  Matcher<const Tpl&> m = NanSensitiveDoubleNear(0.5f);
-  EXPECT_TRUE(m.Matches(Tpl(1.0f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(1.1f, 1.0f)));
-  EXPECT_TRUE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(),
-                            std::numeric_limits<double>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(1.6f, 1.0f)));
-  EXPECT_FALSE(m.Matches(Tpl(1.0f, std::numeric_limits<double>::quiet_NaN())));
-  EXPECT_FALSE(m.Matches(Tpl(std::numeric_limits<double>::quiet_NaN(), 1.0f)));
-}
-
-// Tests that NanSensitiveDoubleNear() describes itself properly.
-TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
-  Matcher<const ::std::tuple<double, double>&> m = NanSensitiveDoubleNear(0.5f);
-  EXPECT_EQ("are an almost-equal pair", Describe(m));
-}
-
-// Tests that Not(m) matches any value that doesn't match m.
-TEST(NotTest, NegatesMatcher) {
-  Matcher<int> m;
-  m = Not(Eq(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-}
-
-// Tests that Not(m) describes itself properly.
-TEST(NotTest, CanDescribeSelf) {
-  Matcher<int> m = Not(Eq(5));
-  EXPECT_EQ("isn't equal to 5", Describe(m));
-}
-
-// Tests that monomorphic matchers are safely cast by the Not matcher.
-TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 is a monomorphic matcher.
-  Matcher<int> greater_than_5 = Gt(5);
-
-  Matcher<const int&> m = Not(greater_than_5);
-  Matcher<int&> m2 = Not(greater_than_5);
-  Matcher<int&> m3 = Not(m);
-}
-
-// Helper to allow easy testing of AllOf matchers with num parameters.
-void AllOfMatches(int num, const Matcher<int>& m) {
-  SCOPED_TRACE(Describe(m));
-  EXPECT_TRUE(m.Matches(0));
-  for (int i = 1; i <= num; ++i) {
-    EXPECT_FALSE(m.Matches(i));
-  }
-  EXPECT_TRUE(m.Matches(num + 1));
-}
-
-// Tests that AllOf(m1, ..., mn) matches any value that matches all of
-// the given matchers.
-TEST(AllOfTest, MatchesWhenAllMatch) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(0));
-  EXPECT_FALSE(m.Matches(3));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  EXPECT_TRUE(m.Matches(0));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(3));
-
-  // The following tests for varying number of sub-matchers. Due to the way
-  // the sub-matchers are handled it is enough to test every sub-matcher once
-  // with sub-matchers using the same matcher type. Varying matcher types are
-  // checked for above.
-  AllOfMatches(2, AllOf(Ne(1), Ne(2)));
-  AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
-  AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
-  AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
-  AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
-  AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
-  AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
-                        Ne(8)));
-  AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
-                        Ne(8), Ne(9)));
-  AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
-                         Ne(9), Ne(10)));
-  AllOfMatches(
-      50, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9),
-                Ne(10), Ne(11), Ne(12), Ne(13), Ne(14), Ne(15), Ne(16), Ne(17),
-                Ne(18), Ne(19), Ne(20), Ne(21), Ne(22), Ne(23), Ne(24), Ne(25),
-                Ne(26), Ne(27), Ne(28), Ne(29), Ne(30), Ne(31), Ne(32), Ne(33),
-                Ne(34), Ne(35), Ne(36), Ne(37), Ne(38), Ne(39), Ne(40), Ne(41),
-                Ne(42), Ne(43), Ne(44), Ne(45), Ne(46), Ne(47), Ne(48), Ne(49),
-                Ne(50)));
-}
-
-
-// Tests that AllOf(m1, ..., mn) describes itself properly.
-TEST(AllOfTest, CanDescribeSelf) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  std::string expected_descr1 =
-      "(is > 0) and (isn't equal to 1) and (isn't equal to 2)";
-  EXPECT_EQ(expected_descr1, Describe(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  std::string expected_descr2 =
-      "(is > 0) and (isn't equal to 1) and (isn't equal to 2) and (isn't equal "
-      "to 3)";
-  EXPECT_EQ(expected_descr2, Describe(m));
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  std::string expected_descr3 =
-      "(is >= 0) and (is < 10) and (isn't equal to 3) and (isn't equal to 5) "
-      "and (isn't equal to 7)";
-  EXPECT_EQ(expected_descr3, Describe(m));
-}
-
-// Tests that AllOf(m1, ..., mn) describes its negation properly.
-TEST(AllOfTest, CanDescribeNegation) {
-  Matcher<int> m;
-  m = AllOf(Le(2), Ge(1));
-  std::string expected_descr4 = "(isn't <= 2) or (isn't >= 1)";
-  EXPECT_EQ(expected_descr4, DescribeNegation(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2));
-  std::string expected_descr5 =
-      "(isn't > 0) or (is equal to 1) or (is equal to 2)";
-  EXPECT_EQ(expected_descr5, DescribeNegation(m));
-
-  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  std::string expected_descr6 =
-      "(isn't > 0) or (is equal to 1) or (is equal to 2) or (is equal to 3)";
-  EXPECT_EQ(expected_descr6, DescribeNegation(m));
-
-  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  std::string expected_desr7 =
-      "(isn't >= 0) or (isn't < 10) or (is equal to 3) or (is equal to 5) or "
-      "(is equal to 7)";
-  EXPECT_EQ(expected_desr7, DescribeNegation(m));
-
-  m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9),
-            Ne(10), Ne(11));
-  AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
-  EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11)"));
-  AllOfMatches(11, m);
-}
-
-// Tests that monomorphic matchers are safely cast by the AllOf matcher.
-TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 and less_than_10 are monomorphic matchers.
-  Matcher<int> greater_than_5 = Gt(5);
-  Matcher<int> less_than_10 = Lt(10);
-
-  Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
-  Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
-  Matcher<int&> m3 = AllOf(greater_than_5, m2);
-
-  // Tests that BothOf works when composing itself.
-  Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
-  Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
-}
-
-TEST(AllOfTest, ExplainsResult) {
-  Matcher<int> m;
-
-  // Successful match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so only the first matcher's
-  // explanation is printed.
-  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
-
-  // Successful match.  Both matchers need to explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
-            Explain(m, 30));
-
-  // Successful match.  All matchers need to explain.  The second
-  // matcher doesn't given an explanation.
-  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
-  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
-            Explain(m, 25));
-
-  // Successful match.  All matchers need to explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
-  EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
-            "and which is 10 more than 30",
-            Explain(m, 40));
-
-  // Failed match.  The first matcher, which failed, needs to
-  // explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
-
-  // Failed match.  The second matcher, which failed, needs to
-  // explain.  Since it doesn't given an explanation, nothing is
-  // printed.
-  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("", Explain(m, 40));
-
-  // Failed match.  The second matcher, which failed, needs to
-  // explain.
-  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
-}
-
-// Helper to allow easy testing of AnyOf matchers with num parameters.
-static void AnyOfMatches(int num, const Matcher<int>& m) {
-  SCOPED_TRACE(Describe(m));
-  EXPECT_FALSE(m.Matches(0));
-  for (int i = 1; i <= num; ++i) {
-    EXPECT_TRUE(m.Matches(i));
-  }
-  EXPECT_FALSE(m.Matches(num + 1));
-}
-
-static void AnyOfStringMatches(int num, const Matcher<std::string>& m) {
-  SCOPED_TRACE(Describe(m));
-  EXPECT_FALSE(m.Matches(std::to_string(0)));
-
-  for (int i = 1; i <= num; ++i) {
-    EXPECT_TRUE(m.Matches(std::to_string(i)));
-  }
-  EXPECT_FALSE(m.Matches(std::to_string(num + 1)));
-}
-
-// Tests that AnyOf(m1, ..., mn) matches any value that matches at
-// least one of the given matchers.
-TEST(AnyOfTest, MatchesWhenAnyMatches) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(4));
-  EXPECT_FALSE(m.Matches(2));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_TRUE(m.Matches(-1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_TRUE(m.Matches(-1));
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_TRUE(m.Matches(2));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(0));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_TRUE(m.Matches(0));
-  EXPECT_TRUE(m.Matches(11));
-  EXPECT_TRUE(m.Matches(3));
-  EXPECT_FALSE(m.Matches(2));
-
-  // The following tests for varying number of sub-matchers. Due to the way
-  // the sub-matchers are handled it is enough to test every sub-matcher once
-  // with sub-matchers using the same matcher type. Varying matcher types are
-  // checked for above.
-  AnyOfMatches(2, AnyOf(1, 2));
-  AnyOfMatches(3, AnyOf(1, 2, 3));
-  AnyOfMatches(4, AnyOf(1, 2, 3, 4));
-  AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
-  AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
-  AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
-  AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
-  AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
-  AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-}
-
-// Tests the variadic version of the AnyOfMatcher.
-TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
-  // Also make sure AnyOf is defined in the right namespace and does not depend
-  // on ADL.
-  Matcher<int> m = ::testing::AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
-
-  EXPECT_THAT(Describe(m), EndsWith("or (is equal to 11)"));
-  AnyOfMatches(11, m);
-  AnyOfMatches(50, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-                         11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-                         21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-                         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-                         41, 42, 43, 44, 45, 46, 47, 48, 49, 50));
-  AnyOfStringMatches(
-      50, AnyOf("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
-                "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
-                "23", "24", "25", "26", "27", "28", "29", "30", "31", "32",
-                "33", "34", "35", "36", "37", "38", "39", "40", "41", "42",
-                "43", "44", "45", "46", "47", "48", "49", "50"));
-}
-
-// Tests the variadic version of the ElementsAreMatcher
-TEST(ElementsAreTest, HugeMatcher) {
-  vector<int> test_vector{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-
-  EXPECT_THAT(test_vector,
-              ElementsAre(Eq(1), Eq(2), Lt(13), Eq(4), Eq(5), Eq(6), Eq(7),
-                          Eq(8), Eq(9), Eq(10), Gt(1), Eq(12)));
-}
-
-// Tests the variadic version of the UnorderedElementsAreMatcher
-TEST(ElementsAreTest, HugeMatcherStr) {
-  vector<std::string> test_vector{
-      "literal_string", "", "", "", "", "", "", "", "", "", "", ""};
-
-  EXPECT_THAT(test_vector, UnorderedElementsAre("literal_string", _, _, _, _, _,
-                                                _, _, _, _, _, _));
-}
-
-// Tests the variadic version of the UnorderedElementsAreMatcher
-TEST(ElementsAreTest, HugeMatcherUnordered) {
-  vector<int> test_vector{2, 1, 8, 5, 4, 6, 7, 3, 9, 12, 11, 10};
-
-  EXPECT_THAT(test_vector, UnorderedElementsAre(
-                               Eq(2), Eq(1), Gt(7), Eq(5), Eq(4), Eq(6), Eq(7),
-                               Eq(3), Eq(9), Eq(12), Eq(11), Ne(122)));
-}
-
-
-// Tests that AnyOf(m1, ..., mn) describes itself properly.
-TEST(AnyOfTest, CanDescribeSelf) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-
-  EXPECT_EQ("(is <= 1) or (is >= 3)",
-            Describe(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_EQ("(is < 0) or (is equal to 1) or (is equal to 2)", Describe(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_EQ("(is < 0) or (is equal to 1) or (is equal to 2) or (is equal to 3)",
-            Describe(m));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_EQ(
-      "(is <= 0) or (is > 10) or (is equal to 3) or (is equal to 5) or (is "
-      "equal to 7)",
-      Describe(m));
-}
-
-// Tests that AnyOf(m1, ..., mn) describes its negation properly.
-TEST(AnyOfTest, CanDescribeNegation) {
-  Matcher<int> m;
-  m = AnyOf(Le(1), Ge(3));
-  EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
-            DescribeNegation(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_EQ("(isn't < 0) and (isn't equal to 1) and (isn't equal to 2)",
-            DescribeNegation(m));
-
-  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_EQ(
-      "(isn't < 0) and (isn't equal to 1) and (isn't equal to 2) and (isn't "
-      "equal to 3)",
-      DescribeNegation(m));
-
-  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_EQ(
-      "(isn't <= 0) and (isn't > 10) and (isn't equal to 3) and (isn't equal "
-      "to 5) and (isn't equal to 7)",
-      DescribeNegation(m));
-}
-
-// Tests that monomorphic matchers are safely cast by the AnyOf matcher.
-TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
-  // greater_than_5 and less_than_10 are monomorphic matchers.
-  Matcher<int> greater_than_5 = Gt(5);
-  Matcher<int> less_than_10 = Lt(10);
-
-  Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
-  Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
-  Matcher<int&> m3 = AnyOf(greater_than_5, m2);
-
-  // Tests that EitherOf works when composing itself.
-  Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
-  Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
-}
-
-TEST(AnyOfTest, ExplainsResult) {
-  Matcher<int> m;
-
-  // Failed match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so only the first matcher's
-  // explanation is printed.
-  m = AnyOf(GreaterThan(10), Lt(0));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
-
-  // Failed match.  Both matchers need to explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
-            Explain(m, 5));
-
-  // Failed match.  All matchers need to explain.  The second
-  // matcher doesn't given an explanation.
-  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
-  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
-            Explain(m, 5));
-
-  // Failed match.  All matchers need to explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
-  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
-            "and which is 25 less than 30",
-            Explain(m, 5));
-
-  // Successful match.  The first matcher, which succeeded, needs to
-  // explain.
-  m = AnyOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
-
-  // Successful match.  The second matcher, which succeeded, needs to
-  // explain.  Since it doesn't given an explanation, nothing is
-  // printed.
-  m = AnyOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("", Explain(m, 0));
-
-  // Successful match.  The second matcher, which succeeded, needs to
-  // explain.
-  m = AnyOf(GreaterThan(30), GreaterThan(20));
-  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
-}
-
-// The following predicate function and predicate functor are for
-// testing the Truly(predicate) matcher.
-
-// Returns non-zero if the input is positive.  Note that the return
-// type of this function is not bool.  It's OK as Truly() accepts any
-// unary function or functor whose return type can be implicitly
-// converted to bool.
-int IsPositive(double x) {
-  return x > 0 ? 1 : 0;
-}
-
-// This functor returns true if the input is greater than the given
-// number.
-class IsGreaterThan {
- public:
-  explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
-
-  bool operator()(int n) const { return n > threshold_; }
-
- private:
-  int threshold_;
-};
-
-// For testing Truly().
-const int foo = 0;
-
-// This predicate returns true if and only if the argument references foo and
-// has a zero value.
-bool ReferencesFooAndIsZero(const int& n) {
-  return (&n == &foo) && (n == 0);
-}
-
-// Tests that Truly(predicate) matches what satisfies the given
-// predicate.
-TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
-  Matcher<double> m = Truly(IsPositive);
-  EXPECT_TRUE(m.Matches(2.0));
-  EXPECT_FALSE(m.Matches(-1.5));
-}
-
-// Tests that Truly(predicate_functor) works too.
-TEST(TrulyTest, CanBeUsedWithFunctor) {
-  Matcher<int> m = Truly(IsGreaterThan(5));
-  EXPECT_TRUE(m.Matches(6));
-  EXPECT_FALSE(m.Matches(4));
-}
-
-// A class that can be implicitly converted to bool.
-class ConvertibleToBool {
- public:
-  explicit ConvertibleToBool(int number) : number_(number) {}
-  operator bool() const { return number_ != 0; }
-
- private:
-  int number_;
-};
-
-ConvertibleToBool IsNotZero(int number) {
-  return ConvertibleToBool(number);
-}
-
-// Tests that the predicate used in Truly() may return a class that's
-// implicitly convertible to bool, even when the class has no
-// operator!().
-TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
-  Matcher<int> m = Truly(IsNotZero);
-  EXPECT_TRUE(m.Matches(1));
-  EXPECT_FALSE(m.Matches(0));
-}
-
-// Tests that Truly(predicate) can describe itself properly.
-TEST(TrulyTest, CanDescribeSelf) {
-  Matcher<double> m = Truly(IsPositive);
-  EXPECT_EQ("satisfies the given predicate",
-            Describe(m));
-}
-
-// Tests that Truly(predicate) works when the matcher takes its
-// argument by reference.
-TEST(TrulyTest, WorksForByRefArguments) {
-  Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
-  EXPECT_TRUE(m.Matches(foo));
-  int n = 0;
-  EXPECT_FALSE(m.Matches(n));
-}
-
-// Tests that Truly(predicate) provides a helpful reason when it fails.
-TEST(TrulyTest, ExplainsFailures) {
-  StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(Truly(IsPositive), -1, &listener));
-  EXPECT_EQ(listener.str(), "didn't satisfy the given predicate");
-}
-
-// Tests that Matches(m) is a predicate satisfied by whatever that
-// matches matcher m.
-TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
-  EXPECT_TRUE(Matches(Ge(0))(1));
-  EXPECT_FALSE(Matches(Eq('a'))('b'));
-}
-
-// Tests that Matches(m) works when the matcher takes its argument by
-// reference.
-TEST(MatchesTest, WorksOnByRefArguments) {
-  int m = 0, n = 0;
-  EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
-  EXPECT_FALSE(Matches(Ref(m))(n));
-}
-
-// Tests that a Matcher on non-reference type can be used in
-// Matches().
-TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
-  Matcher<int> eq5 = Eq(5);
-  EXPECT_TRUE(Matches(eq5)(5));
-  EXPECT_FALSE(Matches(eq5)(2));
-}
-
-// Tests Value(value, matcher).  Since Value() is a simple wrapper for
-// Matches(), which has been tested already, we don't spend a lot of
-// effort on testing Value().
-TEST(ValueTest, WorksWithPolymorphicMatcher) {
-  EXPECT_TRUE(Value("hi", StartsWith("h")));
-  EXPECT_FALSE(Value(5, Gt(10)));
-}
-
-TEST(ValueTest, WorksWithMonomorphicMatcher) {
-  const Matcher<int> is_zero = Eq(0);
-  EXPECT_TRUE(Value(0, is_zero));
-  EXPECT_FALSE(Value('a', is_zero));
-
-  int n = 0;
-  const Matcher<const int&> ref_n = Ref(n);
-  EXPECT_TRUE(Value(n, ref_n));
-  EXPECT_FALSE(Value(1, ref_n));
-}
-
-TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
-  EXPECT_EQ("% 2 == 0", listener1.str());
-
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
-  EXPECT_EQ("", listener2.str());
-}
-
-TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
-  const Matcher<int> is_even = PolymorphicIsEven();
-  StringMatchResultListener listener1;
-  EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
-  EXPECT_EQ("% 2 == 0", listener1.str());
-
-  const Matcher<const double&> is_zero = Eq(0);
-  StringMatchResultListener listener2;
-  EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
-  EXPECT_EQ("", listener2.str());
-}
-
-MATCHER(ConstructNoArg, "") { return true; }
-MATCHER_P(Construct1Arg, arg1, "") { return true; }
-MATCHER_P2(Construct2Args, arg1, arg2, "") { return true; }
+// Silence warning C4244: 'initializing': conversion from 'int' to 'short',
+// possible loss of data and C4100, unreferenced local parameter
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4100)
+#endif
 
-TEST(MatcherConstruct, ExplicitVsImplicit) {
-  {
-    // No arg constructor can be constructed with empty brace.
-    ConstructNoArgMatcher m = {};
-    (void)m;
-    // And with no args
-    ConstructNoArgMatcher m2;
-    (void)m2;
-  }
-  {
-    // The one arg constructor has an explicit constructor.
-    // This is to prevent the implicit conversion.
-    using M = Construct1ArgMatcherP<int>;
-    EXPECT_TRUE((std::is_constructible<M, int>::value));
-    EXPECT_FALSE((std::is_convertible<int, M>::value));
-  }
-  {
-    // Multiple arg matchers can be constructed with an implicit construction.
-    Construct2ArgsMatcherP2<int, double> m = {1, 2.2};
-    (void)m;
-  }
-}
+#include "test/gmock-matchers_test.h"
 
-MATCHER_P(Really, inner_matcher, "") {
-  return ExplainMatchResult(inner_matcher, arg, result_listener);
-}
+namespace testing {
+namespace gmock_matchers_test {
+namespace {
 
-TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
-  EXPECT_THAT(0, Really(Eq(0)));
+std::vector<std::unique_ptr<int>> MakeUniquePtrs(const std::vector<int>& ints) {
+  std::vector<std::unique_ptr<int>> pointers;
+  for (int i : ints) pointers.emplace_back(new int(i));
+  return pointers;
 }
 
-TEST(DescribeMatcherTest, WorksWithValue) {
-  EXPECT_EQ("is equal to 42", DescribeMatcher<int>(42));
-  EXPECT_EQ("isn't equal to 42", DescribeMatcher<int>(42, true));
+std::string OfType(const std::string& type_name) {
+#if GTEST_HAS_RTTI
+  return IsReadableTypeName(type_name) ? " (of type " + type_name + ")" : "";
+#else
+  return "";
+#endif
 }
 
-TEST(DescribeMatcherTest, WorksWithMonomorphicMatcher) {
-  const Matcher<int> monomorphic = Le(0);
-  EXPECT_EQ("is <= 0", DescribeMatcher<int>(monomorphic));
-  EXPECT_EQ("isn't <= 0", DescribeMatcher<int>(monomorphic, true));
+TEST(ContainsTest, WorksWithMoveOnly) {
+  ContainerHelper helper;
+  EXPECT_CALL(helper, Call(Contains(Pointee(2))));
+  helper.Call(MakeUniquePtrs({1, 2}));
 }
 
-TEST(DescribeMatcherTest, WorksWithPolymorphicMatcher) {
-  EXPECT_EQ("is even", DescribeMatcher<int>(PolymorphicIsEven()));
-  EXPECT_EQ("is odd", DescribeMatcher<int>(PolymorphicIsEven(), true));
-}
+INSTANTIATE_GTEST_MATCHER_TEST_P(ElementsAreTest);
 
-TEST(AllArgsTest, WorksForTuple) {
-  EXPECT_THAT(std::make_tuple(1, 2L), AllArgs(Lt()));
-  EXPECT_THAT(std::make_tuple(2L, 1), Not(AllArgs(Lt())));
-}
+// Tests the variadic version of the ElementsAreMatcher
+TEST(ElementsAreTest, HugeMatcher) {
+  vector<int> test_vector{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
-TEST(AllArgsTest, WorksForNonTuple) {
-  EXPECT_THAT(42, AllArgs(Gt(0)));
-  EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
+  EXPECT_THAT(test_vector,
+              ElementsAre(Eq(1), Eq(2), Lt(13), Eq(4), Eq(5), Eq(6), Eq(7),
+                          Eq(8), Eq(9), Eq(10), Gt(1), Eq(12)));
 }
 
-class AllArgsHelper {
- public:
-  AllArgsHelper() {}
-
-  MOCK_METHOD2(Helper, int(char x, int y));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
-};
-
-TEST(AllArgsTest, WorksInWithClause) {
-  AllArgsHelper helper;
-  ON_CALL(helper, Helper(_, _))
-      .With(AllArgs(Lt()))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(helper, Helper(_, _));
-  EXPECT_CALL(helper, Helper(_, _))
-      .With(AllArgs(Gt()))
-      .WillOnce(Return(2));
+// Tests the variadic version of the UnorderedElementsAreMatcher
+TEST(ElementsAreTest, HugeMatcherStr) {
+  vector<std::string> test_vector{
+      "literal_string", "", "", "", "", "", "", "", "", "", "", ""};
 
-  EXPECT_EQ(1, helper.Helper('\1', 2));
-  EXPECT_EQ(2, helper.Helper('a', 1));
+  EXPECT_THAT(test_vector, UnorderedElementsAre("literal_string", _, _, _, _, _,
+                                                _, _, _, _, _, _));
 }
 
-class OptionalMatchersHelper {
- public:
-  OptionalMatchersHelper() {}
-
-  MOCK_METHOD0(NoArgs, int());
-
-  MOCK_METHOD1(OneArg, int(int y));
-
-  MOCK_METHOD2(TwoArgs, int(char x, int y));
-
-  MOCK_METHOD1(Overloaded, int(char x));
-  MOCK_METHOD2(Overloaded, int(char x, int y));
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OptionalMatchersHelper);
-};
-
-TEST(AllArgsTest, WorksWithoutMatchers) {
-  OptionalMatchersHelper helper;
-
-  ON_CALL(helper, NoArgs).WillByDefault(Return(10));
-  ON_CALL(helper, OneArg).WillByDefault(Return(20));
-  ON_CALL(helper, TwoArgs).WillByDefault(Return(30));
-
-  EXPECT_EQ(10, helper.NoArgs());
-  EXPECT_EQ(20, helper.OneArg(1));
-  EXPECT_EQ(30, helper.TwoArgs('\1', 2));
-
-  EXPECT_CALL(helper, NoArgs).Times(1);
-  EXPECT_CALL(helper, OneArg).WillOnce(Return(100));
-  EXPECT_CALL(helper, OneArg(17)).WillOnce(Return(200));
-  EXPECT_CALL(helper, TwoArgs).Times(0);
+// Tests the variadic version of the UnorderedElementsAreMatcher
+TEST(ElementsAreTest, HugeMatcherUnordered) {
+  vector<int> test_vector{2, 1, 8, 5, 4, 6, 7, 3, 9, 12, 11, 10};
 
-  EXPECT_EQ(10, helper.NoArgs());
-  EXPECT_EQ(100, helper.OneArg(1));
-  EXPECT_EQ(200, helper.OneArg(17));
+  EXPECT_THAT(test_vector, UnorderedElementsAre(
+                               Eq(2), Eq(1), Gt(7), Eq(5), Eq(4), Eq(6), Eq(7),
+                               Eq(3), Eq(9), Eq(12), Eq(11), Ne(122)));
 }
 
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value
@@ -3203,13 +114,14 @@ TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, Gt(10)),
                        "Value of: n\n"
                        "Expected: is > 10\n"
-                       "  Actual: 5" + OfType("unsigned short"));
+                       "  Actual: 5" +
+                           OfType("unsigned short"));
   n = 0;
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_THAT(n, AllOf(Le(7), Ge(5))),
-      "Value of: n\n"
-      "Expected: (is <= 7) and (is >= 5)\n"
-      "  Actual: 0" + OfType("unsigned short"));
+  EXPECT_NONFATAL_FAILURE(EXPECT_THAT(n, AllOf(Le(7), Ge(5))),
+                          "Value of: n\n"
+                          "Expected: (is <= 7) and (is >= 5)\n"
+                          "  Actual: 0" +
+                              OfType("unsigned short"));
 }
 
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
@@ -3245,445 +157,8 @@ TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
   EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
                           "Value of: 5\n"
                           "Expected: is > 5\n"
-                          "  Actual: 5" + OfType("int"));
-}
-
-// Tests floating-point matchers.
-template <typename RawType>
-class FloatingPointTest : public testing::Test {
- protected:
-  typedef testing::internal::FloatingPoint<RawType> Floating;
-  typedef typename Floating::Bits Bits;
-
-  FloatingPointTest()
-      : max_ulps_(Floating::kMaxUlps),
-        zero_bits_(Floating(0).bits()),
-        one_bits_(Floating(1).bits()),
-        infinity_bits_(Floating(Floating::Infinity()).bits()),
-        close_to_positive_zero_(
-            Floating::ReinterpretBits(zero_bits_ + max_ulps_/2)),
-        close_to_negative_zero_(
-            -Floating::ReinterpretBits(zero_bits_ + max_ulps_ - max_ulps_/2)),
-        further_from_negative_zero_(-Floating::ReinterpretBits(
-            zero_bits_ + max_ulps_ + 1 - max_ulps_/2)),
-        close_to_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_)),
-        further_from_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_ + 1)),
-        infinity_(Floating::Infinity()),
-        close_to_infinity_(
-            Floating::ReinterpretBits(infinity_bits_ - max_ulps_)),
-        further_from_infinity_(
-            Floating::ReinterpretBits(infinity_bits_ - max_ulps_ - 1)),
-        max_(Floating::Max()),
-        nan1_(Floating::ReinterpretBits(Floating::kExponentBitMask | 1)),
-        nan2_(Floating::ReinterpretBits(Floating::kExponentBitMask | 200)) {
-  }
-
-  void TestSize() {
-    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
-  }
-
-  // A battery of tests for FloatingEqMatcher::Matches.
-  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
-  void TestMatches(
-      testing::internal::FloatingEqMatcher<RawType> (*matcher_maker)(RawType)) {
-    Matcher<RawType> m1 = matcher_maker(0.0);
-    EXPECT_TRUE(m1.Matches(-0.0));
-    EXPECT_TRUE(m1.Matches(close_to_positive_zero_));
-    EXPECT_TRUE(m1.Matches(close_to_negative_zero_));
-    EXPECT_FALSE(m1.Matches(1.0));
-
-    Matcher<RawType> m2 = matcher_maker(close_to_positive_zero_);
-    EXPECT_FALSE(m2.Matches(further_from_negative_zero_));
-
-    Matcher<RawType> m3 = matcher_maker(1.0);
-    EXPECT_TRUE(m3.Matches(close_to_one_));
-    EXPECT_FALSE(m3.Matches(further_from_one_));
-
-    // Test commutativity: matcher_maker(0.0).Matches(1.0) was tested above.
-    EXPECT_FALSE(m3.Matches(0.0));
-
-    Matcher<RawType> m4 = matcher_maker(-infinity_);
-    EXPECT_TRUE(m4.Matches(-close_to_infinity_));
-
-    Matcher<RawType> m5 = matcher_maker(infinity_);
-    EXPECT_TRUE(m5.Matches(close_to_infinity_));
-
-    // This is interesting as the representations of infinity_ and nan1_
-    // are only 1 DLP apart.
-    EXPECT_FALSE(m5.Matches(nan1_));
-
-    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
-    // some cases.
-    Matcher<const RawType&> m6 = matcher_maker(0.0);
-    EXPECT_TRUE(m6.Matches(-0.0));
-    EXPECT_TRUE(m6.Matches(close_to_positive_zero_));
-    EXPECT_FALSE(m6.Matches(1.0));
-
-    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
-    // cases.
-    Matcher<RawType&> m7 = matcher_maker(0.0);
-    RawType x = 0.0;
-    EXPECT_TRUE(m7.Matches(x));
-    x = 0.01f;
-    EXPECT_FALSE(m7.Matches(x));
-  }
-
-  // Pre-calculated numbers to be used by the tests.
-
-  const Bits max_ulps_;
-
-  const Bits zero_bits_;  // The bits that represent 0.0.
-  const Bits one_bits_;  // The bits that represent 1.0.
-  const Bits infinity_bits_;  // The bits that represent +infinity.
-
-  // Some numbers close to 0.0.
-  const RawType close_to_positive_zero_;
-  const RawType close_to_negative_zero_;
-  const RawType further_from_negative_zero_;
-
-  // Some numbers close to 1.0.
-  const RawType close_to_one_;
-  const RawType further_from_one_;
-
-  // Some numbers close to +infinity.
-  const RawType infinity_;
-  const RawType close_to_infinity_;
-  const RawType further_from_infinity_;
-
-  // Maximum representable value that's not infinity.
-  const RawType max_;
-
-  // Some NaNs.
-  const RawType nan1_;
-  const RawType nan2_;
-};
-
-// Tests floating-point matchers with fixed epsilons.
-template <typename RawType>
-class FloatingPointNearTest : public FloatingPointTest<RawType> {
- protected:
-  typedef FloatingPointTest<RawType> ParentType;
-
-  // A battery of tests for FloatingEqMatcher::Matches with a fixed epsilon.
-  // matcher_maker is a pointer to a function which creates a FloatingEqMatcher.
-  void TestNearMatches(
-      testing::internal::FloatingEqMatcher<RawType>
-          (*matcher_maker)(RawType, RawType)) {
-    Matcher<RawType> m1 = matcher_maker(0.0, 0.0);
-    EXPECT_TRUE(m1.Matches(0.0));
-    EXPECT_TRUE(m1.Matches(-0.0));
-    EXPECT_FALSE(m1.Matches(ParentType::close_to_positive_zero_));
-    EXPECT_FALSE(m1.Matches(ParentType::close_to_negative_zero_));
-    EXPECT_FALSE(m1.Matches(1.0));
-
-    Matcher<RawType> m2 = matcher_maker(0.0, 1.0);
-    EXPECT_TRUE(m2.Matches(0.0));
-    EXPECT_TRUE(m2.Matches(-0.0));
-    EXPECT_TRUE(m2.Matches(1.0));
-    EXPECT_TRUE(m2.Matches(-1.0));
-    EXPECT_FALSE(m2.Matches(ParentType::close_to_one_));
-    EXPECT_FALSE(m2.Matches(-ParentType::close_to_one_));
-
-    // Check that inf matches inf, regardless of the of the specified max
-    // absolute error.
-    Matcher<RawType> m3 = matcher_maker(ParentType::infinity_, 0.0);
-    EXPECT_TRUE(m3.Matches(ParentType::infinity_));
-    EXPECT_FALSE(m3.Matches(ParentType::close_to_infinity_));
-    EXPECT_FALSE(m3.Matches(-ParentType::infinity_));
-
-    Matcher<RawType> m4 = matcher_maker(-ParentType::infinity_, 0.0);
-    EXPECT_TRUE(m4.Matches(-ParentType::infinity_));
-    EXPECT_FALSE(m4.Matches(-ParentType::close_to_infinity_));
-    EXPECT_FALSE(m4.Matches(ParentType::infinity_));
-
-    // Test various overflow scenarios.
-    Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
-    EXPECT_TRUE(m5.Matches(ParentType::max_));
-    EXPECT_FALSE(m5.Matches(-ParentType::max_));
-
-    Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
-    EXPECT_FALSE(m6.Matches(ParentType::max_));
-    EXPECT_TRUE(m6.Matches(-ParentType::max_));
-
-    Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
-    EXPECT_TRUE(m7.Matches(ParentType::max_));
-    EXPECT_FALSE(m7.Matches(-ParentType::max_));
-
-    Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
-    EXPECT_FALSE(m8.Matches(ParentType::max_));
-    EXPECT_TRUE(m8.Matches(-ParentType::max_));
-
-    // The difference between max() and -max() normally overflows to infinity,
-    // but it should still match if the max_abs_error is also infinity.
-    Matcher<RawType> m9 = matcher_maker(
-        ParentType::max_, ParentType::infinity_);
-    EXPECT_TRUE(m8.Matches(-ParentType::max_));
-
-    // matcher_maker can produce a Matcher<const RawType&>, which is needed in
-    // some cases.
-    Matcher<const RawType&> m10 = matcher_maker(0.0, 1.0);
-    EXPECT_TRUE(m10.Matches(-0.0));
-    EXPECT_TRUE(m10.Matches(ParentType::close_to_positive_zero_));
-    EXPECT_FALSE(m10.Matches(ParentType::close_to_one_));
-
-    // matcher_maker can produce a Matcher<RawType&>, which is needed in some
-    // cases.
-    Matcher<RawType&> m11 = matcher_maker(0.0, 1.0);
-    RawType x = 0.0;
-    EXPECT_TRUE(m11.Matches(x));
-    x = 1.0f;
-    EXPECT_TRUE(m11.Matches(x));
-    x = -1.0f;
-    EXPECT_TRUE(m11.Matches(x));
-    x = 1.1f;
-    EXPECT_FALSE(m11.Matches(x));
-    x = -1.1f;
-    EXPECT_FALSE(m11.Matches(x));
-  }
-};
-
-// Instantiate FloatingPointTest for testing floats.
-typedef FloatingPointTest<float> FloatTest;
-
-TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) {
-  TestMatches(&FloatEq);
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
-  TestMatches(&NanSensitiveFloatEq);
-}
-
-TEST_F(FloatTest, FloatEqCannotMatchNaN) {
-  // FloatEq never matches NaN.
-  Matcher<float> m = FloatEq(nan1_);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
-  // NanSensitiveFloatEq will match NaN.
-  Matcher<float> m = NanSensitiveFloatEq(nan1_);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatTest, FloatEqCanDescribeSelf) {
-  Matcher<float> m1 = FloatEq(2.0f);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<float> m2 = FloatEq(0.5f);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<float> m3 = FloatEq(nan1_);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
-  Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-// Instantiate FloatingPointTest for testing floats with a user-specified
-// max absolute error.
-typedef FloatingPointNearTest<float> FloatNearTest;
-
-TEST_F(FloatNearTest, FloatNearMatches) {
-  TestNearMatches(&FloatNear);
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats) {
-  TestNearMatches(&NanSensitiveFloatNear);
-}
-
-TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
-  Matcher<float> m1 = FloatNear(2.0f, 0.5f);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<float> m2 = FloatNear(0.5f, 0.5f);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<float> m3 = FloatNear(nan1_, 0.0);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
-  Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
-  // FloatNear never matches NaN.
-  Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
-  // NanSensitiveFloatNear will match NaN.
-  Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-// Instantiate FloatingPointTest for testing doubles.
-typedef FloatingPointTest<double> DoubleTest;
-
-TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
-  TestMatches(&DoubleEq);
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
-  TestMatches(&NanSensitiveDoubleEq);
-}
-
-TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
-  // DoubleEq never matches NaN.
-  Matcher<double> m = DoubleEq(nan1_);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
-  // NanSensitiveDoubleEq will match NaN.
-  Matcher<double> m = NanSensitiveDoubleEq(nan1_);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
-  Matcher<double> m1 = DoubleEq(2.0);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<double> m2 = DoubleEq(0.5);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<double> m3 = DoubleEq(nan1_);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
-  Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
-  EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
-
-  Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
-  EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
-
-  Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-// Instantiate FloatingPointTest for testing floats with a user-specified
-// max absolute error.
-typedef FloatingPointNearTest<double> DoubleNearTest;
-
-TEST_F(DoubleNearTest, DoubleNearMatches) {
-  TestNearMatches(&DoubleNear);
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles) {
-  TestNearMatches(&NanSensitiveDoubleNear);
-}
-
-TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
-  Matcher<double> m1 = DoubleNear(2.0, 0.5);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<double> m2 = DoubleNear(0.5, 0.5);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<double> m3 = DoubleNear(nan1_, 0.0);
-  EXPECT_EQ("never matches", Describe(m3));
-  EXPECT_EQ("is anything", DescribeNegation(m3));
-}
-
-TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
-  EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
-  EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
-  EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
-
-  const std::string explanation =
-      Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
-  // Different C++ implementations may print floating-point numbers
-  // slightly differently.
-  EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" ||  // GCC
-              explanation == "which is 1.2e-010 from 2.1")   // MSVC
-      << " where explanation is \"" << explanation << "\".";
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
-  Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
-  EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
-  EXPECT_EQ(
-      "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
-
-  Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
-  EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
-  EXPECT_EQ(
-      "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
-
-  Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
-  EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
-}
-
-TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
-  // DoubleNear never matches NaN.
-  Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
-  EXPECT_FALSE(m.Matches(nan1_));
-  EXPECT_FALSE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
-}
-
-TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
-  // NanSensitiveDoubleNear will match NaN.
-  Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
-  EXPECT_TRUE(m.Matches(nan1_));
-  EXPECT_TRUE(m.Matches(nan2_));
-  EXPECT_FALSE(m.Matches(1.0));
+                          "  Actual: 5" +
+                              OfType("int"));
 }
 
 TEST(PointeeTest, RawPointer) {
@@ -3707,7 +182,7 @@ TEST(PointeeTest, RawPointerToConst) {
 }
 
 TEST(PointeeTest, ReferenceToConstRawPointer) {
-  const Matcher<int* const &> m = Pointee(Ge(0));
+  const Matcher<int* const&> m = Pointee(Ge(0));
 
   int n = 1;
   EXPECT_TRUE(m.Matches(&n));
@@ -3717,7 +192,7 @@ TEST(PointeeTest, ReferenceToConstRawPointer) {
 }
 
 TEST(PointeeTest, ReferenceToNonConstRawPointer) {
-  const Matcher<double* &> m = Pointee(Ge(0));
+  const Matcher<double*&> m = Pointee(Ge(0));
 
   double x = 1.0;
   double* p = &x;
@@ -3751,179 +226,41 @@ TEST(PointerTest, RawPointer) {
 
   EXPECT_TRUE(m.Matches(&n));
 
-  int* p = nullptr;
-  EXPECT_FALSE(m.Matches(p));
-  EXPECT_FALSE(m.Matches(nullptr));
-}
-
-TEST(PointerTest, RawPointerToConst) {
-  int n = 1;
-  const Matcher<const int*> m = Pointer(Eq(&n));
-
-  EXPECT_TRUE(m.Matches(&n));
-
-  int* p = nullptr;
-  EXPECT_FALSE(m.Matches(p));
-  EXPECT_FALSE(m.Matches(nullptr));
-}
-
-TEST(PointerTest, SmartPointer) {
-  std::unique_ptr<int> n(new int(10));
-  int* raw_n = n.get();
-  const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));
-
-  EXPECT_TRUE(m.Matches(n));
-}
-
-TEST(PointerTest, SmartPointerToConst) {
-  std::unique_ptr<const int> n(new int(10));
-  const int* raw_n = n.get();
-  const Matcher<std::unique_ptr<const int>> m = Pointer(Eq(raw_n));
-
-  // There's no implicit conversion from unique_ptr<int> to const
-  // unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
-  // matcher.
-  std::unique_ptr<const int> p(new int(10));
-  EXPECT_FALSE(m.Matches(p));
-}
-
-TEST(AddressTest, NonConst) {
-  int n = 1;
-  const Matcher<int> m = Address(Eq(&n));
-
-  EXPECT_TRUE(m.Matches(n));
-
-  int other = 5;
-
-  EXPECT_FALSE(m.Matches(other));
-
-  int& n_ref = n;
-
-  EXPECT_TRUE(m.Matches(n_ref));
-}
-
-TEST(AddressTest, Const) {
-  const int n = 1;
-  const Matcher<int> m = Address(Eq(&n));
-
-  EXPECT_TRUE(m.Matches(n));
-
-  int other = 5;
-
-  EXPECT_FALSE(m.Matches(other));
-}
-
-TEST(AddressTest, MatcherDoesntCopy) {
-  std::unique_ptr<int> n(new int(1));
-  const Matcher<std::unique_ptr<int>> m = Address(Eq(&n));
-
-  EXPECT_TRUE(m.Matches(n));
-}
-
-TEST(AddressTest, Describe) {
-  Matcher<int> matcher = Address(_);
-  EXPECT_EQ("has address that is anything", Describe(matcher));
-  EXPECT_EQ("does not have address that is anything",
-            DescribeNegation(matcher));
-}
-
-MATCHER_P(FieldIIs, inner_matcher, "") {
-  return ExplainMatchResult(inner_matcher, arg.i, result_listener);
+  int* p = nullptr;
+  EXPECT_FALSE(m.Matches(p));
+  EXPECT_FALSE(m.Matches(nullptr));
 }
 
-#if GTEST_HAS_RTTI
-TEST(WhenDynamicCastToTest, SameType) {
-  Derived derived;
-  derived.i = 4;
-
-  // Right type. A pointer is passed down.
-  Base* as_base_ptr = &derived;
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
-  EXPECT_THAT(as_base_ptr,
-              Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
-}
-
-TEST(WhenDynamicCastToTest, WrongTypes) {
-  Base base;
-  Derived derived;
-  OtherDerived other_derived;
-
-  // Wrong types. NULL is passed.
-  EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
-  EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
-  Base* as_base_ptr = &derived;
-  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
-  as_base_ptr = &other_derived;
-  EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
-}
-
-TEST(WhenDynamicCastToTest, AlreadyNull) {
-  // Already NULL.
-  Base* as_base_ptr = nullptr;
-  EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
-}
-
-struct AmbiguousCastTypes {
-  class VirtualDerived : public virtual Base {};
-  class DerivedSub1 : public VirtualDerived {};
-  class DerivedSub2 : public VirtualDerived {};
-  class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
-};
+TEST(PointerTest, RawPointerToConst) {
+  int n = 1;
+  const Matcher<const int*> m = Pointer(Eq(&n));
 
-TEST(WhenDynamicCastToTest, AmbiguousCast) {
-  AmbiguousCastTypes::DerivedSub1 sub1;
-  AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
-  // Multiply derived from Base. dynamic_cast<> returns NULL.
-  Base* as_base_ptr =
-      static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
-  EXPECT_THAT(as_base_ptr,
-              WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
-  as_base_ptr = &sub1;
-  EXPECT_THAT(
-      as_base_ptr,
-      WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
-}
+  EXPECT_TRUE(m.Matches(&n));
 
-TEST(WhenDynamicCastToTest, Describe) {
-  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
-  const std::string prefix =
-      "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
-  EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
-  EXPECT_EQ(prefix + "does not point to a value that is anything",
-            DescribeNegation(matcher));
+  int* p = nullptr;
+  EXPECT_FALSE(m.Matches(p));
+  EXPECT_FALSE(m.Matches(nullptr));
 }
 
-TEST(WhenDynamicCastToTest, Explain) {
-  Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
-  Base* null = nullptr;
-  EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
-  Derived derived;
-  EXPECT_TRUE(matcher.Matches(&derived));
-  EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
+TEST(PointerTest, SmartPointer) {
+  std::unique_ptr<int> n(new int(10));
+  int* raw_n = n.get();
+  const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));
 
-  // With references, the matcher itself can fail. Test for that one.
-  Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
-  EXPECT_THAT(Explain(ref_matcher, derived),
-              HasSubstr("which cannot be dynamic_cast"));
+  EXPECT_TRUE(m.Matches(n));
 }
 
-TEST(WhenDynamicCastToTest, GoodReference) {
-  Derived derived;
-  derived.i = 4;
-  Base& as_base_ref = derived;
-  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
-  EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
-}
+TEST(PointerTest, SmartPointerToConst) {
+  std::unique_ptr<const int> n(new int(10));
+  const int* raw_n = n.get();
+  const Matcher<std::unique_ptr<const int>> m = Pointer(Eq(raw_n));
 
-TEST(WhenDynamicCastToTest, BadReference) {
-  Derived derived;
-  Base& as_base_ref = derived;
-  EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
+  // There's no implicit conversion from unique_ptr<int> to const
+  // unique_ptr<const int>, so we must pass a unique_ptr<const int> into the
+  // matcher.
+  std::unique_ptr<const int> p(new int(10));
+  EXPECT_FALSE(m.Matches(p));
 }
-#endif  // GTEST_HAS_RTTI
 
 // Minimal const-propagating pointer.
 template <typename T>
@@ -3945,8 +282,10 @@ class ConstPropagatingPtr {
   T* val_;
 };
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(PointeeTest);
+
 TEST(PointeeTest, WorksWithConstPropagatingPointers) {
-  const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
+  const Matcher<ConstPropagatingPtr<int>> m = Pointee(Lt(5));
   int three = 3;
   const ConstPropagatingPtr<int> co(&three);
   ConstPropagatingPtr<int> o(&three);
@@ -3976,17 +315,16 @@ TEST(PointeeTest, MatchesAgainstAValue) {
 TEST(PointeeTest, CanDescribeSelf) {
   const Matcher<int*> m = Pointee(Gt(3));
   EXPECT_EQ("points to a value that is > 3", Describe(m));
-  EXPECT_EQ("does not point to a value that is > 3",
-            DescribeNegation(m));
+  EXPECT_EQ("does not point to a value that is > 3", DescribeNegation(m));
 }
 
-TEST(PointeeTest, CanExplainMatchResult) {
+TEST_P(PointeeTestP, CanExplainMatchResult) {
   const Matcher<const std::string*> m = Pointee(StartsWith("Hi"));
 
   EXPECT_EQ("", Explain(m, static_cast<const std::string*>(nullptr)));
 
   const Matcher<long*> m2 = Pointee(GreaterThan(1));  // NOLINT
-  long n = 3;  // NOLINT
+  long n = 3;                                         // NOLINT
   EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
             Explain(m2, &n));
 }
@@ -4008,7 +346,8 @@ class Uncopyable {
 
  private:
   int value_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Uncopyable);
+  Uncopyable(const Uncopyable&) = delete;
+  Uncopyable& operator=(const Uncopyable&) = delete;
 };
 
 // Returns true if and only if x.value() is positive.
@@ -4035,6 +374,8 @@ struct DerivedStruct : public AStruct {
   char ch;
 };
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(FieldTest);
+
 // Tests that Field(&Foo::field, ...) works when field is non-const.
 TEST(FieldTest, WorksForNonConstField) {
   Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
@@ -4116,8 +457,7 @@ TEST(FieldTest, WorksForArgumentOfSubType) {
 // argument type are compatible but not the same.
 TEST(FieldTest, WorksForCompatibleMatcherType) {
   // The field is an int, but the inner matcher expects a signed char.
-  Matcher<const AStruct&> m = Field(&AStruct::x,
-                                    Matcher<signed char>(Ge(0)));
+  Matcher<const AStruct&> m = Field(&AStruct::x, Matcher<signed char>(Ge(0)));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
@@ -4142,7 +482,7 @@ TEST(FieldTest, CanDescribeSelfWithFieldName) {
 }
 
 // Tests that Field() can explain the match result.
-TEST(FieldTest, CanExplainMatchResult) {
+TEST_P(FieldTestP, CanExplainMatchResult) {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
@@ -4155,7 +495,7 @@ TEST(FieldTest, CanExplainMatchResult) {
       Explain(m, a));
 }
 
-TEST(FieldTest, CanExplainMatchResultWithFieldName) {
+TEST_P(FieldTestP, CanExplainMatchResultWithFieldName) {
   Matcher<const AStruct&> m = Field("field_name", &AStruct::x, Ge(0));
 
   AStruct a;
@@ -4168,6 +508,8 @@ TEST(FieldTest, CanExplainMatchResultWithFieldName) {
             Explain(m, a));
 }
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(FieldForPointerTest);
+
 // Tests that Field() works when the argument is a pointer to const.
 TEST(FieldForPointerTest, WorksForPointerToConst) {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
@@ -4234,7 +576,7 @@ TEST(FieldForPointerTest, CanDescribeSelfWithFieldName) {
 }
 
 // Tests that Field() can explain the result of matching a pointer.
-TEST(FieldForPointerTest, CanExplainMatchResult) {
+TEST_P(FieldForPointerTestP, CanExplainMatchResult) {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
@@ -4245,10 +587,11 @@ TEST(FieldForPointerTest, CanExplainMatchResult) {
 
   m = Field(&AStruct::x, GreaterThan(0));
   EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
-            ", which is 1 more than 0", Explain(m, &a));
+                ", which is 1 more than 0",
+            Explain(m, &a));
 }
 
-TEST(FieldForPointerTest, CanExplainMatchResultWithFieldName) {
+TEST_P(FieldForPointerTestP, CanExplainMatchResultWithFieldName) {
   Matcher<const AStruct*> m = Field("field_name", &AStruct::x, Ge(0));
 
   AStruct a;
@@ -4277,7 +620,7 @@ class AClass {
   // A getter that returns a reference to const.
   const std::string& s() const { return s_; }
 
-  const std::string& s_ref() const & { return s_; }
+  const std::string& s_ref() const& { return s_; }
 
   void set_s(const std::string& new_s) { s_ = new_s; }
 
@@ -4297,10 +640,13 @@ double AClass::x_ = 0.0;
 class DerivedClass : public AClass {
  public:
   int k() const { return k_; }
+
  private:
   int k_;
 };
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(PropertyTest);
+
 // Tests that Property(&Foo::property, ...) works when property()
 // returns a non-reference.
 TEST(PropertyTest, WorksForNonReferenceProperty) {
@@ -4396,8 +742,7 @@ TEST(PropertyTest, WorksForArgumentOfSubType) {
 // and m's argument type are compatible but different.
 TEST(PropertyTest, WorksForCompatibleMatcherType) {
   // n() returns an int but the inner matcher expects a signed char.
-  Matcher<const AClass&> m = Property(&AClass::n,
-                                      Matcher<signed char>(Ge(0)));
+  Matcher<const AClass&> m = Property(&AClass::n, Matcher<signed char>(Ge(0)));
 
   Matcher<const AClass&> m_with_name =
       Property("n", &AClass::n, Matcher<signed char>(Ge(0)));
@@ -4428,7 +773,7 @@ TEST(PropertyTest, CanDescribeSelfWithPropertyName) {
 }
 
 // Tests that Property() can explain the match result.
-TEST(PropertyTest, CanExplainMatchResult) {
+TEST_P(PropertyTestP, CanExplainMatchResult) {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
   AClass a;
@@ -4441,7 +786,7 @@ TEST(PropertyTest, CanExplainMatchResult) {
       Explain(m, a));
 }
 
-TEST(PropertyTest, CanExplainMatchResultWithPropertyName) {
+TEST_P(PropertyTestP, CanExplainMatchResultWithPropertyName) {
   Matcher<const AClass&> m = Property("fancy_name", &AClass::n, Ge(0));
 
   AClass a;
@@ -4454,6 +799,8 @@ TEST(PropertyTest, CanExplainMatchResultWithPropertyName) {
             Explain(m, a));
 }
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(PropertyForPointerTest);
+
 // Tests that Property() works when the argument is a pointer to const.
 TEST(PropertyForPointerTest, WorksForPointerToConst) {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
@@ -4530,7 +877,7 @@ TEST(PropertyForPointerTest, CanDescribeSelfWithPropertyDescription) {
 }
 
 // Tests that Property() can explain the result of matching a pointer.
-TEST(PropertyForPointerTest, CanExplainMatchResult) {
+TEST_P(PropertyForPointerTestP, CanExplainMatchResult) {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
   AClass a;
@@ -4542,11 +889,11 @@ TEST(PropertyForPointerTest, CanExplainMatchResult) {
 
   m = Property(&AClass::n, GreaterThan(0));
   EXPECT_EQ("which points to an object whose given property is 1" +
-            OfType("int") + ", which is 1 more than 0",
+                OfType("int") + ", which is 1 more than 0",
             Explain(m, &a));
 }
 
-TEST(PropertyForPointerTest, CanExplainMatchResultWithPropertyName) {
+TEST_P(PropertyForPointerTestP, CanExplainMatchResultWithPropertyName) {
   Matcher<const AClass*> m = Property("fancy_name", &AClass::n, Ge(0));
 
   AClass a;
@@ -4570,6 +917,8 @@ std::string IntToStringFunction(int input) {
   return input == 1 ? "foo" : "bar";
 }
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(ResultOfTest);
+
 TEST(ResultOfTest, WorksForFunctionPointers) {
   Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(std::string("foo")));
 
@@ -4581,23 +930,49 @@ TEST(ResultOfTest, WorksForFunctionPointers) {
 TEST(ResultOfTest, CanDescribeItself) {
   Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
 
-  EXPECT_EQ("is mapped by the given callable to a value that "
-            "is equal to \"foo\"", Describe(matcher));
-  EXPECT_EQ("is mapped by the given callable to a value that "
-            "isn't equal to \"foo\"", DescribeNegation(matcher));
+  EXPECT_EQ(
+      "is mapped by the given callable to a value that "
+      "is equal to \"foo\"",
+      Describe(matcher));
+  EXPECT_EQ(
+      "is mapped by the given callable to a value that "
+      "isn't equal to \"foo\"",
+      DescribeNegation(matcher));
+}
+
+// Tests that ResultOf() can describe itself when provided a result description.
+TEST(ResultOfTest, CanDescribeItselfWithResultDescription) {
+  Matcher<int> matcher =
+      ResultOf("string conversion", &IntToStringFunction, StrEq("foo"));
+
+  EXPECT_EQ("whose string conversion is equal to \"foo\"", Describe(matcher));
+  EXPECT_EQ("whose string conversion isn't equal to \"foo\"",
+            DescribeNegation(matcher));
 }
 
 // Tests that ResultOf() can explain the match result.
 int IntFunction(int input) { return input == 42 ? 80 : 90; }
 
-TEST(ResultOfTest, CanExplainMatchResult) {
+TEST_P(ResultOfTestP, CanExplainMatchResult) {
   Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
   EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
             Explain(matcher, 36));
 
   matcher = ResultOf(&IntFunction, GreaterThan(85));
   EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
-            ", which is 5 more than 85", Explain(matcher, 36));
+                ", which is 5 more than 85",
+            Explain(matcher, 36));
+}
+
+TEST_P(ResultOfTestP, CanExplainMatchResultWithResultDescription) {
+  Matcher<int> matcher = ResultOf("magic int conversion", &IntFunction, Ge(85));
+  EXPECT_EQ("whose magic int conversion is 90" + OfType("int"),
+            Explain(matcher, 36));
+
+  matcher = ResultOf("magic int conversion", &IntFunction, GreaterThan(85));
+  EXPECT_EQ("whose magic int conversion is 90" + OfType("int") +
+                ", which is 5 more than 85",
+            Explain(matcher, 36));
 }
 
 // Tests that ResultOf(f, ...) compiles and works as expected when f(x)
@@ -4628,8 +1003,7 @@ TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
   // Test that ResultOf works with uncopyable objects
   Uncopyable obj(0);
   Uncopyable obj2(0);
-  Matcher<Uncopyable&> matcher2 =
-      ResultOf(&RefUncopyableFunction, Ref(obj));
+  Matcher<Uncopyable&> matcher2 = ResultOf(&RefUncopyableFunction, Ref(obj));
 
   EXPECT_TRUE(matcher2.Matches(obj));
   EXPECT_FALSE(matcher2.Matches(obj2));
@@ -4678,9 +1052,7 @@ TEST(ResultOfTest, WorksForFunctionReferences) {
 // Tests that ResultOf(f, ...) compiles and works as expected when f is a
 // function object.
 struct Functor {
-  std::string operator()(int input) const {
-    return IntToStringFunction(input);
-  }
+  std::string operator()(int input) const { return IntToStringFunction(input); }
 };
 
 TEST(ResultOfTest, WorksForFunctors) {
@@ -4697,7 +1069,7 @@ struct PolymorphicFunctor {
   typedef int result_type;
   int operator()(int n) { return n; }
   int operator()(const char* s) { return static_cast<int>(strlen(s)); }
-  std::string operator()(int *p) { return p ? "good ptr" : "null"; }
+  std::string operator()(int* p) { return p ? "good ptr" : "null"; }
 };
 
 TEST(ResultOfTest, WorksForPolymorphicFunctors) {
@@ -4759,190 +1131,6 @@ TEST(ResultOfTest, WorksForReferencingCallables) {
   EXPECT_FALSE(matcher3.Matches(n2));
 }
 
-class DivisibleByImpl {
- public:
-  explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
-
-  // For testing using ExplainMatchResultTo() with polymorphic matchers.
-  template <typename T>
-  bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
-    *listener << "which is " << (n % divider_) << " modulo "
-              << divider_;
-    return (n % divider_) == 0;
-  }
-
-  void DescribeTo(ostream* os) const {
-    *os << "is divisible by " << divider_;
-  }
-
-  void DescribeNegationTo(ostream* os) const {
-    *os << "is not divisible by " << divider_;
-  }
-
-  void set_divider(int a_divider) { divider_ = a_divider; }
-  int divider() const { return divider_; }
-
- private:
-  int divider_;
-};
-
-PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
-  return MakePolymorphicMatcher(DivisibleByImpl(n));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_False_False) {
-  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
-  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_False_True) {
-  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
-  EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
-}
-
-// Tests that when AllOf() fails, only the first failing matcher is
-// asked to explain why.
-TEST(ExplainMatchResultTest, AllOf_True_False) {
-  const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
-  EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
-}
-
-// Tests that when AllOf() succeeds, all matchers are asked to explain
-// why.
-TEST(ExplainMatchResultTest, AllOf_True_True) {
-  const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
-  EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
-}
-
-TEST(ExplainMatchResultTest, AllOf_True_True_2) {
-  const Matcher<int> m = AllOf(Ge(2), Le(3));
-  EXPECT_EQ("", Explain(m, 2));
-}
-
-TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
-  const Matcher<int> m = GreaterThan(5);
-  EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
-}
-
-// The following two tests verify that values without a public copy
-// ctor can be used as arguments to matchers like Eq(), Ge(), and etc
-// with the help of ByRef().
-
-class NotCopyable {
- public:
-  explicit NotCopyable(int a_value) : value_(a_value) {}
-
-  int value() const { return value_; }
-
-  bool operator==(const NotCopyable& rhs) const {
-    return value() == rhs.value();
-  }
-
-  bool operator>=(const NotCopyable& rhs) const {
-    return value() >= rhs.value();
-  }
- private:
-  int value_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NotCopyable);
-};
-
-TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
-  const NotCopyable const_value1(1);
-  const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
-
-  const NotCopyable n1(1), n2(2);
-  EXPECT_TRUE(m.Matches(n1));
-  EXPECT_FALSE(m.Matches(n2));
-}
-
-TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
-  NotCopyable value2(2);
-  const Matcher<NotCopyable&> m = Ge(ByRef(value2));
-
-  NotCopyable n1(1), n2(2);
-  EXPECT_FALSE(m.Matches(n1));
-  EXPECT_TRUE(m.Matches(n2));
-}
-
-TEST(IsEmptyTest, ImplementsIsEmpty) {
-  vector<int> container;
-  EXPECT_THAT(container, IsEmpty());
-  container.push_back(0);
-  EXPECT_THAT(container, Not(IsEmpty()));
-  container.push_back(1);
-  EXPECT_THAT(container, Not(IsEmpty()));
-}
-
-TEST(IsEmptyTest, WorksWithString) {
-  std::string text;
-  EXPECT_THAT(text, IsEmpty());
-  text = "foo";
-  EXPECT_THAT(text, Not(IsEmpty()));
-  text = std::string("\0", 1);
-  EXPECT_THAT(text, Not(IsEmpty()));
-}
-
-TEST(IsEmptyTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = IsEmpty();
-  EXPECT_EQ("is empty", Describe(m));
-  EXPECT_EQ("isn't empty", DescribeNegation(m));
-}
-
-TEST(IsEmptyTest, ExplainsResult) {
-  Matcher<vector<int> > m = IsEmpty();
-  vector<int> container;
-  EXPECT_EQ("", Explain(m, container));
-  container.push_back(0);
-  EXPECT_EQ("whose size is 1", Explain(m, container));
-}
-
-TEST(IsEmptyTest, WorksWithMoveOnly) {
-  ContainerHelper helper;
-  EXPECT_CALL(helper, Call(IsEmpty()));
-  helper.Call({});
-}
-
-TEST(IsTrueTest, IsTrueIsFalse) {
-  EXPECT_THAT(true, IsTrue());
-  EXPECT_THAT(false, IsFalse());
-  EXPECT_THAT(true, Not(IsFalse()));
-  EXPECT_THAT(false, Not(IsTrue()));
-  EXPECT_THAT(0, Not(IsTrue()));
-  EXPECT_THAT(0, IsFalse());
-  EXPECT_THAT(nullptr, Not(IsTrue()));
-  EXPECT_THAT(nullptr, IsFalse());
-  EXPECT_THAT(-1, IsTrue());
-  EXPECT_THAT(-1, Not(IsFalse()));
-  EXPECT_THAT(1, IsTrue());
-  EXPECT_THAT(1, Not(IsFalse()));
-  EXPECT_THAT(2, IsTrue());
-  EXPECT_THAT(2, Not(IsFalse()));
-  int a = 42;
-  EXPECT_THAT(a, IsTrue());
-  EXPECT_THAT(a, Not(IsFalse()));
-  EXPECT_THAT(&a, IsTrue());
-  EXPECT_THAT(&a, Not(IsFalse()));
-  EXPECT_THAT(false, Not(IsTrue()));
-  EXPECT_THAT(true, Not(IsFalse()));
-  EXPECT_THAT(std::true_type(), IsTrue());
-  EXPECT_THAT(std::true_type(), Not(IsFalse()));
-  EXPECT_THAT(std::false_type(), IsFalse());
-  EXPECT_THAT(std::false_type(), Not(IsTrue()));
-  EXPECT_THAT(nullptr, Not(IsTrue()));
-  EXPECT_THAT(nullptr, IsFalse());
-  std::unique_ptr<int> null_unique;
-  std::unique_ptr<int> nonnull_unique(new int(0));
-  EXPECT_THAT(null_unique, Not(IsTrue()));
-  EXPECT_THAT(null_unique, IsFalse());
-  EXPECT_THAT(nonnull_unique, IsTrue());
-  EXPECT_THAT(nonnull_unique, Not(IsFalse()));
-}
-
 TEST(SizeIsTest, ImplementsSizeIs) {
   vector<int> container;
   EXPECT_THAT(container, SizeIs(0));
@@ -4993,16 +1181,16 @@ TEST(SizeIsTest, WorksWithMinimalistCustomType) {
 }
 
 TEST(SizeIsTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = SizeIs(2);
-  EXPECT_EQ("size is equal to 2", Describe(m));
-  EXPECT_EQ("size isn't equal to 2", DescribeNegation(m));
+  Matcher<vector<int>> m = SizeIs(2);
+  EXPECT_EQ("has a size that is equal to 2", Describe(m));
+  EXPECT_EQ("has a size that isn't equal to 2", DescribeNegation(m));
 }
 
 TEST(SizeIsTest, ExplainsResult) {
-  Matcher<vector<int> > m1 = SizeIs(2);
-  Matcher<vector<int> > m2 = SizeIs(Lt(2u));
-  Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
-  Matcher<vector<int> > m4 = SizeIs(Gt(1u));
+  Matcher<vector<int>> m1 = SizeIs(2);
+  Matcher<vector<int>> m2 = SizeIs(Lt(2u));
+  Matcher<vector<int>> m3 = SizeIs(AnyOf(0, 3));
+  Matcher<vector<int>> m4 = SizeIs(Gt(1u));
   vector<int> container;
   EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
   EXPECT_EQ("whose size 0 matches", Explain(m2, container));
@@ -5016,207 +1204,6 @@ TEST(SizeIsTest, ExplainsResult) {
   EXPECT_EQ("whose size 2 matches", Explain(m4, container));
 }
 
-#if GTEST_HAS_TYPED_TEST
-// Tests ContainerEq with different container types, and
-// different element types.
-
-template <typename T>
-class ContainerEqTest : public testing::Test {};
-
-typedef testing::Types<
-    set<int>,
-    vector<size_t>,
-    multiset<size_t>,
-    list<int> >
-    ContainerEqTestTypes;
-
-TYPED_TEST_SUITE(ContainerEqTest, ContainerEqTestTypes);
-
-// Tests that the filled container is equal to itself.
-TYPED_TEST(ContainerEqTest, EqualsSelf) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  TypeParam my_set(vals, vals + 6);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_TRUE(m.Matches(my_set));
-  EXPECT_EQ("", Explain(m, my_set));
-}
-
-// Tests that missing values are reported.
-TYPED_TEST(ContainerEqTest, ValueMissing) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {2, 1, 8, 5};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 4);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which doesn't have these expected elements: 3",
-            Explain(m, test_set));
-}
-
-// Tests that added values are reported.
-TYPED_TEST(ContainerEqTest, ValueAdded) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8, 46};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 6);
-  const Matcher<const TypeParam&> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
-}
-
-// Tests that added and missing values are reported together.
-TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 8, 46};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 5);
-  const Matcher<TypeParam> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 46,\n"
-            "and doesn't have these expected elements: 5",
-            Explain(m, test_set));
-}
-
-// Tests duplicated value -- expect no explanation.
-TYPED_TEST(ContainerEqTest, DuplicateDifference) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8};
-  TypeParam my_set(vals, vals + 6);
-  TypeParam test_set(test_vals, test_vals + 5);
-  const Matcher<const TypeParam&> m = ContainerEq(my_set);
-  // Depending on the container, match may be true or false
-  // But in any case there should be no explanation.
-  EXPECT_EQ("", Explain(m, test_set));
-}
-#endif  // GTEST_HAS_TYPED_TEST
-
-// Tests that multiple missing values are reported.
-// Using just vector here, so order is predictable.
-TEST(ContainerEqExtraTest, MultipleValuesMissing) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {2, 1, 5};
-  vector<int> my_set(vals, vals + 6);
-  vector<int> test_set(test_vals, test_vals + 3);
-  const Matcher<vector<int> > m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which doesn't have these expected elements: 3, 8",
-            Explain(m, test_set));
-}
-
-// Tests that added values are reported.
-// Using just vector here, so order is predictable.
-TEST(ContainerEqExtraTest, MultipleValuesAdded) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
-  list<size_t> my_set(vals, vals + 6);
-  list<size_t> test_set(test_vals, test_vals + 7);
-  const Matcher<const list<size_t>&> m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 92, 46",
-            Explain(m, test_set));
-}
-
-// Tests that added and missing values are reported together.
-TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 92, 46};
-  list<size_t> my_set(vals, vals + 6);
-  list<size_t> test_set(test_vals, test_vals + 5);
-  const Matcher<const list<size_t> > m = ContainerEq(my_set);
-  EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
-            "and doesn't have these expected elements: 5, 8",
-            Explain(m, test_set));
-}
-
-// Tests to see that duplicate elements are detected,
-// but (as above) not reported in the explanation.
-TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
-  static const int vals[] = {1, 1, 2, 3, 5, 8};
-  static const int test_vals[] = {1, 2, 3, 5, 8};
-  vector<int> my_set(vals, vals + 6);
-  vector<int> test_set(test_vals, test_vals + 5);
-  const Matcher<vector<int> > m = ContainerEq(my_set);
-  EXPECT_TRUE(m.Matches(my_set));
-  EXPECT_FALSE(m.Matches(test_set));
-  // There is nothing to report when both sets contain all the same values.
-  EXPECT_EQ("", Explain(m, test_set));
-}
-
-// Tests that ContainerEq works for non-trivial associative containers,
-// like maps.
-TEST(ContainerEqExtraTest, WorksForMaps) {
-  map<int, std::string> my_map;
-  my_map[0] = "a";
-  my_map[1] = "b";
-
-  map<int, std::string> test_map;
-  test_map[0] = "aa";
-  test_map[1] = "b";
-
-  const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
-  EXPECT_TRUE(m.Matches(my_map));
-  EXPECT_FALSE(m.Matches(test_map));
-
-  EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
-            "and doesn't have these expected elements: (0, \"a\")",
-            Explain(m, test_map));
-}
-
-TEST(ContainerEqExtraTest, WorksForNativeArray) {
-  int a1[] = {1, 2, 3};
-  int a2[] = {1, 2, 3};
-  int b[] = {1, 2, 4};
-
-  EXPECT_THAT(a1, ContainerEq(a2));
-  EXPECT_THAT(a1, Not(ContainerEq(b)));
-}
-
-TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
-  const char a1[][3] = {"hi", "lo"};
-  const char a2[][3] = {"hi", "lo"};
-  const char b[][3] = {"lo", "hi"};
-
-  // Tests using ContainerEq() in the first dimension.
-  EXPECT_THAT(a1, ContainerEq(a2));
-  EXPECT_THAT(a1, Not(ContainerEq(b)));
-
-  // Tests using ContainerEq() in the second dimension.
-  EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
-  EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
-}
-
-TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
-  const int a1[] = {1, 2, 3};
-  const int a2[] = {1, 2, 3};
-  const int b[] = {1, 2, 3, 4};
-
-  const int* const p1 = a1;
-  EXPECT_THAT(std::make_tuple(p1, 3), ContainerEq(a2));
-  EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(b)));
-
-  const int c[] = {1, 3, 2};
-  EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(c)));
-}
-
-TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
-  std::string a1[][3] = {
-    {"hi", "hello", "ciao"},
-    {"bye", "see you", "ciao"}
-  };
-
-  std::string a2[][3] = {
-    {"hi", "hello", "ciao"},
-    {"bye", "see you", "ciao"}
-  };
-
-  const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
-  EXPECT_THAT(a1, m);
-
-  a2[0][0] = "ha";
-  EXPECT_THAT(a1, m);
-}
-
 TEST(WhenSortedByTest, WorksForEmptyContainer) {
   const vector<int> numbers;
   EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre()));
@@ -5229,10 +1216,10 @@ TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
   numbers.push_back(1);
   numbers.push_back(2);
   numbers.push_back(2);
-  EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(),
-                                    ElementsAre(3, 2, 2, 1)));
-  EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(),
-                                        ElementsAre(1, 2, 2, 3))));
+  EXPECT_THAT(numbers,
+              WhenSortedBy(greater<unsigned>(), ElementsAre(3, 2, 2, 1)));
+  EXPECT_THAT(numbers,
+              Not(WhenSortedBy(greater<unsigned>(), ElementsAre(1, 2, 2, 3))));
 }
 
 TEST(WhenSortedByTest, WorksForNonVectorContainer) {
@@ -5250,21 +1237,23 @@ TEST(WhenSortedByTest, WorksForNativeArray) {
   const int numbers[] = {1, 3, 2, 4};
   const int sorted_numbers[] = {1, 2, 3, 4};
   EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4)));
-  EXPECT_THAT(numbers, WhenSortedBy(less<int>(),
-                                    ElementsAreArray(sorted_numbers)));
+  EXPECT_THAT(numbers,
+              WhenSortedBy(less<int>(), ElementsAreArray(sorted_numbers)));
   EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4))));
 }
 
 TEST(WhenSortedByTest, CanDescribeSelf) {
-  const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
-  EXPECT_EQ("(when sorted) has 2 elements where\n"
-            "element #0 is equal to 1,\n"
-            "element #1 is equal to 2",
-            Describe(m));
-  EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
-            "element #0 isn't equal to 1, or\n"
-            "element #1 isn't equal to 2",
-            DescribeNegation(m));
+  const Matcher<vector<int>> m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
+  EXPECT_EQ(
+      "(when sorted) has 2 elements where\n"
+      "element #0 is equal to 1,\n"
+      "element #1 is equal to 2",
+      Describe(m));
+  EXPECT_EQ(
+      "(when sorted) doesn't have 2 elements, or\n"
+      "element #0 isn't equal to 1, or\n"
+      "element #1 isn't equal to 2",
+      DescribeNegation(m));
 }
 
 TEST(WhenSortedByTest, ExplainsMatchResult) {
@@ -5308,43 +1297,37 @@ TEST(WhenSortedTest, WorksForMapTypes) {
 }
 
 TEST(WhenSortedTest, WorksForMultiMapTypes) {
-    multimap<int, int> ifib;
-    ifib.insert(make_pair(8, 6));
-    ifib.insert(make_pair(2, 3));
-    ifib.insert(make_pair(1, 1));
-    ifib.insert(make_pair(3, 4));
-    ifib.insert(make_pair(1, 2));
-    ifib.insert(make_pair(5, 5));
-    EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1),
-                                             Pair(1, 2),
-                                             Pair(2, 3),
-                                             Pair(3, 4),
-                                             Pair(5, 5),
-                                             Pair(8, 6))));
-    EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6),
-                                                 Pair(2, 3),
-                                                 Pair(1, 1),
-                                                 Pair(3, 4),
-                                                 Pair(1, 2),
-                                                 Pair(5, 5)))));
+  multimap<int, int> ifib;
+  ifib.insert(make_pair(8, 6));
+  ifib.insert(make_pair(2, 3));
+  ifib.insert(make_pair(1, 1));
+  ifib.insert(make_pair(3, 4));
+  ifib.insert(make_pair(1, 2));
+  ifib.insert(make_pair(5, 5));
+  EXPECT_THAT(ifib,
+              WhenSorted(ElementsAre(Pair(1, 1), Pair(1, 2), Pair(2, 3),
+                                     Pair(3, 4), Pair(5, 5), Pair(8, 6))));
+  EXPECT_THAT(ifib,
+              Not(WhenSorted(ElementsAre(Pair(8, 6), Pair(2, 3), Pair(1, 1),
+                                         Pair(3, 4), Pair(1, 2), Pair(5, 5)))));
 }
 
 TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
-    std::deque<int> d;
-    d.push_back(2);
-    d.push_back(1);
-    EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
-    EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
+  std::deque<int> d;
+  d.push_back(2);
+  d.push_back(1);
+  EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
+  EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
 }
 
 TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
-    std::deque<int> d;
-    d.push_back(2);
-    d.push_back(1);
-    Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
-    EXPECT_THAT(d, WhenSorted(vector_match));
-    Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
-    EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
+  std::deque<int> d;
+  d.push_back(2);
+  d.push_back(1);
+  Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
+  EXPECT_THAT(d, WhenSorted(vector_match));
+  Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
+  EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
 }
 
 // Deliberately bare pseudo-container.
@@ -5353,6 +1336,7 @@ template <typename T>
 class Streamlike {
  private:
   class ConstIter;
+
  public:
   typedef ConstIter const_iterator;
   typedef T value_type;
@@ -5363,19 +1347,18 @@ class Streamlike {
   const_iterator begin() const {
     return const_iterator(this, remainder_.begin());
   }
-  const_iterator end() const {
-    return const_iterator(this, remainder_.end());
-  }
+  const_iterator end() const { return const_iterator(this, remainder_.end()); }
 
  private:
-  class ConstIter : public std::iterator<std::input_iterator_tag,
-                                         value_type,
-                                         ptrdiff_t,
-                                         const value_type*,
-                                         const value_type&> {
+  class ConstIter {
    public:
-    ConstIter(const Streamlike* s,
-              typename std::list<value_type>::iterator pos)
+    using iterator_category = std::input_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = const value_type*;
+    using reference = const value_type&;
+
+    ConstIter(const Streamlike* s, typename std::list<value_type>::iterator pos)
         : s_(s), pos_(pos) {}
 
     const value_type& operator*() const { return *pos_; }
@@ -5391,6 +1374,7 @@ class Streamlike {
      public:
       explicit PostIncrProxy(const value_type& value) : value_(value) {}
       value_type operator*() const { return value_; }
+
      private:
       value_type value_;
     };
@@ -5438,6 +1422,8 @@ TEST(StreamlikeTest, Iteration) {
   }
 }
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(BeginEndDistanceIsTest);
+
 TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
   std::forward_list<int> container;
   EXPECT_THAT(container, BeginEndDistanceIs(0));
@@ -5457,7 +1443,7 @@ TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
 }
 
 TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
-  Matcher<vector<int> > m = BeginEndDistanceIs(2);
+  Matcher<vector<int>> m = BeginEndDistanceIs(2);
   EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m));
   EXPECT_EQ("distance between begin() and end() isn't equal to 2",
             DescribeNegation(m));
@@ -5469,11 +1455,11 @@ TEST(BeginEndDistanceIsTest, WorksWithMoveOnly) {
   helper.Call(MakeUniquePtrs({1, 2}));
 }
 
-TEST(BeginEndDistanceIsTest, ExplainsResult) {
-  Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
-  Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
-  Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
-  Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
+TEST_P(BeginEndDistanceIsTestP, ExplainsResult) {
+  Matcher<vector<int>> m1 = BeginEndDistanceIs(2);
+  Matcher<vector<int>> m2 = BeginEndDistanceIs(Lt(2));
+  Matcher<vector<int>> m3 = BeginEndDistanceIs(AnyOf(0, 3));
+  Matcher<vector<int>> m4 = BeginEndDistanceIs(GreaterThan(1));
   vector<int> container;
   EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
             Explain(m1, container));
@@ -5834,8 +1820,8 @@ TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
   std::vector<int> s(std::begin(a), std::end(a));
   do {
     StringMatchResultListener listener;
-    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a),
-                                   s, &listener)) << listener.str();
+    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a), s, &listener))
+        << listener.str();
   } while (std::next_permutation(s.begin(), s.end()));
 }
 
@@ -5845,8 +1831,9 @@ TEST(UnorderedElementsAreArrayTest, VectorBool) {
   std::vector<bool> expected(std::begin(a), std::end(a));
   std::vector<bool> actual(std::begin(b), std::end(b));
   StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected),
-                                 actual, &listener)) << listener.str();
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected), actual,
+                                 &listener))
+      << listener.str();
 }
 
 TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
@@ -5881,7 +1868,6 @@ TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
   EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
 }
 
-
 TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
   const int a[5] = {2, 1, 4, 5, 3};
   EXPECT_THAT(a, UnorderedElementsAreArray({1, 2, 3, 4, 5}));
@@ -5896,10 +1882,10 @@ TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
 
 TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
   const int a[5] = {2, 1, 4, 5, 3};
-  EXPECT_THAT(a, UnorderedElementsAreArray(
-      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray(
-      {Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
+  EXPECT_THAT(a,
+              UnorderedElementsAreArray({Eq(1), Eq(2), Eq(3), Eq(4), Eq(5)}));
+  EXPECT_THAT(
+      a, Not(UnorderedElementsAreArray({Eq(1), Eq(2), Eq(3), Eq(4), Eq(6)})));
 }
 
 TEST(UnorderedElementsAreArrayTest,
@@ -5908,13 +1894,12 @@ TEST(UnorderedElementsAreArrayTest,
   // The compiler cannot infer the type of the initializer list if its
   // elements have different types.  We must explicitly specify the
   // unified element type in this case.
-  EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int> >(
-      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
-  EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int> >(
-      {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
+  EXPECT_THAT(a, UnorderedElementsAreArray<Matcher<int>>(
+                     {Eq(1), Ne(-2), Ge(3), Le(4), Eq(5)}));
+  EXPECT_THAT(a, Not(UnorderedElementsAreArray<Matcher<int>>(
+                     {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
 }
 
-
 TEST(UnorderedElementsAreArrayTest, WorksWithMoveOnly) {
   ContainerHelper helper;
   EXPECT_CALL(helper,
@@ -5940,22 +1925,22 @@ TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
   std::vector<int> s(std::begin(a), std::end(a));
   do {
     StringMatchResultListener listener;
-    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                   s, &listener)) << listener.str();
+    EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), s, &listener))
+        << listener.str();
   } while (std::next_permutation(s.begin(), s.end()));
 }
 
 TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
   const int a[] = {1, 2, 3};
   std::vector<int> s(std::begin(a), std::end(a));
-  std::vector<Matcher<int> > mv;
+  std::vector<Matcher<int>> mv;
   mv.push_back(1);
   mv.push_back(2);
   mv.push_back(2);
   // The element with value '3' matches nothing: fail fast.
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                  s, &listener)) << listener.str();
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv), s, &listener))
+      << listener.str();
 }
 
 TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
@@ -5983,15 +1968,15 @@ TEST_F(UnorderedElementsAreTest, WorksWithMoveOnly) {
 // [       OK ] UnorderedElementsAreTest.Performance (4 ms)
 TEST_F(UnorderedElementsAreTest, Performance) {
   std::vector<int> s;
-  std::vector<Matcher<int> > mv;
+  std::vector<Matcher<int>> mv;
   for (int i = 0; i < 100; ++i) {
     s.push_back(i);
     mv.push_back(_);
   }
   mv[50] = Eq(0);
   StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                 s, &listener)) << listener.str();
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv), s, &listener))
+      << listener.str();
 }
 
 // Another variant of 'Performance' with similar expectations.
@@ -5999,7 +1984,7 @@ TEST_F(UnorderedElementsAreTest, Performance) {
 // [       OK ] UnorderedElementsAreTest.PerformanceHalfStrict (4 ms)
 TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
   std::vector<int> s;
-  std::vector<Matcher<int> > mv;
+  std::vector<Matcher<int>> mv;
   for (int i = 0; i < 100; ++i) {
     s.push_back(i);
     if (i & 1) {
@@ -6009,24 +1994,24 @@ TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
     }
   }
   StringMatchResultListener listener;
-  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
-                                 s, &listener)) << listener.str();
+  EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv), s, &listener))
+      << listener.str();
 }
 
 TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
   std::vector<int> v;
   v.push_back(4);
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                  v, &listener)) << listener.str();
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
+      << listener.str();
   EXPECT_THAT(listener.str(), Eq("which has 1 element"));
 }
 
 TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
   std::vector<int> v;
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
-                                  v, &listener)) << listener.str();
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
+      << listener.str();
   EXPECT_THAT(listener.str(), Eq(""));
 }
 
@@ -6035,12 +2020,11 @@ TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
   v.push_back(1);
   v.push_back(1);
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where the following matchers don't match any elements:\n"
-         "matcher #1: is equal to 2"));
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2), v, &listener))
+      << listener.str();
+  EXPECT_THAT(listener.str(),
+              Eq("where the following matchers don't match any elements:\n"
+                 "matcher #1: is equal to 2"));
 }
 
 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
@@ -6048,12 +2032,11 @@ TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
   v.push_back(1);
   v.push_back(2);
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where the following elements don't match any matchers:\n"
-         "element #1: 2"));
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1), v, &listener))
+      << listener.str();
+  EXPECT_THAT(listener.str(),
+              Eq("where the following elements don't match any matchers:\n"
+                 "element #1: 2"));
 }
 
 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) {
@@ -6061,17 +2044,16 @@ TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement) {
   v.push_back(2);
   v.push_back(3);
   StringMatchResultListener listener;
-  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
-                                  v, &listener)) << listener.str();
-  EXPECT_THAT(
-      listener.str(),
-      Eq("where"
-         " the following matchers don't match any elements:\n"
-         "matcher #0: is equal to 1\n"
-         "and"
-         " where"
-         " the following elements don't match any matchers:\n"
-         "element #1: 3"));
+  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2), v, &listener))
+      << listener.str();
+  EXPECT_THAT(listener.str(),
+              Eq("where"
+                 " the following matchers don't match any elements:\n"
+                 "matcher #0: is equal to 1\n"
+                 "and"
+                 " where"
+                 " the following elements don't match any matchers:\n"
+                 "element #1: 3"));
 }
 
 // Test helper for formatting element, matcher index pairs in expectations.
@@ -6101,29 +2083,24 @@ TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
   // We have to be a bit loose here, because there are 4 valid max matches.
   EXPECT_THAT(
       listener.str(),
-      AnyOf(prefix + "{\n  " + EMString(0, 0) +
-                     ",\n  " + EMString(1, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 1) +
-                     ",\n  " + EMString(1, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 0) +
-                     ",\n  " + EMString(2, 2) + "\n}",
-            prefix + "{\n  " + EMString(0, 1) +
-                     ",\n  " + EMString(2, 2) + "\n}"));
+      AnyOf(
+          prefix + "{\n  " + EMString(0, 0) + ",\n  " + EMString(1, 2) + "\n}",
+          prefix + "{\n  " + EMString(0, 1) + ",\n  " + EMString(1, 2) + "\n}",
+          prefix + "{\n  " + EMString(0, 0) + ",\n  " + EMString(2, 2) + "\n}",
+          prefix + "{\n  " + EMString(0, 1) + ",\n  " + EMString(2, 2) +
+              "\n}"));
 }
 
 TEST_F(UnorderedElementsAreTest, Describe) {
-  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()),
-              Eq("is empty"));
-  EXPECT_THAT(
-      Describe<IntVec>(UnorderedElementsAre(345)),
-      Eq("has 1 element and that element is equal to 345"));
-  EXPECT_THAT(
-      Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
-      Eq("has 3 elements and there exists some permutation "
-         "of elements such that:\n"
-         " - element #0 is equal to 111, and\n"
-         " - element #1 is equal to 222, and\n"
-         " - element #2 is equal to 333"));
+  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()), Eq("is empty"));
+  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre(345)),
+              Eq("has 1 element and that element is equal to 345"));
+  EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
+              Eq("has 3 elements and there exists some permutation "
+                 "of elements such that:\n"
+                 " - element #0 is equal to 111, and\n"
+                 " - element #1 is equal to 222, and\n"
+                 " - element #2 is equal to 333"));
 }
 
 TEST_F(UnorderedElementsAreTest, DescribeNegation) {
@@ -6132,320 +2109,22 @@ TEST_F(UnorderedElementsAreTest, DescribeNegation) {
   EXPECT_THAT(
       DescribeNegation<IntVec>(UnorderedElementsAre(345)),
       Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
-  EXPECT_THAT(
-      DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
-      Eq("doesn't have 3 elements, or there exists no permutation "
-         "of elements such that:\n"
-         " - element #0 is equal to 123, and\n"
-         " - element #1 is equal to 234, and\n"
-         " - element #2 is equal to 345"));
-}
-
-namespace {
-
-// Used as a check on the more complex max flow method used in the
-// real testing::internal::FindMaxBipartiteMatching. This method is
-// compatible but runs in worst-case factorial time, so we only
-// use it in testing for small problem sizes.
-template <typename Graph>
-class BacktrackingMaxBPMState {
- public:
-  // Does not take ownership of 'g'.
-  explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) { }
-
-  ElementMatcherPairs Compute() {
-    if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
-      return best_so_far_;
-    }
-    lhs_used_.assign(graph_->LhsSize(), kUnused);
-    rhs_used_.assign(graph_->RhsSize(), kUnused);
-    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
-      matches_.clear();
-      RecurseInto(irhs);
-      if (best_so_far_.size() == graph_->RhsSize())
-        break;
-    }
-    return best_so_far_;
-  }
-
- private:
-  static const size_t kUnused = static_cast<size_t>(-1);
-
-  void PushMatch(size_t lhs, size_t rhs) {
-    matches_.push_back(ElementMatcherPair(lhs, rhs));
-    lhs_used_[lhs] = rhs;
-    rhs_used_[rhs] = lhs;
-    if (matches_.size() > best_so_far_.size()) {
-      best_so_far_ = matches_;
-    }
-  }
-
-  void PopMatch() {
-    const ElementMatcherPair& back = matches_.back();
-    lhs_used_[back.first] = kUnused;
-    rhs_used_[back.second] = kUnused;
-    matches_.pop_back();
-  }
-
-  bool RecurseInto(size_t irhs) {
-    if (rhs_used_[irhs] != kUnused) {
-      return true;
-    }
-    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
-      if (lhs_used_[ilhs] != kUnused) {
-        continue;
-      }
-      if (!graph_->HasEdge(ilhs, irhs)) {
-        continue;
-      }
-      PushMatch(ilhs, irhs);
-      if (best_so_far_.size() == graph_->RhsSize()) {
-        return false;
-      }
-      for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
-        if (!RecurseInto(mi)) return false;
-      }
-      PopMatch();
-    }
-    return true;
-  }
-
-  const Graph* graph_;  // not owned
-  std::vector<size_t> lhs_used_;
-  std::vector<size_t> rhs_used_;
-  ElementMatcherPairs matches_;
-  ElementMatcherPairs best_so_far_;
-};
-
-template <typename Graph>
-const size_t BacktrackingMaxBPMState<Graph>::kUnused;
-
-}  // namespace
-
-// Implement a simple backtracking algorithm to determine if it is possible
-// to find one element per matcher, without reusing elements.
-template <typename Graph>
-ElementMatcherPairs
-FindBacktrackingMaxBPM(const Graph& g) {
-  return BacktrackingMaxBPMState<Graph>(&g).Compute();
-}
-
-class BacktrackingBPMTest : public ::testing::Test { };
-
-// Tests the MaxBipartiteMatching algorithm with square matrices.
-// The single int param is the # of nodes on each of the left and right sides.
-class BipartiteTest : public ::testing::TestWithParam<size_t> {};
-
-// Verify all match graphs up to some moderate number of edges.
-TEST_P(BipartiteTest, Exhaustive) {
-  size_t nodes = GetParam();
-  MatchMatrix graph(nodes, nodes);
-  do {
-    ElementMatcherPairs matches =
-        internal::FindMaxBipartiteMatching(graph);
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
-        << "graph: " << graph.DebugString();
-    // Check that all elements of matches are in the graph.
-    // Check that elements of first and second are unique.
-    std::vector<bool> seen_element(graph.LhsSize());
-    std::vector<bool> seen_matcher(graph.RhsSize());
-    SCOPED_TRACE(PrintToString(matches));
-    for (size_t i = 0; i < matches.size(); ++i) {
-      size_t ilhs = matches[i].first;
-      size_t irhs = matches[i].second;
-      EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
-      EXPECT_FALSE(seen_element[ilhs]);
-      EXPECT_FALSE(seen_matcher[irhs]);
-      seen_element[ilhs] = true;
-      seen_matcher[irhs] = true;
-    }
-  } while (graph.NextGraph());
-}
-
-INSTANTIATE_TEST_SUITE_P(AllGraphs, BipartiteTest,
-                         ::testing::Range(size_t{0}, size_t{5}));
-
-// Parameterized by a pair interpreted as (LhsSize, RhsSize).
-class BipartiteNonSquareTest
-    : public ::testing::TestWithParam<std::pair<size_t, size_t> > {
-};
-
-TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
-  //   .......
-  // 0:-----\ :
-  // 1:---\ | :
-  // 2:---\ | :
-  // 3:-\ | | :
-  //  :.......:
-  //    0 1 2
-  MatchMatrix g(4, 3);
-  constexpr std::array<std::array<size_t, 2>, 4> kEdges = {
-      {{{0, 2}}, {{1, 1}}, {{2, 1}}, {{3, 0}}}};
-  for (size_t i = 0; i < kEdges.size(); ++i) {
-    g.SetEdge(kEdges[i][0], kEdges[i][1], true);
-  }
-  EXPECT_THAT(FindBacktrackingMaxBPM(g),
-              ElementsAre(Pair(3, 0),
-                          Pair(AnyOf(1, 2), 1),
-                          Pair(0, 2))) << g.DebugString();
-}
-
-// Verify a few nonsquare matrices.
-TEST_P(BipartiteNonSquareTest, Exhaustive) {
-  size_t nlhs = GetParam().first;
-  size_t nrhs = GetParam().second;
-  MatchMatrix graph(nlhs, nrhs);
-  do {
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
-              internal::FindMaxBipartiteMatching(graph).size())
-        << "graph: " << graph.DebugString()
-        << "\nbacktracking: "
-        << PrintToString(FindBacktrackingMaxBPM(graph))
-        << "\nmax flow: "
-        << PrintToString(internal::FindMaxBipartiteMatching(graph));
-  } while (graph.NextGraph());
-}
-
-INSTANTIATE_TEST_SUITE_P(AllGraphs, BipartiteNonSquareTest,
-    testing::Values(
-        std::make_pair(1, 2),
-        std::make_pair(2, 1),
-        std::make_pair(3, 2),
-        std::make_pair(2, 3),
-        std::make_pair(4, 1),
-        std::make_pair(1, 4),
-        std::make_pair(4, 3),
-        std::make_pair(3, 4)));
-
-class BipartiteRandomTest
-    : public ::testing::TestWithParam<std::pair<int, int> > {
-};
-
-// Verifies a large sample of larger graphs.
-TEST_P(BipartiteRandomTest, LargerNets) {
-  int nodes = GetParam().first;
-  int iters = GetParam().second;
-  MatchMatrix graph(static_cast<size_t>(nodes), static_cast<size_t>(nodes));
-
-  auto seed = static_cast<uint32_t>(GTEST_FLAG(random_seed));
-  if (seed == 0) {
-    seed = static_cast<uint32_t>(time(nullptr));
-  }
-
-  for (; iters > 0; --iters, ++seed) {
-    srand(static_cast<unsigned int>(seed));
-    graph.Randomize();
-    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
-              internal::FindMaxBipartiteMatching(graph).size())
-        << " graph: " << graph.DebugString()
-        << "\nTo reproduce the failure, rerun the test with the flag"
-           " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
-  }
-}
-
-// Test argument is a std::pair<int, int> representing (nodes, iters).
-INSTANTIATE_TEST_SUITE_P(Samples, BipartiteRandomTest,
-    testing::Values(
-        std::make_pair(5, 10000),
-        std::make_pair(6, 5000),
-        std::make_pair(7, 2000),
-        std::make_pair(8, 500),
-        std::make_pair(9, 100)));
-
-// Tests IsReadableTypeName().
-
-TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
-  EXPECT_TRUE(IsReadableTypeName("int"));
-  EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
-  EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
-  EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
-  EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
-  EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
-  EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
-  EXPECT_FALSE(
-      IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
-  EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
-}
-
-TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
-  EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
-}
-
-// Tests FormatMatcherDescription().
-
-TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
-  EXPECT_EQ("is even",
-            FormatMatcherDescription(false, "IsEven", Strings()));
-  EXPECT_EQ("not (is even)",
-            FormatMatcherDescription(true, "IsEven", Strings()));
-
-  const char* params[] = {"5"};
-  EXPECT_EQ("equals 5",
-            FormatMatcherDescription(false, "Equals",
-                                     Strings(params, params + 1)));
-
-  const char* params2[] = {"5", "8"};
-  EXPECT_EQ("is in range (5, 8)",
-            FormatMatcherDescription(false, "IsInRange",
-                                     Strings(params2, params2 + 2)));
-}
-
-// Tests PolymorphicMatcher::mutable_impl().
-TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
-  PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
-  DivisibleByImpl& impl = m.mutable_impl();
-  EXPECT_EQ(42, impl.divider());
-
-  impl.set_divider(0);
-  EXPECT_EQ(0, m.mutable_impl().divider());
-}
-
-// Tests PolymorphicMatcher::impl().
-TEST(PolymorphicMatcherTest, CanAccessImpl) {
-  const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
-  const DivisibleByImpl& impl = m.impl();
-  EXPECT_EQ(42, impl.divider());
-}
-
-TEST(MatcherTupleTest, ExplainsMatchFailure) {
-  stringstream ss1;
-  ExplainMatchFailureTupleTo(
-      std::make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
-      std::make_tuple('a', 10), &ss1);
-  EXPECT_EQ("", ss1.str());  // Successful match.
-
-  stringstream ss2;
-  ExplainMatchFailureTupleTo(
-      std::make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
-      std::make_tuple(2, 'b'), &ss2);
-  EXPECT_EQ("  Expected arg #0: is > 5\n"
-            "           Actual: 2, which is 3 less than 5\n"
-            "  Expected arg #1: is equal to 'a' (97, 0x61)\n"
-            "           Actual: 'b' (98, 0x62)\n",
-            ss2.str());  // Failed match where both arguments need explanation.
-
-  stringstream ss3;
-  ExplainMatchFailureTupleTo(
-      std::make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
-      std::make_tuple(2, 'a'), &ss3);
-  EXPECT_EQ("  Expected arg #0: is > 5\n"
-            "           Actual: 2, which is 3 less than 5\n",
-            ss3.str());  // Failed match where only one argument needs
-                         // explanation.
+  EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
+              Eq("doesn't have 3 elements, or there exists no permutation "
+                 "of elements such that:\n"
+                 " - element #0 is equal to 123, and\n"
+                 " - element #1 is equal to 234, and\n"
+                 " - element #2 is equal to 345"));
 }
 
 // Tests Each().
 
-TEST(EachTest, ExplainsMatchResultCorrectly) {
+INSTANTIATE_GTEST_MATCHER_TEST_P(EachTest);
+
+TEST_P(EachTestP, ExplainsMatchResultCorrectly) {
   set<int> a;  // empty
 
-  Matcher<set<int> > m = Each(2);
+  Matcher<set<int>> m = Each(2);
   EXPECT_EQ("", Explain(m, a));
 
   Matcher<const int(&)[1]> n = Each(1);  // NOLINT
@@ -6468,10 +2147,10 @@ TEST(EachTest, ExplainsMatchResultCorrectly) {
 }
 
 TEST(EachTest, DescribesItselfCorrectly) {
-  Matcher<vector<int> > m = Each(1);
+  Matcher<vector<int>> m = Each(1);
   EXPECT_EQ("only contains elements that is equal to 1", Describe(m));
 
-  Matcher<vector<int> > m2 = Not(m);
+  Matcher<vector<int>> m2 = Not(m);
   EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2));
 }
 
@@ -6566,13 +2245,15 @@ TEST(PointwiseTest, DescribesSelf) {
   rhs.push_back(2);
   rhs.push_back(3);
   const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
-  EXPECT_EQ("contains 3 values, where each value and its corresponding value "
-            "in { 1, 2, 3 } are a pair where the first is half of the second",
-            Describe(m));
-  EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
-            "index i where x and the i-th value of { 1, 2, 3 } are a pair "
-            "where the first isn't half of the second",
-            DescribeNegation(m));
+  EXPECT_EQ(
+      "contains 3 values, where each value and its corresponding value "
+      "in { 1, 2, 3 } are a pair where the first is half of the second",
+      Describe(m));
+  EXPECT_EQ(
+      "doesn't contain exactly 3 values, or contains a value x at some "
+      "index i where x and the i-th value of { 1, 2, 3 } are a pair "
+      "where the first isn't half of the second",
+      DescribeNegation(m));
 }
 
 TEST(PointwiseTest, MakesCopyOfRhs) {
@@ -6581,7 +2262,7 @@ TEST(PointwiseTest, MakesCopyOfRhs) {
   rhs.push_back(4);
 
   int lhs[] = {1, 2};
-  const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
+  const Matcher<const int(&)[2]> m = Pointwise(IsHalfOf(), rhs);
   EXPECT_THAT(lhs, m);
 
   // Changing rhs now shouldn't affect m, which made a copy of rhs.
@@ -6619,20 +2300,17 @@ TEST(PointwiseTest, WorksForVectorOfBool) {
   EXPECT_THAT(lhs, Not(Pointwise(Eq(), rhs)));
 }
 
-
 TEST(PointwiseTest, WorksForRhsInitializerList) {
   const vector<int> lhs{2, 4, 6};
   EXPECT_THAT(lhs, Pointwise(Gt(), {1, 2, 3}));
   EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7})));
 }
 
-
 TEST(PointwiseTest, RejectsWrongSize) {
   const double lhs[2] = {1, 2};
   const int rhs[1] = {0};
   EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
-  EXPECT_EQ("which contains 2 values",
-            Explain(Pointwise(Gt(), rhs), lhs));
+  EXPECT_EQ("which contains 2 values", Explain(Pointwise(Gt(), rhs), lhs));
 
   const int rhs2[3] = {0, 1, 2};
   EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2)));
@@ -6642,9 +2320,10 @@ TEST(PointwiseTest, RejectsWrongContent) {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 6, 4};
   EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs)));
-  EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
-            "where the second/2 is 3",
-            Explain(Pointwise(IsHalfOf(), rhs), lhs));
+  EXPECT_EQ(
+      "where the value pair (2, 6) at index #1 don't match, "
+      "where the second/2 is 3",
+      Explain(Pointwise(IsHalfOf(), rhs), lhs));
 }
 
 TEST(PointwiseTest, AcceptsCorrectContent) {
@@ -6711,7 +2390,7 @@ TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
   rhs.push_back(4);
 
   int lhs[] = {2, 1};
-  const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
+  const Matcher<const int(&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
   EXPECT_THAT(lhs, m);
 
   // Changing rhs now shouldn't affect m, which made a copy of rhs.
@@ -6739,14 +2418,12 @@ TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
 }
 
-
 TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
   const vector<int> lhs{2, 4, 6};
   EXPECT_THAT(lhs, UnorderedPointwise(Gt(), {5, 1, 3}));
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
 }
 
-
 TEST(UnorderedPointwiseTest, RejectsWrongSize) {
   const double lhs[2] = {1, 2};
   const int rhs[1] = {0};
@@ -6762,9 +2439,10 @@ TEST(UnorderedPointwiseTest, RejectsWrongContent) {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 6, 6};
   EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs)));
-  EXPECT_EQ("where the following elements don't match any matchers:\n"
-            "element #1: 2",
-            Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
+  EXPECT_EQ(
+      "where the following elements don't match any matchers:\n"
+      "element #1: 2",
+      Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
 }
 
 TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
@@ -6798,335 +2476,12 @@ TEST(UnorderedPointwiseTest, WorksWithMoveOnly) {
   helper.Call(MakeUniquePtrs({2, 1}));
 }
 
-// Sample optional type implementation with minimal requirements for use with
-// Optional matcher.
-template <typename T>
-class SampleOptional {
- public:
-  using value_type = T;
-  explicit SampleOptional(T value)
-      : value_(std::move(value)), has_value_(true) {}
-  SampleOptional() : value_(), has_value_(false) {}
-  operator bool() const { return has_value_; }
-  const T& operator*() const { return value_; }
-
- private:
-  T value_;
-  bool has_value_;
-};
-
-TEST(OptionalTest, DescribesSelf) {
-  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
-  EXPECT_EQ("value is equal to 1", Describe(m));
-}
-
-TEST(OptionalTest, ExplainsSelf) {
-  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
-  EXPECT_EQ("whose value 1 matches", Explain(m, SampleOptional<int>(1)));
-  EXPECT_EQ("whose value 2 doesn't match", Explain(m, SampleOptional<int>(2)));
-}
-
-TEST(OptionalTest, MatchesNonEmptyOptional) {
-  const Matcher<SampleOptional<int>> m1 = Optional(1);
-  const Matcher<SampleOptional<int>> m2 = Optional(Eq(2));
-  const Matcher<SampleOptional<int>> m3 = Optional(Lt(3));
-  SampleOptional<int> opt(1);
-  EXPECT_TRUE(m1.Matches(opt));
-  EXPECT_FALSE(m2.Matches(opt));
-  EXPECT_TRUE(m3.Matches(opt));
-}
-
-TEST(OptionalTest, DoesNotMatchNullopt) {
-  const Matcher<SampleOptional<int>> m = Optional(1);
-  SampleOptional<int> empty;
-  EXPECT_FALSE(m.Matches(empty));
-}
-
-TEST(OptionalTest, WorksWithMoveOnly) {
-  Matcher<SampleOptional<std::unique_ptr<int>>> m = Optional(Eq(nullptr));
-  EXPECT_TRUE(m.Matches(SampleOptional<std::unique_ptr<int>>(nullptr)));
-}
-
-class SampleVariantIntString {
- public:
-  SampleVariantIntString(int i) : i_(i), has_int_(true) {}
-  SampleVariantIntString(const std::string& s) : s_(s), has_int_(false) {}
-
-  template <typename T>
-  friend bool holds_alternative(const SampleVariantIntString& value) {
-    return value.has_int_ == std::is_same<T, int>::value;
-  }
-
-  template <typename T>
-  friend const T& get(const SampleVariantIntString& value) {
-    return value.get_impl(static_cast<T*>(nullptr));
-  }
-
- private:
-  const int& get_impl(int*) const { return i_; }
-  const std::string& get_impl(std::string*) const { return s_; }
-
-  int i_;
-  std::string s_;
-  bool has_int_;
-};
-
-TEST(VariantTest, DescribesSelf) {
-  const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
-  EXPECT_THAT(Describe(m), ContainsRegex("is a variant<> with value of type "
-                                         "'.*' and the value is equal to 1"));
-}
-
-TEST(VariantTest, ExplainsSelf) {
-  const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
-  EXPECT_THAT(Explain(m, SampleVariantIntString(1)),
-              ContainsRegex("whose value 1"));
-  EXPECT_THAT(Explain(m, SampleVariantIntString("A")),
-              HasSubstr("whose value is not of type '"));
-  EXPECT_THAT(Explain(m, SampleVariantIntString(2)),
-              "whose value 2 doesn't match");
-}
-
-TEST(VariantTest, FullMatch) {
-  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
-  EXPECT_TRUE(m.Matches(SampleVariantIntString(1)));
-
-  m = VariantWith<std::string>(Eq("1"));
-  EXPECT_TRUE(m.Matches(SampleVariantIntString("1")));
-}
-
-TEST(VariantTest, TypeDoesNotMatch) {
-  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
-  EXPECT_FALSE(m.Matches(SampleVariantIntString("1")));
-
-  m = VariantWith<std::string>(Eq("1"));
-  EXPECT_FALSE(m.Matches(SampleVariantIntString(1)));
-}
-
-TEST(VariantTest, InnerDoesNotMatch) {
-  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
-  EXPECT_FALSE(m.Matches(SampleVariantIntString(2)));
-
-  m = VariantWith<std::string>(Eq("1"));
-  EXPECT_FALSE(m.Matches(SampleVariantIntString("2")));
-}
-
-class SampleAnyType {
- public:
-  explicit SampleAnyType(int i) : index_(0), i_(i) {}
-  explicit SampleAnyType(const std::string& s) : index_(1), s_(s) {}
-
-  template <typename T>
-  friend const T* any_cast(const SampleAnyType* any) {
-    return any->get_impl(static_cast<T*>(nullptr));
-  }
-
- private:
-  int index_;
-  int i_;
-  std::string s_;
-
-  const int* get_impl(int*) const { return index_ == 0 ? &i_ : nullptr; }
-  const std::string* get_impl(std::string*) const {
-    return index_ == 1 ? &s_ : nullptr;
-  }
-};
-
-TEST(AnyWithTest, FullMatch) {
-  Matcher<SampleAnyType> m = AnyWith<int>(Eq(1));
-  EXPECT_TRUE(m.Matches(SampleAnyType(1)));
-}
-
-TEST(AnyWithTest, TestBadCastType) {
-  Matcher<SampleAnyType> m = AnyWith<std::string>(Eq("fail"));
-  EXPECT_FALSE(m.Matches(SampleAnyType(1)));
-}
-
-TEST(AnyWithTest, TestUseInContainers) {
-  std::vector<SampleAnyType> a;
-  a.emplace_back(1);
-  a.emplace_back(2);
-  a.emplace_back(3);
-  EXPECT_THAT(
-      a, ElementsAreArray({AnyWith<int>(1), AnyWith<int>(2), AnyWith<int>(3)}));
-
-  std::vector<SampleAnyType> b;
-  b.emplace_back("hello");
-  b.emplace_back("merhaba");
-  b.emplace_back("salut");
-  EXPECT_THAT(b, ElementsAreArray({AnyWith<std::string>("hello"),
-                                   AnyWith<std::string>("merhaba"),
-                                   AnyWith<std::string>("salut")}));
-}
-TEST(AnyWithTest, TestCompare) {
-  EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0)));
-}
-
-TEST(AnyWithTest, DescribesSelf) {
-  const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
-  EXPECT_THAT(Describe(m), ContainsRegex("is an 'any' type with value of type "
-                                         "'.*' and the value is equal to 1"));
-}
-
-TEST(AnyWithTest, ExplainsSelf) {
-  const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
-
-  EXPECT_THAT(Explain(m, SampleAnyType(1)), ContainsRegex("whose value 1"));
-  EXPECT_THAT(Explain(m, SampleAnyType("A")),
-              HasSubstr("whose value is not of type '"));
-  EXPECT_THAT(Explain(m, SampleAnyType(2)), "whose value 2 doesn't match");
-}
-
 TEST(PointeeTest, WorksOnMoveOnlyType) {
   std::unique_ptr<int> p(new int(3));
   EXPECT_THAT(p, Pointee(Eq(3)));
   EXPECT_THAT(p, Not(Pointee(Eq(2))));
 }
 
-TEST(NotTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
-  EXPECT_THAT(p, Pointee(Eq(3)));
-  EXPECT_THAT(p, Not(Pointee(Eq(2))));
-}
-
-// Tests Args<k0, ..., kn>(m).
-
-TEST(ArgsTest, AcceptsZeroTemplateArg) {
-  const std::tuple<int, bool> t(5, true);
-  EXPECT_THAT(t, Args<>(Eq(std::tuple<>())));
-  EXPECT_THAT(t, Not(Args<>(Ne(std::tuple<>()))));
-}
-
-TEST(ArgsTest, AcceptsOneTemplateArg) {
-  const std::tuple<int, bool> t(5, true);
-  EXPECT_THAT(t, Args<0>(Eq(std::make_tuple(5))));
-  EXPECT_THAT(t, Args<1>(Eq(std::make_tuple(true))));
-  EXPECT_THAT(t, Not(Args<1>(Eq(std::make_tuple(false)))));
-}
-
-TEST(ArgsTest, AcceptsTwoTemplateArgs) {
-  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-
-  EXPECT_THAT(t, (Args<0, 1>(Lt())));
-  EXPECT_THAT(t, (Args<1, 2>(Lt())));
-  EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
-}
-
-TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
-  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-  EXPECT_THAT(t, (Args<0, 0>(Eq())));
-  EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
-}
-
-TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
-  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
-  EXPECT_THAT(t, (Args<2, 0>(Gt())));
-  EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
-}
-
-MATCHER(SumIsZero, "") {
-  return std::get<0>(arg) + std::get<1>(arg) + std::get<2>(arg) == 0;
-}
-
-TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
-  EXPECT_THAT(std::make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
-  EXPECT_THAT(std::make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
-}
-
-TEST(ArgsTest, CanBeNested) {
-  const std::tuple<short, int, long, int> t(4, 5, 6L, 6);  // NOLINT
-  EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
-  EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
-}
-
-TEST(ArgsTest, CanMatchTupleByValue) {
-  typedef std::tuple<char, int, int> Tuple3;
-  const Matcher<Tuple3> m = Args<1, 2>(Lt());
-  EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2)));
-  EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2)));
-}
-
-TEST(ArgsTest, CanMatchTupleByReference) {
-  typedef std::tuple<char, char, int> Tuple3;
-  const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
-  EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2)));
-  EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2)));
-}
-
-// Validates that arg is printed as str.
-MATCHER_P(PrintsAs, str, "") {
-  return testing::PrintToString(arg) == str;
-}
-
-TEST(ArgsTest, AcceptsTenTemplateArgs) {
-  EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
-              (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
-                  PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
-  EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
-              Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
-                  PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
-}
-
-TEST(ArgsTest, DescirbesSelfCorrectly) {
-  const Matcher<std::tuple<int, bool, char> > m = Args<2, 0>(Lt());
-  EXPECT_EQ("are a tuple whose fields (#2, #0) are a pair where "
-            "the first < the second",
-            Describe(m));
-}
-
-TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
-  const Matcher<const std::tuple<int, bool, char, int>&> m =
-      Args<0, 2, 3>(Args<2, 0>(Lt()));
-  EXPECT_EQ("are a tuple whose fields (#0, #2, #3) are a tuple "
-            "whose fields (#2, #0) are a pair where the first < the second",
-            Describe(m));
-}
-
-TEST(ArgsTest, DescribesNegationCorrectly) {
-  const Matcher<std::tuple<int, char> > m = Args<1, 0>(Gt());
-  EXPECT_EQ("are a tuple whose fields (#1, #0) aren't a pair "
-            "where the first > the second",
-            DescribeNegation(m));
-}
-
-TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
-  const Matcher<std::tuple<bool, int, int> > m = Args<1, 2>(Eq());
-  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
-            Explain(m, std::make_tuple(false, 42, 42)));
-  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
-            Explain(m, std::make_tuple(false, 42, 43)));
-}
-
-// For testing Args<>'s explanation.
-class LessThanMatcher : public MatcherInterface<std::tuple<char, int> > {
- public:
-  void DescribeTo(::std::ostream* /*os*/) const override {}
-
-  bool MatchAndExplain(std::tuple<char, int> value,
-                       MatchResultListener* listener) const override {
-    const int diff = std::get<0>(value) - std::get<1>(value);
-    if (diff > 0) {
-      *listener << "where the first value is " << diff
-                << " more than the second";
-    }
-    return diff < 0;
-  }
-};
-
-Matcher<std::tuple<char, int> > LessThan() {
-  return MakeMatcher(new LessThanMatcher);
-}
-
-TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
-  const Matcher<std::tuple<char, int, int> > m = Args<0, 2>(LessThan());
-  EXPECT_EQ(
-      "whose fields (#0, #2) are ('a' (97, 0x61), 42), "
-      "where the first value is 55 more than the second",
-      Explain(m, std::make_tuple('a', 42, 42)));
-  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
-            Explain(m, std::make_tuple('\0', 42, 43)));
-}
-
 class PredicateFormatterFromMatcherTest : public ::testing::Test {
  protected:
   enum Behavior { kInitialSuccess, kAlwaysFail, kFlaky };
@@ -7231,7 +2586,7 @@ TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
   EXPECT_EQ("isn't empty", DescribeNegation(m));
 }
 
-TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) {
+TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElement) {
   Matcher<const list<int>&> m = ElementsAre(Gt(5));
   EXPECT_EQ(
       "doesn't have 1 element, or\n"
@@ -7257,7 +2612,7 @@ TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
   EXPECT_EQ("", Explain(m, test_list));  // No need to explain anything.
 }
 
-TEST(ElementsAreTest, ExplainsNonTrivialMatch) {
+TEST_P(ElementsAreTestP, ExplainsNonTrivialMatch) {
   Matcher<const vector<int>&> m =
       ElementsAre(GreaterThan(1), 0, GreaterThan(2));
 
@@ -7280,7 +2635,7 @@ TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
   EXPECT_EQ("which has 1 element", Explain(m, test_list));
 }
 
-TEST(ElementsAreTest, CanExplainMismatchRightSize) {
+TEST_P(ElementsAreTestP, CanExplainMismatchRightSize) {
   Matcher<const vector<int>&> m = ElementsAre(1, GreaterThan(5));
 
   vector<int> v;
@@ -7428,7 +2783,10 @@ class NativeArrayPassedAsPointerAndSize {
   MOCK_METHOD(void, Helper, (int* array, int size));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
+  NativeArrayPassedAsPointerAndSize(const NativeArrayPassedAsPointerAndSize&) =
+      delete;
+  NativeArrayPassedAsPointerAndSize& operator=(
+      const NativeArrayPassedAsPointerAndSize&) = delete;
 };
 
 TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
@@ -7601,7 +2959,7 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
 }
 
 // Since ElementsAre() and ElementsAreArray() share much of the
-// implementation, we only do a sanity test for native arrays here.
+// implementation, we only do a test for native arrays here.
 TEST(ElementsAreArrayTest, WorksWithNativeArray) {
   ::std::string a[] = {"hi", "ho"};
   ::std::string b[] = {"hi", "ho"};
@@ -7628,401 +2986,16 @@ TEST(ElementsAreArrayTest, SourceLifeSpan) {
   EXPECT_THAT(test_vector, Not(matcher_maker));
 }
 
-// Tests for the MATCHER*() macro family.
-
-// Tests that a simple MATCHER() definition works.
-
-MATCHER(IsEven, "") { return (arg % 2) == 0; }
-
-TEST(MatcherMacroTest, Works) {
-  const Matcher<int> m = IsEven();
-  EXPECT_TRUE(m.Matches(6));
-  EXPECT_FALSE(m.Matches(7));
-
-  EXPECT_EQ("is even", Describe(m));
-  EXPECT_EQ("not (is even)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 6));
-  EXPECT_EQ("", Explain(m, 7));
-}
-
-// This also tests that the description string can reference 'negation'.
-MATCHER(IsEven2, negation ? "is odd" : "is even") {
-  if ((arg % 2) == 0) {
-    // Verifies that we can stream to result_listener, a listener
-    // supplied by the MATCHER macro implicitly.
-    *result_listener << "OK";
-    return true;
-  } else {
-    *result_listener << "% 2 == " << (arg % 2);
-    return false;
-  }
-}
-
-// This also tests that the description string can reference matcher
-// parameters.
-MATCHER_P2(EqSumOf, x, y,
-           std::string(negation ? "doesn't equal" : "equals") + " the sum of " +
-               PrintToString(x) + " and " + PrintToString(y)) {
-  if (arg == (x + y)) {
-    *result_listener << "OK";
-    return true;
-  } else {
-    // Verifies that we can stream to the underlying stream of
-    // result_listener.
-    if (result_listener->stream() != nullptr) {
-      *result_listener->stream() << "diff == " << (x + y - arg);
-    }
-    return false;
-  }
-}
-
-// Tests that the matcher description can reference 'negation' and the
-// matcher parameters.
-TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
-  const Matcher<int> m1 = IsEven2();
-  EXPECT_EQ("is even", Describe(m1));
-  EXPECT_EQ("is odd", DescribeNegation(m1));
-
-  const Matcher<int> m2 = EqSumOf(5, 9);
-  EXPECT_EQ("equals the sum of 5 and 9", Describe(m2));
-  EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2));
-}
-
-// Tests explaining match result in a MATCHER* macro.
-TEST(MatcherMacroTest, CanExplainMatchResult) {
-  const Matcher<int> m1 = IsEven2();
-  EXPECT_EQ("OK", Explain(m1, 4));
-  EXPECT_EQ("% 2 == 1", Explain(m1, 5));
-
-  const Matcher<int> m2 = EqSumOf(1, 2);
-  EXPECT_EQ("OK", Explain(m2, 3));
-  EXPECT_EQ("diff == -1", Explain(m2, 4));
-}
-
-// Tests that the body of MATCHER() can reference the type of the
-// value being matched.
-
-MATCHER(IsEmptyString, "") {
-  StaticAssertTypeEq<::std::string, arg_type>();
-  return arg.empty();
-}
-
-MATCHER(IsEmptyStringByRef, "") {
-  StaticAssertTypeEq<const ::std::string&, arg_type>();
-  return arg.empty();
-}
-
-TEST(MatcherMacroTest, CanReferenceArgType) {
-  const Matcher<::std::string> m1 = IsEmptyString();
-  EXPECT_TRUE(m1.Matches(""));
-
-  const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
-  EXPECT_TRUE(m2.Matches(""));
-}
-
-// Tests that MATCHER() can be used in a namespace.
-
-namespace matcher_test {
-MATCHER(IsOdd, "") { return (arg % 2) != 0; }
-}  // namespace matcher_test
-
-TEST(MatcherMacroTest, WorksInNamespace) {
-  Matcher<int> m = matcher_test::IsOdd();
-  EXPECT_FALSE(m.Matches(4));
-  EXPECT_TRUE(m.Matches(5));
-}
-
-// Tests that Value() can be used to compose matchers.
-MATCHER(IsPositiveOdd, "") {
-  return Value(arg, matcher_test::IsOdd()) && arg > 0;
-}
-
-TEST(MatcherMacroTest, CanBeComposedUsingValue) {
-  EXPECT_THAT(3, IsPositiveOdd());
-  EXPECT_THAT(4, Not(IsPositiveOdd()));
-  EXPECT_THAT(-1, Not(IsPositiveOdd()));
-}
-
-// Tests that a simple MATCHER_P() definition works.
-
-MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }
-
-TEST(MatcherPMacroTest, Works) {
-  const Matcher<int> m = IsGreaterThan32And(5);
-  EXPECT_TRUE(m.Matches(36));
-  EXPECT_FALSE(m.Matches(5));
-
-  EXPECT_EQ("is greater than 32 and 5", Describe(m));
-  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36));
-  EXPECT_EQ("", Explain(m, 5));
-}
-
-// Tests that the description is calculated correctly from the matcher name.
-MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
-
-TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
-  const Matcher<int> m = _is_Greater_Than32and_(5);
-
-  EXPECT_EQ("is greater than 32 and 5", Describe(m));
-  EXPECT_EQ("not (is greater than 32 and 5)", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36));
-  EXPECT_EQ("", Explain(m, 5));
-}
-
-// Tests that a MATCHER_P matcher can be explicitly instantiated with
-// a reference parameter type.
-
-class UncopyableFoo {
- public:
-  explicit UncopyableFoo(char value) : value_(value) { (void)value_; }
-
-  UncopyableFoo(const UncopyableFoo&) = delete;
-  void operator=(const UncopyableFoo&) = delete;
-
- private:
-  char value_;
-};
-
-MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }
-
-TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
-  UncopyableFoo foo1('1'), foo2('2');
-  const Matcher<const UncopyableFoo&> m =
-      ReferencesUncopyable<const UncopyableFoo&>(foo1);
-
-  EXPECT_TRUE(m.Matches(foo1));
-  EXPECT_FALSE(m.Matches(foo2));
-
-  // We don't want the address of the parameter printed, as most
-  // likely it will just annoy the user.  If the address is
-  // interesting, the user should consider passing the parameter by
-  // pointer instead.
-  EXPECT_EQ("references uncopyable 1-byte object <31>", Describe(m));
-}
-
-// Tests that the body of MATCHER_Pn() can reference the parameter
-// types.
-
-MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") {
-  StaticAssertTypeEq<int, foo_type>();
-  StaticAssertTypeEq<long, bar_type>();  // NOLINT
-  StaticAssertTypeEq<char, baz_type>();
-  return arg == 0;
-}
-
-TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
-  EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a'));
-}
-
-// Tests that a MATCHER_Pn matcher can be explicitly instantiated with
-// reference parameter types.
-
-MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
-  return &arg == &variable1 || &arg == &variable2;
-}
-
-TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
-  UncopyableFoo foo1('1'), foo2('2'), foo3('3');
-  const Matcher<const UncopyableFoo&> const_m =
-      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
-
-  EXPECT_TRUE(const_m.Matches(foo1));
-  EXPECT_TRUE(const_m.Matches(foo2));
-  EXPECT_FALSE(const_m.Matches(foo3));
-
-  const Matcher<UncopyableFoo&> m =
-      ReferencesAnyOf<UncopyableFoo&, UncopyableFoo&>(foo1, foo2);
-
-  EXPECT_TRUE(m.Matches(foo1));
-  EXPECT_TRUE(m.Matches(foo2));
-  EXPECT_FALSE(m.Matches(foo3));
-}
-
-TEST(MatcherPnMacroTest,
-     GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
-  UncopyableFoo foo1('1'), foo2('2');
-  const Matcher<const UncopyableFoo&> m =
-      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
-
-  // We don't want the addresses of the parameters printed, as most
-  // likely they will just annoy the user.  If the addresses are
-  // interesting, the user should consider passing the parameters by
-  // pointers instead.
-  EXPECT_EQ("references any of (1-byte object <31>, 1-byte object <32>)",
-            Describe(m));
-}
-
-// Tests that a simple MATCHER_P2() definition works.
-
-MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }
-
-TEST(MatcherPnMacroTest, Works) {
-  const Matcher<const long&> m = IsNotInClosedRange(10, 20);  // NOLINT
-  EXPECT_TRUE(m.Matches(36L));
-  EXPECT_FALSE(m.Matches(15L));
-
-  EXPECT_EQ("is not in closed range (10, 20)", Describe(m));
-  EXPECT_EQ("not (is not in closed range (10, 20))", DescribeNegation(m));
-  EXPECT_EQ("", Explain(m, 36L));
-  EXPECT_EQ("", Explain(m, 15L));
-}
-
-// Tests that MATCHER*() definitions can be overloaded on the number
-// of parameters; also tests MATCHER_Pn() where n >= 3.
-
-MATCHER(EqualsSumOf, "") { return arg == 0; }
-MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
-MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
-MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
-MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
-MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
-MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
-  return arg == a + b + c + d + e + f;
-}
-MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
-  return arg == a + b + c + d + e + f + g;
-}
-MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
-  return arg == a + b + c + d + e + f + g + h;
-}
-MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
-  return arg == a + b + c + d + e + f + g + h + i;
-}
-MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") {
-  return arg == a + b + c + d + e + f + g + h + i + j;
-}
-
-TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
-  EXPECT_THAT(0, EqualsSumOf());
-  EXPECT_THAT(1, EqualsSumOf(1));
-  EXPECT_THAT(12, EqualsSumOf(10, 2));
-  EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
-  EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
-  EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
-  EXPECT_THAT("abcdef",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'));
-  EXPECT_THAT("abcdefg",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g'));
-  EXPECT_THAT("abcdefgh", EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e",
-                                      'f', 'g', "h"));
-  EXPECT_THAT("abcdefghi", EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e",
-                                       'f', 'g', "h", 'i'));
-  EXPECT_THAT("abcdefghij",
-              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', "h",
-                          'i', ::std::string("j")));
-
-  EXPECT_THAT(1, Not(EqualsSumOf()));
-  EXPECT_THAT(-1, Not(EqualsSumOf(1)));
-  EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
-  EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
-  EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
-  EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
-  EXPECT_THAT("abcdef ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')));
-  EXPECT_THAT("abcdefg ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
-                                          "e", 'f', 'g')));
-  EXPECT_THAT("abcdefgh ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
-                                           "e", 'f', 'g', "h")));
-  EXPECT_THAT("abcdefghi ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
-                                            "e", 'f', 'g', "h", 'i')));
-  EXPECT_THAT("abcdefghij ",
-              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
-                              "h", 'i', ::std::string("j"))));
-}
-
-// Tests that a MATCHER_Pn() definition can be instantiated with any
-// compatible parameter types.
-TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
-  EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3)));
-  EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d"));
-
-  EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
-  EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
-}
-
-// Tests that the matcher body can promote the parameter types.
-
-MATCHER_P2(EqConcat, prefix, suffix, "") {
-  // The following lines promote the two parameters to desired types.
-  std::string prefix_str(prefix);
-  char suffix_char = static_cast<char>(suffix);
-  return arg == prefix_str + suffix_char;
-}
-
-TEST(MatcherPnMacroTest, SimpleTypePromotion) {
-  Matcher<std::string> no_promo = EqConcat(std::string("foo"), 't');
-  Matcher<const std::string&> promo = EqConcat("foo", static_cast<int>('t'));
-  EXPECT_FALSE(no_promo.Matches("fool"));
-  EXPECT_FALSE(promo.Matches("fool"));
-  EXPECT_TRUE(no_promo.Matches("foot"));
-  EXPECT_TRUE(promo.Matches("foot"));
-}
-
-// Verifies the type of a MATCHER*.
-
-TEST(MatcherPnMacroTest, TypesAreCorrect) {
-  // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable.
-  EqualsSumOfMatcher a0 = EqualsSumOf();
-
-  // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable.
-  EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);
-
-  // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk
-  // variable, and so on.
-  EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2');
-  EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3');
-  EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4');
-  EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
-      EqualsSumOf(1, 2, 3, 4, '5');
-  EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
-      EqualsSumOf(1, 2, 3, 4, 5, '6');
-  EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, '7');
-  EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8');
-  EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9');
-  EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
-      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
-
-  // Avoid "unused variable" warnings.
-  (void)a0;
-  (void)a1;
-  (void)a2;
-  (void)a3;
-  (void)a4;
-  (void)a5;
-  (void)a6;
-  (void)a7;
-  (void)a8;
-  (void)a9;
-  (void)a10;
-}
-
-// Tests that matcher-typed parameters can be used in Value() inside a
-// MATCHER_Pn definition.
-
-// Succeeds if arg matches exactly 2 of the 3 matchers.
-MATCHER_P3(TwoOf, m1, m2, m3, "") {
-  const int count = static_cast<int>(Value(arg, m1)) +
-                    static_cast<int>(Value(arg, m2)) +
-                    static_cast<int>(Value(arg, m3));
-  return count == 2;
-}
-
-TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
-  EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
-  EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
-}
-
 // Tests Contains().
 
+INSTANTIATE_GTEST_MATCHER_TEST_P(ContainsTest);
+
 TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
   list<int> some_list;
   some_list.push_back(3);
   some_list.push_back(1);
   some_list.push_back(2);
+  some_list.push_back(3);
   EXPECT_THAT(some_list, Contains(1));
   EXPECT_THAT(some_list, Contains(Gt(2.5)));
   EXPECT_THAT(some_list, Contains(Eq(2.0f)));
@@ -8070,7 +3043,7 @@ TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
   EXPECT_THAT(c_string_set, Not(Contains(std::string("goodbye"))));
 }
 
-TEST(ContainsTest, ExplainsMatchResultCorrectly) {
+TEST_P(ContainsTestP, ExplainsMatchResultCorrectly) {
   const int a[2] = {1, 2};
   Matcher<const int(&)[2]> m = Contains(2);
   EXPECT_EQ("whose element #1 matches", Explain(m, a));
@@ -8147,416 +3120,10 @@ TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
   EXPECT_THAT(a, Contains(Not(Contains(5))));
 }
 
-TEST(AllOfArrayTest, BasicForms) {
-  // Iterator
-  std::vector<int> v0{};
-  std::vector<int> v1{1};
-  std::vector<int> v2{2, 3};
-  std::vector<int> v3{4, 4, 4};
-  EXPECT_THAT(0, AllOfArray(v0.begin(), v0.end()));
-  EXPECT_THAT(1, AllOfArray(v1.begin(), v1.end()));
-  EXPECT_THAT(2, Not(AllOfArray(v1.begin(), v1.end())));
-  EXPECT_THAT(3, Not(AllOfArray(v2.begin(), v2.end())));
-  EXPECT_THAT(4, AllOfArray(v3.begin(), v3.end()));
-  // Pointer +  size
-  int ar[6] = {1, 2, 3, 4, 4, 4};
-  EXPECT_THAT(0, AllOfArray(ar, 0));
-  EXPECT_THAT(1, AllOfArray(ar, 1));
-  EXPECT_THAT(2, Not(AllOfArray(ar, 1)));
-  EXPECT_THAT(3, Not(AllOfArray(ar + 1, 3)));
-  EXPECT_THAT(4, AllOfArray(ar + 3, 3));
-  // Array
-  // int ar0[0];  Not usable
-  int ar1[1] = {1};
-  int ar2[2] = {2, 3};
-  int ar3[3] = {4, 4, 4};
-  // EXPECT_THAT(0, Not(AllOfArray(ar0)));  // Cannot work
-  EXPECT_THAT(1, AllOfArray(ar1));
-  EXPECT_THAT(2, Not(AllOfArray(ar1)));
-  EXPECT_THAT(3, Not(AllOfArray(ar2)));
-  EXPECT_THAT(4, AllOfArray(ar3));
-  // Container
-  EXPECT_THAT(0, AllOfArray(v0));
-  EXPECT_THAT(1, AllOfArray(v1));
-  EXPECT_THAT(2, Not(AllOfArray(v1)));
-  EXPECT_THAT(3, Not(AllOfArray(v2)));
-  EXPECT_THAT(4, AllOfArray(v3));
-  // Initializer
-  EXPECT_THAT(0, AllOfArray<int>({}));  // Requires template arg.
-  EXPECT_THAT(1, AllOfArray({1}));
-  EXPECT_THAT(2, Not(AllOfArray({1})));
-  EXPECT_THAT(3, Not(AllOfArray({2, 3})));
-  EXPECT_THAT(4, AllOfArray({4, 4, 4}));
-}
-
-TEST(AllOfArrayTest, Matchers) {
-  // vector
-  std::vector<Matcher<int>> matchers{Ge(1), Lt(2)};
-  EXPECT_THAT(0, Not(AllOfArray(matchers)));
-  EXPECT_THAT(1, AllOfArray(matchers));
-  EXPECT_THAT(2, Not(AllOfArray(matchers)));
-  // initializer_list
-  EXPECT_THAT(0, Not(AllOfArray({Ge(0), Ge(1)})));
-  EXPECT_THAT(1, AllOfArray({Ge(0), Ge(1)}));
-}
-
-TEST(AnyOfArrayTest, BasicForms) {
-  // Iterator
-  std::vector<int> v0{};
-  std::vector<int> v1{1};
-  std::vector<int> v2{2, 3};
-  EXPECT_THAT(0, Not(AnyOfArray(v0.begin(), v0.end())));
-  EXPECT_THAT(1, AnyOfArray(v1.begin(), v1.end()));
-  EXPECT_THAT(2, Not(AnyOfArray(v1.begin(), v1.end())));
-  EXPECT_THAT(3, AnyOfArray(v2.begin(), v2.end()));
-  EXPECT_THAT(4, Not(AnyOfArray(v2.begin(), v2.end())));
-  // Pointer +  size
-  int ar[3] = {1, 2, 3};
-  EXPECT_THAT(0, Not(AnyOfArray(ar, 0)));
-  EXPECT_THAT(1, AnyOfArray(ar, 1));
-  EXPECT_THAT(2, Not(AnyOfArray(ar, 1)));
-  EXPECT_THAT(3, AnyOfArray(ar + 1, 2));
-  EXPECT_THAT(4, Not(AnyOfArray(ar + 1, 2)));
-  // Array
-  // int ar0[0];  Not usable
-  int ar1[1] = {1};
-  int ar2[2] = {2, 3};
-  // EXPECT_THAT(0, Not(AnyOfArray(ar0)));  // Cannot work
-  EXPECT_THAT(1, AnyOfArray(ar1));
-  EXPECT_THAT(2, Not(AnyOfArray(ar1)));
-  EXPECT_THAT(3, AnyOfArray(ar2));
-  EXPECT_THAT(4, Not(AnyOfArray(ar2)));
-  // Container
-  EXPECT_THAT(0, Not(AnyOfArray(v0)));
-  EXPECT_THAT(1, AnyOfArray(v1));
-  EXPECT_THAT(2, Not(AnyOfArray(v1)));
-  EXPECT_THAT(3, AnyOfArray(v2));
-  EXPECT_THAT(4, Not(AnyOfArray(v2)));
-  // Initializer
-  EXPECT_THAT(0, Not(AnyOfArray<int>({})));  // Requires template arg.
-  EXPECT_THAT(1, AnyOfArray({1}));
-  EXPECT_THAT(2, Not(AnyOfArray({1})));
-  EXPECT_THAT(3, AnyOfArray({2, 3}));
-  EXPECT_THAT(4, Not(AnyOfArray({2, 3})));
-}
-
-TEST(AnyOfArrayTest, Matchers) {
-  // We negate test AllOfArrayTest.Matchers.
-  // vector
-  std::vector<Matcher<int>> matchers{Lt(1), Ge(2)};
-  EXPECT_THAT(0, AnyOfArray(matchers));
-  EXPECT_THAT(1, Not(AnyOfArray(matchers)));
-  EXPECT_THAT(2, AnyOfArray(matchers));
-  // initializer_list
-  EXPECT_THAT(0, AnyOfArray({Lt(0), Lt(1)}));
-  EXPECT_THAT(1, Not(AllOfArray({Lt(0), Lt(1)})));
-}
-
-TEST(AnyOfArrayTest, ExplainsMatchResultCorrectly) {
-  // AnyOfArray and AllOfArry use the same underlying template-template,
-  // thus it is sufficient to test one here.
-  const std::vector<int> v0{};
-  const std::vector<int> v1{1};
-  const std::vector<int> v2{2, 3};
-  const Matcher<int> m0 = AnyOfArray(v0);
-  const Matcher<int> m1 = AnyOfArray(v1);
-  const Matcher<int> m2 = AnyOfArray(v2);
-  EXPECT_EQ("", Explain(m0, 0));
-  EXPECT_EQ("", Explain(m1, 1));
-  EXPECT_EQ("", Explain(m1, 2));
-  EXPECT_EQ("", Explain(m2, 3));
-  EXPECT_EQ("", Explain(m2, 4));
-  EXPECT_EQ("()", Describe(m0));
-  EXPECT_EQ("(is equal to 1)", Describe(m1));
-  EXPECT_EQ("(is equal to 2) or (is equal to 3)", Describe(m2));
-  EXPECT_EQ("()", DescribeNegation(m0));
-  EXPECT_EQ("(isn't equal to 1)", DescribeNegation(m1));
-  EXPECT_EQ("(isn't equal to 2) and (isn't equal to 3)", DescribeNegation(m2));
-  // Explain with matchers
-  const Matcher<int> g1 = AnyOfArray({GreaterThan(1)});
-  const Matcher<int> g2 = AnyOfArray({GreaterThan(1), GreaterThan(2)});
-  // Explains the first positiv match and all prior negative matches...
-  EXPECT_EQ("which is 1 less than 1", Explain(g1, 0));
-  EXPECT_EQ("which is the same as 1", Explain(g1, 1));
-  EXPECT_EQ("which is 1 more than 1", Explain(g1, 2));
-  EXPECT_EQ("which is 1 less than 1, and which is 2 less than 2",
-            Explain(g2, 0));
-  EXPECT_EQ("which is the same as 1, and which is 1 less than 2",
-            Explain(g2, 1));
-  EXPECT_EQ("which is 1 more than 1",  // Only the first
-            Explain(g2, 2));
-}
-
-TEST(AllOfTest, HugeMatcher) {
-  // Verify that using AllOf with many arguments doesn't cause
-  // the compiler to exceed template instantiation depth limit.
-  EXPECT_THAT(0, testing::AllOf(_, _, _, _, _, _, _, _, _,
-                                testing::AllOf(_, _, _, _, _, _, _, _, _, _)));
-}
-
-TEST(AnyOfTest, HugeMatcher) {
-  // Verify that using AnyOf with many arguments doesn't cause
-  // the compiler to exceed template instantiation depth limit.
-  EXPECT_THAT(0, testing::AnyOf(_, _, _, _, _, _, _, _, _,
-                                testing::AnyOf(_, _, _, _, _, _, _, _, _, _)));
-}
-
-namespace adl_test {
-
-// Verifies that the implementation of ::testing::AllOf and ::testing::AnyOf
-// don't issue unqualified recursive calls.  If they do, the argument dependent
-// name lookup will cause AllOf/AnyOf in the 'adl_test' namespace to be found
-// as a candidate and the compilation will break due to an ambiguous overload.
-
-// The matcher must be in the same namespace as AllOf/AnyOf to make argument
-// dependent lookup find those.
-MATCHER(M, "") {
-  (void)arg;
-  return true;
-}
-
-template <typename T1, typename T2>
-bool AllOf(const T1& /*t1*/, const T2& /*t2*/) {
-  return true;
-}
-
-TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
-  EXPECT_THAT(42,
-              testing::AllOf(M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
-}
-
-template <typename T1, typename T2>
-bool AnyOf(const T1&, const T2&) {
-  return true;
-}
-
-TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
-  EXPECT_THAT(42,
-              testing::AnyOf(M(), M(), M(), M(), M(), M(), M(), M(), M(), M()));
-}
-
-}  // namespace adl_test
-
-TEST(AllOfTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
-  EXPECT_THAT(p, AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(5))));
-  EXPECT_THAT(p, Not(AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(3)))));
-}
-
-TEST(AnyOfTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
-  EXPECT_THAT(p, AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Lt(5))));
-  EXPECT_THAT(p, Not(AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Gt(5)))));
-}
-
-MATCHER(IsNotNull, "") { return arg != nullptr; }
-
-// Verifies that a matcher defined using MATCHER() can work on
-// move-only types.
-TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
-  EXPECT_THAT(p, IsNotNull());
-  EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull()));
-}
-
-MATCHER_P(UniquePointee, pointee, "") { return *arg == pointee; }
-
-// Verifies that a matcher defined using MATCHER_P*() can work on
-// move-only types.
-TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
-  EXPECT_THAT(p, UniquePointee(3));
-  EXPECT_THAT(p, Not(UniquePointee(2)));
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-// std::function<void()> is used below for compatibility with older copies of
-// GCC. Normally, a raw lambda is all that is needed.
-
-// Test that examples from documentation compile
-TEST(ThrowsTest, Examples) {
-  EXPECT_THAT(
-      std::function<void()>([]() { throw std::runtime_error("message"); }),
-      Throws<std::runtime_error>());
-
-  EXPECT_THAT(
-      std::function<void()>([]() { throw std::runtime_error("message"); }),
-      ThrowsMessage<std::runtime_error>(HasSubstr("message")));
-}
-
-TEST(ThrowsTest, DoesNotGenerateDuplicateCatchClauseWarning) {
-  EXPECT_THAT(std::function<void()>([]() { throw std::exception(); }),
-              Throws<std::exception>());
-}
-
-TEST(ThrowsTest, CallableExecutedExactlyOnce) {
-  size_t a = 0;
-
-  EXPECT_THAT(std::function<void()>([&a]() {
-                a++;
-                throw 10;
-              }),
-              Throws<int>());
-  EXPECT_EQ(a, 1u);
-
-  EXPECT_THAT(std::function<void()>([&a]() {
-                a++;
-                throw std::runtime_error("message");
-              }),
-              Throws<std::runtime_error>());
-  EXPECT_EQ(a, 2u);
-
-  EXPECT_THAT(std::function<void()>([&a]() {
-                a++;
-                throw std::runtime_error("message");
-              }),
-              ThrowsMessage<std::runtime_error>(HasSubstr("message")));
-  EXPECT_EQ(a, 3u);
-
-  EXPECT_THAT(std::function<void()>([&a]() {
-                a++;
-                throw std::runtime_error("message");
-              }),
-              Throws<std::runtime_error>(
-                  Property(&std::runtime_error::what, HasSubstr("message"))));
-  EXPECT_EQ(a, 4u);
-}
-
-TEST(ThrowsTest, Describe) {
-  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
-  std::stringstream ss;
-  matcher.DescribeTo(&ss);
-  auto explanation = ss.str();
-  EXPECT_THAT(explanation, HasSubstr("std::runtime_error"));
-}
-
-TEST(ThrowsTest, Success) {
-  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
-  StringMatchResultListener listener;
-  EXPECT_TRUE(matcher.MatchAndExplain(
-      []() { throw std::runtime_error("error message"); }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("std::runtime_error"));
-}
-
-TEST(ThrowsTest, FailWrongType) {
-  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain(
-      []() { throw std::logic_error("error message"); }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("std::logic_error"));
-  EXPECT_THAT(listener.str(), HasSubstr("\"error message\""));
-}
-
-TEST(ThrowsTest, FailWrongTypeNonStd) {
-  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
-  EXPECT_THAT(listener.str(),
-              HasSubstr("throws an exception of an unknown type"));
-}
-
-TEST(ThrowsTest, FailNoThrow) {
-  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain([]() { (void)0; }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("does not throw any exception"));
-}
-
-class ThrowsPredicateTest
-    : public TestWithParam<Matcher<std::function<void()>>> {};
-
-TEST_P(ThrowsPredicateTest, Describe) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  std::stringstream ss;
-  matcher.DescribeTo(&ss);
-  auto explanation = ss.str();
-  EXPECT_THAT(explanation, HasSubstr("std::runtime_error"));
-  EXPECT_THAT(explanation, HasSubstr("error message"));
-}
-
-TEST_P(ThrowsPredicateTest, Success) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  StringMatchResultListener listener;
-  EXPECT_TRUE(matcher.MatchAndExplain(
-      []() { throw std::runtime_error("error message"); }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("std::runtime_error"));
-}
-
-TEST_P(ThrowsPredicateTest, FailWrongType) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain(
-      []() { throw std::logic_error("error message"); }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("std::logic_error"));
-  EXPECT_THAT(listener.str(), HasSubstr("\"error message\""));
-}
-
-TEST_P(ThrowsPredicateTest, FailWrongTypeNonStd) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
-  EXPECT_THAT(listener.str(),
-              HasSubstr("throws an exception of an unknown type"));
-}
-
-TEST_P(ThrowsPredicateTest, FailWrongMessage) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain(
-      []() { throw std::runtime_error("wrong message"); }, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("std::runtime_error"));
-  EXPECT_THAT(listener.str(), Not(HasSubstr("wrong message")));
-}
-
-TEST_P(ThrowsPredicateTest, FailNoThrow) {
-  Matcher<std::function<void()>> matcher = GetParam();
-  StringMatchResultListener listener;
-  EXPECT_FALSE(matcher.MatchAndExplain([]() {}, &listener));
-  EXPECT_THAT(listener.str(), HasSubstr("does not throw any exception"));
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    AllMessagePredicates, ThrowsPredicateTest,
-    Values(Matcher<std::function<void()>>(
-        ThrowsMessage<std::runtime_error>(HasSubstr("error message")))));
-
-// Tests that Throws<E1>(Matcher<E2>{}) compiles even when E2 != const E1&.
-TEST(ThrowsPredicateCompilesTest, ExceptionMatcherAcceptsBroadType) {
-  {
-    Matcher<std::function<void()>> matcher =
-        ThrowsMessage<std::runtime_error>(HasSubstr("error message"));
-    EXPECT_TRUE(
-        matcher.Matches([]() { throw std::runtime_error("error message"); }));
-    EXPECT_FALSE(
-        matcher.Matches([]() { throw std::runtime_error("wrong message"); }));
-  }
-
-  {
-    Matcher<uint64_t> inner = Eq(10);
-    Matcher<std::function<void()>> matcher = Throws<uint32_t>(inner);
-    EXPECT_TRUE(matcher.Matches([]() { throw(uint32_t) 10; }));
-    EXPECT_FALSE(matcher.Matches([]() { throw(uint32_t) 11; }));
-  }
-}
-
-// Tests that ThrowsMessage("message") is equivalent
-// to ThrowsMessage(Eq<std::string>("message")).
-TEST(ThrowsPredicateCompilesTest, MessageMatcherAcceptsNonMatcher) {
-  Matcher<std::function<void()>> matcher =
-      ThrowsMessage<std::runtime_error>("error message");
-  EXPECT_TRUE(
-      matcher.Matches([]() { throw std::runtime_error("error message"); }));
-  EXPECT_FALSE(matcher.Matches(
-      []() { throw std::runtime_error("wrong error message"); }));
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
 }  // namespace
 }  // namespace gmock_matchers_test
 }  // namespace testing
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
diff --git a/googletest/googlemock/test/gmock-matchers-misc_test.cc b/googletest/googlemock/test/gmock-matchers-misc_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..42a0e44d7f498be08bc9bf2b34a1fd2905c23eb8
--- /dev/null
+++ b/googletest/googlemock/test/gmock-matchers-misc_test.cc
@@ -0,0 +1,1819 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
+
+// Silence warning C4244: 'initializing': conversion from 'int' to 'short',
+// possible loss of data and C4100, unreferenced local parameter
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4100)
+#endif
+
+#include "test/gmock-matchers_test.h"
+
+namespace testing {
+namespace gmock_matchers_test {
+namespace {
+
+TEST(AddressTest, NonConst) {
+  int n = 1;
+  const Matcher<int> m = Address(Eq(&n));
+
+  EXPECT_TRUE(m.Matches(n));
+
+  int other = 5;
+
+  EXPECT_FALSE(m.Matches(other));
+
+  int& n_ref = n;
+
+  EXPECT_TRUE(m.Matches(n_ref));
+}
+
+TEST(AddressTest, Const) {
+  const int n = 1;
+  const Matcher<int> m = Address(Eq(&n));
+
+  EXPECT_TRUE(m.Matches(n));
+
+  int other = 5;
+
+  EXPECT_FALSE(m.Matches(other));
+}
+
+TEST(AddressTest, MatcherDoesntCopy) {
+  std::unique_ptr<int> n(new int(1));
+  const Matcher<std::unique_ptr<int>> m = Address(Eq(&n));
+
+  EXPECT_TRUE(m.Matches(n));
+}
+
+TEST(AddressTest, Describe) {
+  Matcher<int> matcher = Address(_);
+  EXPECT_EQ("has address that is anything", Describe(matcher));
+  EXPECT_EQ("does not have address that is anything",
+            DescribeNegation(matcher));
+}
+
+// The following two tests verify that values without a public copy
+// ctor can be used as arguments to matchers like Eq(), Ge(), and etc
+// with the help of ByRef().
+
+class NotCopyable {
+ public:
+  explicit NotCopyable(int a_value) : value_(a_value) {}
+
+  int value() const { return value_; }
+
+  bool operator==(const NotCopyable& rhs) const {
+    return value() == rhs.value();
+  }
+
+  bool operator>=(const NotCopyable& rhs) const {
+    return value() >= rhs.value();
+  }
+
+ private:
+  int value_;
+
+  NotCopyable(const NotCopyable&) = delete;
+  NotCopyable& operator=(const NotCopyable&) = delete;
+};
+
+TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
+  const NotCopyable const_value1(1);
+  const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
+
+  const NotCopyable n1(1), n2(2);
+  EXPECT_TRUE(m.Matches(n1));
+  EXPECT_FALSE(m.Matches(n2));
+}
+
+TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
+  NotCopyable value2(2);
+  const Matcher<NotCopyable&> m = Ge(ByRef(value2));
+
+  NotCopyable n1(1), n2(2);
+  EXPECT_FALSE(m.Matches(n1));
+  EXPECT_TRUE(m.Matches(n2));
+}
+
+TEST(IsEmptyTest, ImplementsIsEmpty) {
+  vector<int> container;
+  EXPECT_THAT(container, IsEmpty());
+  container.push_back(0);
+  EXPECT_THAT(container, Not(IsEmpty()));
+  container.push_back(1);
+  EXPECT_THAT(container, Not(IsEmpty()));
+}
+
+TEST(IsEmptyTest, WorksWithString) {
+  std::string text;
+  EXPECT_THAT(text, IsEmpty());
+  text = "foo";
+  EXPECT_THAT(text, Not(IsEmpty()));
+  text = std::string("\0", 1);
+  EXPECT_THAT(text, Not(IsEmpty()));
+}
+
+TEST(IsEmptyTest, CanDescribeSelf) {
+  Matcher<vector<int>> m = IsEmpty();
+  EXPECT_EQ("is empty", Describe(m));
+  EXPECT_EQ("isn't empty", DescribeNegation(m));
+}
+
+TEST(IsEmptyTest, ExplainsResult) {
+  Matcher<vector<int>> m = IsEmpty();
+  vector<int> container;
+  EXPECT_EQ("", Explain(m, container));
+  container.push_back(0);
+  EXPECT_EQ("whose size is 1", Explain(m, container));
+}
+
+TEST(IsEmptyTest, WorksWithMoveOnly) {
+  ContainerHelper helper;
+  EXPECT_CALL(helper, Call(IsEmpty()));
+  helper.Call({});
+}
+
+TEST(IsTrueTest, IsTrueIsFalse) {
+  EXPECT_THAT(true, IsTrue());
+  EXPECT_THAT(false, IsFalse());
+  EXPECT_THAT(true, Not(IsFalse()));
+  EXPECT_THAT(false, Not(IsTrue()));
+  EXPECT_THAT(0, Not(IsTrue()));
+  EXPECT_THAT(0, IsFalse());
+  EXPECT_THAT(nullptr, Not(IsTrue()));
+  EXPECT_THAT(nullptr, IsFalse());
+  EXPECT_THAT(-1, IsTrue());
+  EXPECT_THAT(-1, Not(IsFalse()));
+  EXPECT_THAT(1, IsTrue());
+  EXPECT_THAT(1, Not(IsFalse()));
+  EXPECT_THAT(2, IsTrue());
+  EXPECT_THAT(2, Not(IsFalse()));
+  int a = 42;
+  EXPECT_THAT(a, IsTrue());
+  EXPECT_THAT(a, Not(IsFalse()));
+  EXPECT_THAT(&a, IsTrue());
+  EXPECT_THAT(&a, Not(IsFalse()));
+  EXPECT_THAT(false, Not(IsTrue()));
+  EXPECT_THAT(true, Not(IsFalse()));
+  EXPECT_THAT(std::true_type(), IsTrue());
+  EXPECT_THAT(std::true_type(), Not(IsFalse()));
+  EXPECT_THAT(std::false_type(), IsFalse());
+  EXPECT_THAT(std::false_type(), Not(IsTrue()));
+  EXPECT_THAT(nullptr, Not(IsTrue()));
+  EXPECT_THAT(nullptr, IsFalse());
+  std::unique_ptr<int> null_unique;
+  std::unique_ptr<int> nonnull_unique(new int(0));
+  EXPECT_THAT(null_unique, Not(IsTrue()));
+  EXPECT_THAT(null_unique, IsFalse());
+  EXPECT_THAT(nonnull_unique, IsTrue());
+  EXPECT_THAT(nonnull_unique, Not(IsFalse()));
+}
+
+#if GTEST_HAS_TYPED_TEST
+// Tests ContainerEq with different container types, and
+// different element types.
+
+template <typename T>
+class ContainerEqTest : public testing::Test {};
+
+typedef testing::Types<set<int>, vector<size_t>, multiset<size_t>, list<int>>
+    ContainerEqTestTypes;
+
+TYPED_TEST_SUITE(ContainerEqTest, ContainerEqTestTypes);
+
+// Tests that the filled container is equal to itself.
+TYPED_TEST(ContainerEqTest, EqualsSelf) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  TypeParam my_set(vals, vals + 6);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_TRUE(m.Matches(my_set));
+  EXPECT_EQ("", Explain(m, my_set));
+}
+
+// Tests that missing values are reported.
+TYPED_TEST(ContainerEqTest, ValueMissing) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {2, 1, 8, 5};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 4);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3",
+            Explain(m, test_set));
+}
+
+// Tests that added values are reported.
+TYPED_TEST(ContainerEqTest, ValueAdded) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8, 46};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 6);
+  const Matcher<const TypeParam&> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
+}
+
+// Tests that added and missing values are reported together.
+TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 8, 46};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 5);
+  const Matcher<TypeParam> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ(
+      "which has these unexpected elements: 46,\n"
+      "and doesn't have these expected elements: 5",
+      Explain(m, test_set));
+}
+
+// Tests duplicated value -- expect no explanation.
+TYPED_TEST(ContainerEqTest, DuplicateDifference) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8};
+  TypeParam my_set(vals, vals + 6);
+  TypeParam test_set(test_vals, test_vals + 5);
+  const Matcher<const TypeParam&> m = ContainerEq(my_set);
+  // Depending on the container, match may be true or false
+  // But in any case there should be no explanation.
+  EXPECT_EQ("", Explain(m, test_set));
+}
+#endif  // GTEST_HAS_TYPED_TEST
+
+// Tests that multiple missing values are reported.
+// Using just vector here, so order is predictable.
+TEST(ContainerEqExtraTest, MultipleValuesMissing) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {2, 1, 5};
+  vector<int> my_set(vals, vals + 6);
+  vector<int> test_set(test_vals, test_vals + 3);
+  const Matcher<vector<int>> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3, 8",
+            Explain(m, test_set));
+}
+
+// Tests that added values are reported.
+// Using just vector here, so order is predictable.
+TEST(ContainerEqExtraTest, MultipleValuesAdded) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
+  list<size_t> my_set(vals, vals + 6);
+  list<size_t> test_set(test_vals, test_vals + 7);
+  const Matcher<const list<size_t>&> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ("which has these unexpected elements: 92, 46",
+            Explain(m, test_set));
+}
+
+// Tests that added and missing values are reported together.
+TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 92, 46};
+  list<size_t> my_set(vals, vals + 6);
+  list<size_t> test_set(test_vals, test_vals + 5);
+  const Matcher<const list<size_t>> m = ContainerEq(my_set);
+  EXPECT_FALSE(m.Matches(test_set));
+  EXPECT_EQ(
+      "which has these unexpected elements: 92, 46,\n"
+      "and doesn't have these expected elements: 5, 8",
+      Explain(m, test_set));
+}
+
+// Tests to see that duplicate elements are detected,
+// but (as above) not reported in the explanation.
+TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
+  static const int vals[] = {1, 1, 2, 3, 5, 8};
+  static const int test_vals[] = {1, 2, 3, 5, 8};
+  vector<int> my_set(vals, vals + 6);
+  vector<int> test_set(test_vals, test_vals + 5);
+  const Matcher<vector<int>> m = ContainerEq(my_set);
+  EXPECT_TRUE(m.Matches(my_set));
+  EXPECT_FALSE(m.Matches(test_set));
+  // There is nothing to report when both sets contain all the same values.
+  EXPECT_EQ("", Explain(m, test_set));
+}
+
+// Tests that ContainerEq works for non-trivial associative containers,
+// like maps.
+TEST(ContainerEqExtraTest, WorksForMaps) {
+  map<int, std::string> my_map;
+  my_map[0] = "a";
+  my_map[1] = "b";
+
+  map<int, std::string> test_map;
+  test_map[0] = "aa";
+  test_map[1] = "b";
+
+  const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
+  EXPECT_TRUE(m.Matches(my_map));
+  EXPECT_FALSE(m.Matches(test_map));
+
+  EXPECT_EQ(
+      "which has these unexpected elements: (0, \"aa\"),\n"
+      "and doesn't have these expected elements: (0, \"a\")",
+      Explain(m, test_map));
+}
+
+TEST(ContainerEqExtraTest, WorksForNativeArray) {
+  int a1[] = {1, 2, 3};
+  int a2[] = {1, 2, 3};
+  int b[] = {1, 2, 4};
+
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+}
+
+TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
+  const char a1[][3] = {"hi", "lo"};
+  const char a2[][3] = {"hi", "lo"};
+  const char b[][3] = {"lo", "hi"};
+
+  // Tests using ContainerEq() in the first dimension.
+  EXPECT_THAT(a1, ContainerEq(a2));
+  EXPECT_THAT(a1, Not(ContainerEq(b)));
+
+  // Tests using ContainerEq() in the second dimension.
+  EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
+  EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
+}
+
+TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
+  const int a1[] = {1, 2, 3};
+  const int a2[] = {1, 2, 3};
+  const int b[] = {1, 2, 3, 4};
+
+  const int* const p1 = a1;
+  EXPECT_THAT(std::make_tuple(p1, 3), ContainerEq(a2));
+  EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(b)));
+
+  const int c[] = {1, 3, 2};
+  EXPECT_THAT(std::make_tuple(p1, 3), Not(ContainerEq(c)));
+}
+
+TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
+  std::string a1[][3] = {{"hi", "hello", "ciao"}, {"bye", "see you", "ciao"}};
+
+  std::string a2[][3] = {{"hi", "hello", "ciao"}, {"bye", "see you", "ciao"}};
+
+  const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
+  EXPECT_THAT(a1, m);
+
+  a2[0][0] = "ha";
+  EXPECT_THAT(a1, m);
+}
+
+namespace {
+
+// Used as a check on the more complex max flow method used in the
+// real testing::internal::FindMaxBipartiteMatching. This method is
+// compatible but runs in worst-case factorial time, so we only
+// use it in testing for small problem sizes.
+template <typename Graph>
+class BacktrackingMaxBPMState {
+ public:
+  // Does not take ownership of 'g'.
+  explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) {}
+
+  ElementMatcherPairs Compute() {
+    if (graph_->LhsSize() == 0 || graph_->RhsSize() == 0) {
+      return best_so_far_;
+    }
+    lhs_used_.assign(graph_->LhsSize(), kUnused);
+    rhs_used_.assign(graph_->RhsSize(), kUnused);
+    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
+      matches_.clear();
+      RecurseInto(irhs);
+      if (best_so_far_.size() == graph_->RhsSize()) break;
+    }
+    return best_so_far_;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  void PushMatch(size_t lhs, size_t rhs) {
+    matches_.push_back(ElementMatcherPair(lhs, rhs));
+    lhs_used_[lhs] = rhs;
+    rhs_used_[rhs] = lhs;
+    if (matches_.size() > best_so_far_.size()) {
+      best_so_far_ = matches_;
+    }
+  }
+
+  void PopMatch() {
+    const ElementMatcherPair& back = matches_.back();
+    lhs_used_[back.first] = kUnused;
+    rhs_used_[back.second] = kUnused;
+    matches_.pop_back();
+  }
+
+  bool RecurseInto(size_t irhs) {
+    if (rhs_used_[irhs] != kUnused) {
+      return true;
+    }
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      if (lhs_used_[ilhs] != kUnused) {
+        continue;
+      }
+      if (!graph_->HasEdge(ilhs, irhs)) {
+        continue;
+      }
+      PushMatch(ilhs, irhs);
+      if (best_so_far_.size() == graph_->RhsSize()) {
+        return false;
+      }
+      for (size_t mi = irhs + 1; mi < graph_->RhsSize(); ++mi) {
+        if (!RecurseInto(mi)) return false;
+      }
+      PopMatch();
+    }
+    return true;
+  }
+
+  const Graph* graph_;  // not owned
+  std::vector<size_t> lhs_used_;
+  std::vector<size_t> rhs_used_;
+  ElementMatcherPairs matches_;
+  ElementMatcherPairs best_so_far_;
+};
+
+template <typename Graph>
+const size_t BacktrackingMaxBPMState<Graph>::kUnused;
+
+}  // namespace
+
+// Implement a simple backtracking algorithm to determine if it is possible
+// to find one element per matcher, without reusing elements.
+template <typename Graph>
+ElementMatcherPairs FindBacktrackingMaxBPM(const Graph& g) {
+  return BacktrackingMaxBPMState<Graph>(&g).Compute();
+}
+
+class BacktrackingBPMTest : public ::testing::Test {};
+
+// Tests the MaxBipartiteMatching algorithm with square matrices.
+// The single int param is the # of nodes on each of the left and right sides.
+class BipartiteTest : public ::testing::TestWithParam<size_t> {};
+
+// Verify all match graphs up to some moderate number of edges.
+TEST_P(BipartiteTest, Exhaustive) {
+  size_t nodes = GetParam();
+  MatchMatrix graph(nodes, nodes);
+  do {
+    ElementMatcherPairs matches = internal::FindMaxBipartiteMatching(graph);
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
+        << "graph: " << graph.DebugString();
+    // Check that all elements of matches are in the graph.
+    // Check that elements of first and second are unique.
+    std::vector<bool> seen_element(graph.LhsSize());
+    std::vector<bool> seen_matcher(graph.RhsSize());
+    SCOPED_TRACE(PrintToString(matches));
+    for (size_t i = 0; i < matches.size(); ++i) {
+      size_t ilhs = matches[i].first;
+      size_t irhs = matches[i].second;
+      EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
+      EXPECT_FALSE(seen_element[ilhs]);
+      EXPECT_FALSE(seen_matcher[irhs]);
+      seen_element[ilhs] = true;
+      seen_matcher[irhs] = true;
+    }
+  } while (graph.NextGraph());
+}
+
+INSTANTIATE_TEST_SUITE_P(AllGraphs, BipartiteTest,
+                         ::testing::Range(size_t{0}, size_t{5}));
+
+// Parameterized by a pair interpreted as (LhsSize, RhsSize).
+class BipartiteNonSquareTest
+    : public ::testing::TestWithParam<std::pair<size_t, size_t>> {};
+
+TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
+  //   .......
+  // 0:-----\ :
+  // 1:---\ | :
+  // 2:---\ | :
+  // 3:-\ | | :
+  //  :.......:
+  //    0 1 2
+  MatchMatrix g(4, 3);
+  constexpr std::array<std::array<size_t, 2>, 4> kEdges = {
+      {{{0, 2}}, {{1, 1}}, {{2, 1}}, {{3, 0}}}};
+  for (size_t i = 0; i < kEdges.size(); ++i) {
+    g.SetEdge(kEdges[i][0], kEdges[i][1], true);
+  }
+  EXPECT_THAT(FindBacktrackingMaxBPM(g),
+              ElementsAre(Pair(3, 0), Pair(AnyOf(1, 2), 1), Pair(0, 2)))
+      << g.DebugString();
+}
+
+// Verify a few nonsquare matrices.
+TEST_P(BipartiteNonSquareTest, Exhaustive) {
+  size_t nlhs = GetParam().first;
+  size_t nrhs = GetParam().second;
+  MatchMatrix graph(nlhs, nrhs);
+  do {
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
+              internal::FindMaxBipartiteMatching(graph).size())
+        << "graph: " << graph.DebugString()
+        << "\nbacktracking: " << PrintToString(FindBacktrackingMaxBPM(graph))
+        << "\nmax flow: "
+        << PrintToString(internal::FindMaxBipartiteMatching(graph));
+  } while (graph.NextGraph());
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    AllGraphs, BipartiteNonSquareTest,
+    testing::Values(std::make_pair(1, 2), std::make_pair(2, 1),
+                    std::make_pair(3, 2), std::make_pair(2, 3),
+                    std::make_pair(4, 1), std::make_pair(1, 4),
+                    std::make_pair(4, 3), std::make_pair(3, 4)));
+
+class BipartiteRandomTest
+    : public ::testing::TestWithParam<std::pair<int, int>> {};
+
+// Verifies a large sample of larger graphs.
+TEST_P(BipartiteRandomTest, LargerNets) {
+  int nodes = GetParam().first;
+  int iters = GetParam().second;
+  MatchMatrix graph(static_cast<size_t>(nodes), static_cast<size_t>(nodes));
+
+  auto seed = static_cast<uint32_t>(GTEST_FLAG_GET(random_seed));
+  if (seed == 0) {
+    seed = static_cast<uint32_t>(time(nullptr));
+  }
+
+  for (; iters > 0; --iters, ++seed) {
+    srand(static_cast<unsigned int>(seed));
+    graph.Randomize();
+    EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
+              internal::FindMaxBipartiteMatching(graph).size())
+        << " graph: " << graph.DebugString()
+        << "\nTo reproduce the failure, rerun the test with the flag"
+           " --"
+        << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
+  }
+}
+
+// Test argument is a std::pair<int, int> representing (nodes, iters).
+INSTANTIATE_TEST_SUITE_P(Samples, BipartiteRandomTest,
+                         testing::Values(std::make_pair(5, 10000),
+                                         std::make_pair(6, 5000),
+                                         std::make_pair(7, 2000),
+                                         std::make_pair(8, 500),
+                                         std::make_pair(9, 100)));
+
+// Tests IsReadableTypeName().
+
+TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
+  EXPECT_TRUE(IsReadableTypeName("int"));
+  EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
+  EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
+  EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames) {
+  EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
+  EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
+  EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
+  EXPECT_FALSE(
+      IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
+  EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
+}
+
+TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
+  EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
+}
+
+// Tests FormatMatcherDescription().
+
+TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
+  EXPECT_EQ("is even",
+            FormatMatcherDescription(false, "IsEven", {}, Strings()));
+  EXPECT_EQ("not (is even)",
+            FormatMatcherDescription(true, "IsEven", {}, Strings()));
+
+  EXPECT_EQ("equals (a: 5)",
+            FormatMatcherDescription(false, "Equals", {"a"}, {"5"}));
+
+  EXPECT_EQ(
+      "is in range (a: 5, b: 8)",
+      FormatMatcherDescription(false, "IsInRange", {"a", "b"}, {"5", "8"}));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(MatcherTupleTest);
+
+TEST_P(MatcherTupleTestP, ExplainsMatchFailure) {
+  stringstream ss1;
+  ExplainMatchFailureTupleTo(
+      std::make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
+      std::make_tuple('a', 10), &ss1);
+  EXPECT_EQ("", ss1.str());  // Successful match.
+
+  stringstream ss2;
+  ExplainMatchFailureTupleTo(
+      std::make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+      std::make_tuple(2, 'b'), &ss2);
+  EXPECT_EQ(
+      "  Expected arg #0: is > 5\n"
+      "           Actual: 2, which is 3 less than 5\n"
+      "  Expected arg #1: is equal to 'a' (97, 0x61)\n"
+      "           Actual: 'b' (98, 0x62)\n",
+      ss2.str());  // Failed match where both arguments need explanation.
+
+  stringstream ss3;
+  ExplainMatchFailureTupleTo(
+      std::make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+      std::make_tuple(2, 'a'), &ss3);
+  EXPECT_EQ(
+      "  Expected arg #0: is > 5\n"
+      "           Actual: 2, which is 3 less than 5\n",
+      ss3.str());  // Failed match where only one argument needs
+                   // explanation.
+}
+
+// Sample optional type implementation with minimal requirements for use with
+// Optional matcher.
+template <typename T>
+class SampleOptional {
+ public:
+  using value_type = T;
+  explicit SampleOptional(T value)
+      : value_(std::move(value)), has_value_(true) {}
+  SampleOptional() : value_(), has_value_(false) {}
+  operator bool() const { return has_value_; }
+  const T& operator*() const { return value_; }
+
+ private:
+  T value_;
+  bool has_value_;
+};
+
+TEST(OptionalTest, DescribesSelf) {
+  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+  EXPECT_EQ("value is equal to 1", Describe(m));
+}
+
+TEST(OptionalTest, ExplainsSelf) {
+  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+  EXPECT_EQ("whose value 1 matches", Explain(m, SampleOptional<int>(1)));
+  EXPECT_EQ("whose value 2 doesn't match", Explain(m, SampleOptional<int>(2)));
+}
+
+TEST(OptionalTest, MatchesNonEmptyOptional) {
+  const Matcher<SampleOptional<int>> m1 = Optional(1);
+  const Matcher<SampleOptional<int>> m2 = Optional(Eq(2));
+  const Matcher<SampleOptional<int>> m3 = Optional(Lt(3));
+  SampleOptional<int> opt(1);
+  EXPECT_TRUE(m1.Matches(opt));
+  EXPECT_FALSE(m2.Matches(opt));
+  EXPECT_TRUE(m3.Matches(opt));
+}
+
+TEST(OptionalTest, DoesNotMatchNullopt) {
+  const Matcher<SampleOptional<int>> m = Optional(1);
+  SampleOptional<int> empty;
+  EXPECT_FALSE(m.Matches(empty));
+}
+
+TEST(OptionalTest, WorksWithMoveOnly) {
+  Matcher<SampleOptional<std::unique_ptr<int>>> m = Optional(Eq(nullptr));
+  EXPECT_TRUE(m.Matches(SampleOptional<std::unique_ptr<int>>(nullptr)));
+}
+
+class SampleVariantIntString {
+ public:
+  SampleVariantIntString(int i) : i_(i), has_int_(true) {}
+  SampleVariantIntString(const std::string& s) : s_(s), has_int_(false) {}
+
+  template <typename T>
+  friend bool holds_alternative(const SampleVariantIntString& value) {
+    return value.has_int_ == std::is_same<T, int>::value;
+  }
+
+  template <typename T>
+  friend const T& get(const SampleVariantIntString& value) {
+    return value.get_impl(static_cast<T*>(nullptr));
+  }
+
+ private:
+  const int& get_impl(int*) const { return i_; }
+  const std::string& get_impl(std::string*) const { return s_; }
+
+  int i_;
+  std::string s_;
+  bool has_int_;
+};
+
+TEST(VariantTest, DescribesSelf) {
+  const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
+  EXPECT_THAT(Describe(m), ContainsRegex("is a variant<> with value of type "
+                                         "'.*' and the value is equal to 1"));
+}
+
+TEST(VariantTest, ExplainsSelf) {
+  const Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
+  EXPECT_THAT(Explain(m, SampleVariantIntString(1)),
+              ContainsRegex("whose value 1"));
+  EXPECT_THAT(Explain(m, SampleVariantIntString("A")),
+              HasSubstr("whose value is not of type '"));
+  EXPECT_THAT(Explain(m, SampleVariantIntString(2)),
+              "whose value 2 doesn't match");
+}
+
+TEST(VariantTest, FullMatch) {
+  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
+  EXPECT_TRUE(m.Matches(SampleVariantIntString(1)));
+
+  m = VariantWith<std::string>(Eq("1"));
+  EXPECT_TRUE(m.Matches(SampleVariantIntString("1")));
+}
+
+TEST(VariantTest, TypeDoesNotMatch) {
+  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
+  EXPECT_FALSE(m.Matches(SampleVariantIntString("1")));
+
+  m = VariantWith<std::string>(Eq("1"));
+  EXPECT_FALSE(m.Matches(SampleVariantIntString(1)));
+}
+
+TEST(VariantTest, InnerDoesNotMatch) {
+  Matcher<SampleVariantIntString> m = VariantWith<int>(Eq(1));
+  EXPECT_FALSE(m.Matches(SampleVariantIntString(2)));
+
+  m = VariantWith<std::string>(Eq("1"));
+  EXPECT_FALSE(m.Matches(SampleVariantIntString("2")));
+}
+
+class SampleAnyType {
+ public:
+  explicit SampleAnyType(int i) : index_(0), i_(i) {}
+  explicit SampleAnyType(const std::string& s) : index_(1), s_(s) {}
+
+  template <typename T>
+  friend const T* any_cast(const SampleAnyType* any) {
+    return any->get_impl(static_cast<T*>(nullptr));
+  }
+
+ private:
+  int index_;
+  int i_;
+  std::string s_;
+
+  const int* get_impl(int*) const { return index_ == 0 ? &i_ : nullptr; }
+  const std::string* get_impl(std::string*) const {
+    return index_ == 1 ? &s_ : nullptr;
+  }
+};
+
+TEST(AnyWithTest, FullMatch) {
+  Matcher<SampleAnyType> m = AnyWith<int>(Eq(1));
+  EXPECT_TRUE(m.Matches(SampleAnyType(1)));
+}
+
+TEST(AnyWithTest, TestBadCastType) {
+  Matcher<SampleAnyType> m = AnyWith<std::string>(Eq("fail"));
+  EXPECT_FALSE(m.Matches(SampleAnyType(1)));
+}
+
+TEST(AnyWithTest, TestUseInContainers) {
+  std::vector<SampleAnyType> a;
+  a.emplace_back(1);
+  a.emplace_back(2);
+  a.emplace_back(3);
+  EXPECT_THAT(
+      a, ElementsAreArray({AnyWith<int>(1), AnyWith<int>(2), AnyWith<int>(3)}));
+
+  std::vector<SampleAnyType> b;
+  b.emplace_back("hello");
+  b.emplace_back("merhaba");
+  b.emplace_back("salut");
+  EXPECT_THAT(b, ElementsAreArray({AnyWith<std::string>("hello"),
+                                   AnyWith<std::string>("merhaba"),
+                                   AnyWith<std::string>("salut")}));
+}
+TEST(AnyWithTest, TestCompare) {
+  EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0)));
+}
+
+TEST(AnyWithTest, DescribesSelf) {
+  const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
+  EXPECT_THAT(Describe(m), ContainsRegex("is an 'any' type with value of type "
+                                         "'.*' and the value is equal to 1"));
+}
+
+TEST(AnyWithTest, ExplainsSelf) {
+  const Matcher<const SampleAnyType&> m = AnyWith<int>(Eq(1));
+
+  EXPECT_THAT(Explain(m, SampleAnyType(1)), ContainsRegex("whose value 1"));
+  EXPECT_THAT(Explain(m, SampleAnyType("A")),
+              HasSubstr("whose value is not of type '"));
+  EXPECT_THAT(Explain(m, SampleAnyType(2)), "whose value 2 doesn't match");
+}
+
+// Tests Args<k0, ..., kn>(m).
+
+TEST(ArgsTest, AcceptsZeroTemplateArg) {
+  const std::tuple<int, bool> t(5, true);
+  EXPECT_THAT(t, Args<>(Eq(std::tuple<>())));
+  EXPECT_THAT(t, Not(Args<>(Ne(std::tuple<>()))));
+}
+
+TEST(ArgsTest, AcceptsOneTemplateArg) {
+  const std::tuple<int, bool> t(5, true);
+  EXPECT_THAT(t, Args<0>(Eq(std::make_tuple(5))));
+  EXPECT_THAT(t, Args<1>(Eq(std::make_tuple(true))));
+  EXPECT_THAT(t, Not(Args<1>(Eq(std::make_tuple(false)))));
+}
+
+TEST(ArgsTest, AcceptsTwoTemplateArgs) {
+  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+
+  EXPECT_THAT(t, (Args<0, 1>(Lt())));
+  EXPECT_THAT(t, (Args<1, 2>(Lt())));
+  EXPECT_THAT(t, Not(Args<0, 2>(Gt())));
+}
+
+TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
+  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+  EXPECT_THAT(t, (Args<0, 0>(Eq())));
+  EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
+}
+
+TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
+  const std::tuple<short, int, long> t(4, 5, 6L);  // NOLINT
+  EXPECT_THAT(t, (Args<2, 0>(Gt())));
+  EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
+}
+
+MATCHER(SumIsZero, "") {
+  return std::get<0>(arg) + std::get<1>(arg) + std::get<2>(arg) == 0;
+}
+
+TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
+  EXPECT_THAT(std::make_tuple(-1, 2), (Args<0, 0, 1>(SumIsZero())));
+  EXPECT_THAT(std::make_tuple(1, 2), Not(Args<0, 0, 1>(SumIsZero())));
+}
+
+TEST(ArgsTest, CanBeNested) {
+  const std::tuple<short, int, long, int> t(4, 5, 6L, 6);  // NOLINT
+  EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
+  EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
+}
+
+TEST(ArgsTest, CanMatchTupleByValue) {
+  typedef std::tuple<char, int, int> Tuple3;
+  const Matcher<Tuple3> m = Args<1, 2>(Lt());
+  EXPECT_TRUE(m.Matches(Tuple3('a', 1, 2)));
+  EXPECT_FALSE(m.Matches(Tuple3('b', 2, 2)));
+}
+
+TEST(ArgsTest, CanMatchTupleByReference) {
+  typedef std::tuple<char, char, int> Tuple3;
+  const Matcher<const Tuple3&> m = Args<0, 1>(Lt());
+  EXPECT_TRUE(m.Matches(Tuple3('a', 'b', 2)));
+  EXPECT_FALSE(m.Matches(Tuple3('b', 'b', 2)));
+}
+
+// Validates that arg is printed as str.
+MATCHER_P(PrintsAs, str, "") { return testing::PrintToString(arg) == str; }
+
+TEST(ArgsTest, AcceptsTenTemplateArgs) {
+  EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
+              (Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
+                  PrintsAs("(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
+  EXPECT_THAT(std::make_tuple(0, 1L, 2, 3L, 4, 5, 6, 7, 8, 9),
+              Not(Args<9, 8, 7, 6, 5, 4, 3, 2, 1, 0>(
+                  PrintsAs("(0, 8, 7, 6, 5, 4, 3, 2, 1, 0)"))));
+}
+
+TEST(ArgsTest, DescirbesSelfCorrectly) {
+  const Matcher<std::tuple<int, bool, char>> m = Args<2, 0>(Lt());
+  EXPECT_EQ(
+      "are a tuple whose fields (#2, #0) are a pair where "
+      "the first < the second",
+      Describe(m));
+}
+
+TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
+  const Matcher<const std::tuple<int, bool, char, int>&> m =
+      Args<0, 2, 3>(Args<2, 0>(Lt()));
+  EXPECT_EQ(
+      "are a tuple whose fields (#0, #2, #3) are a tuple "
+      "whose fields (#2, #0) are a pair where the first < the second",
+      Describe(m));
+}
+
+TEST(ArgsTest, DescribesNegationCorrectly) {
+  const Matcher<std::tuple<int, char>> m = Args<1, 0>(Gt());
+  EXPECT_EQ(
+      "are a tuple whose fields (#1, #0) aren't a pair "
+      "where the first > the second",
+      DescribeNegation(m));
+}
+
+TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
+  const Matcher<std::tuple<bool, int, int>> m = Args<1, 2>(Eq());
+  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
+            Explain(m, std::make_tuple(false, 42, 42)));
+  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
+            Explain(m, std::make_tuple(false, 42, 43)));
+}
+
+// For testing Args<>'s explanation.
+class LessThanMatcher : public MatcherInterface<std::tuple<char, int>> {
+ public:
+  void DescribeTo(::std::ostream* /*os*/) const override {}
+
+  bool MatchAndExplain(std::tuple<char, int> value,
+                       MatchResultListener* listener) const override {
+    const int diff = std::get<0>(value) - std::get<1>(value);
+    if (diff > 0) {
+      *listener << "where the first value is " << diff
+                << " more than the second";
+    }
+    return diff < 0;
+  }
+};
+
+Matcher<std::tuple<char, int>> LessThan() {
+  return MakeMatcher(new LessThanMatcher);
+}
+
+TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
+  const Matcher<std::tuple<char, int, int>> m = Args<0, 2>(LessThan());
+  EXPECT_EQ(
+      "whose fields (#0, #2) are ('a' (97, 0x61), 42), "
+      "where the first value is 55 more than the second",
+      Explain(m, std::make_tuple('a', 42, 42)));
+  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
+            Explain(m, std::make_tuple('\0', 42, 43)));
+}
+
+// Tests for the MATCHER*() macro family.
+
+// Tests that a simple MATCHER() definition works.
+
+MATCHER(IsEven, "") { return (arg % 2) == 0; }
+
+TEST(MatcherMacroTest, Works) {
+  const Matcher<int> m = IsEven();
+  EXPECT_TRUE(m.Matches(6));
+  EXPECT_FALSE(m.Matches(7));
+
+  EXPECT_EQ("is even", Describe(m));
+  EXPECT_EQ("not (is even)", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 6));
+  EXPECT_EQ("", Explain(m, 7));
+}
+
+// This also tests that the description string can reference 'negation'.
+MATCHER(IsEven2, negation ? "is odd" : "is even") {
+  if ((arg % 2) == 0) {
+    // Verifies that we can stream to result_listener, a listener
+    // supplied by the MATCHER macro implicitly.
+    *result_listener << "OK";
+    return true;
+  } else {
+    *result_listener << "% 2 == " << (arg % 2);
+    return false;
+  }
+}
+
+// This also tests that the description string can reference matcher
+// parameters.
+MATCHER_P2(EqSumOf, x, y,
+           std::string(negation ? "doesn't equal" : "equals") + " the sum of " +
+               PrintToString(x) + " and " + PrintToString(y)) {
+  if (arg == (x + y)) {
+    *result_listener << "OK";
+    return true;
+  } else {
+    // Verifies that we can stream to the underlying stream of
+    // result_listener.
+    if (result_listener->stream() != nullptr) {
+      *result_listener->stream() << "diff == " << (x + y - arg);
+    }
+    return false;
+  }
+}
+
+// Tests that the matcher description can reference 'negation' and the
+// matcher parameters.
+TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
+  const Matcher<int> m1 = IsEven2();
+  EXPECT_EQ("is even", Describe(m1));
+  EXPECT_EQ("is odd", DescribeNegation(m1));
+
+  const Matcher<int> m2 = EqSumOf(5, 9);
+  EXPECT_EQ("equals the sum of 5 and 9", Describe(m2));
+  EXPECT_EQ("doesn't equal the sum of 5 and 9", DescribeNegation(m2));
+}
+
+// Tests explaining match result in a MATCHER* macro.
+TEST(MatcherMacroTest, CanExplainMatchResult) {
+  const Matcher<int> m1 = IsEven2();
+  EXPECT_EQ("OK", Explain(m1, 4));
+  EXPECT_EQ("% 2 == 1", Explain(m1, 5));
+
+  const Matcher<int> m2 = EqSumOf(1, 2);
+  EXPECT_EQ("OK", Explain(m2, 3));
+  EXPECT_EQ("diff == -1", Explain(m2, 4));
+}
+
+// Tests that the body of MATCHER() can reference the type of the
+// value being matched.
+
+MATCHER(IsEmptyString, "") {
+  StaticAssertTypeEq<::std::string, arg_type>();
+  return arg.empty();
+}
+
+MATCHER(IsEmptyStringByRef, "") {
+  StaticAssertTypeEq<const ::std::string&, arg_type>();
+  return arg.empty();
+}
+
+TEST(MatcherMacroTest, CanReferenceArgType) {
+  const Matcher<::std::string> m1 = IsEmptyString();
+  EXPECT_TRUE(m1.Matches(""));
+
+  const Matcher<const ::std::string&> m2 = IsEmptyStringByRef();
+  EXPECT_TRUE(m2.Matches(""));
+}
+
+// Tests that MATCHER() can be used in a namespace.
+
+namespace matcher_test {
+MATCHER(IsOdd, "") { return (arg % 2) != 0; }
+}  // namespace matcher_test
+
+TEST(MatcherMacroTest, WorksInNamespace) {
+  Matcher<int> m = matcher_test::IsOdd();
+  EXPECT_FALSE(m.Matches(4));
+  EXPECT_TRUE(m.Matches(5));
+}
+
+// Tests that Value() can be used to compose matchers.
+MATCHER(IsPositiveOdd, "") {
+  return Value(arg, matcher_test::IsOdd()) && arg > 0;
+}
+
+TEST(MatcherMacroTest, CanBeComposedUsingValue) {
+  EXPECT_THAT(3, IsPositiveOdd());
+  EXPECT_THAT(4, Not(IsPositiveOdd()));
+  EXPECT_THAT(-1, Not(IsPositiveOdd()));
+}
+
+// Tests that a simple MATCHER_P() definition works.
+
+MATCHER_P(IsGreaterThan32And, n, "") { return arg > 32 && arg > n; }
+
+TEST(MatcherPMacroTest, Works) {
+  const Matcher<int> m = IsGreaterThan32And(5);
+  EXPECT_TRUE(m.Matches(36));
+  EXPECT_FALSE(m.Matches(5));
+
+  EXPECT_EQ("is greater than 32 and (n: 5)", Describe(m));
+  EXPECT_EQ("not (is greater than 32 and (n: 5))", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36));
+  EXPECT_EQ("", Explain(m, 5));
+}
+
+// Tests that the description is calculated correctly from the matcher name.
+MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
+
+TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
+  const Matcher<int> m = _is_Greater_Than32and_(5);
+
+  EXPECT_EQ("is greater than 32 and (n: 5)", Describe(m));
+  EXPECT_EQ("not (is greater than 32 and (n: 5))", DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36));
+  EXPECT_EQ("", Explain(m, 5));
+}
+
+// Tests that a MATCHER_P matcher can be explicitly instantiated with
+// a reference parameter type.
+
+class UncopyableFoo {
+ public:
+  explicit UncopyableFoo(char value) : value_(value) { (void)value_; }
+
+  UncopyableFoo(const UncopyableFoo&) = delete;
+  void operator=(const UncopyableFoo&) = delete;
+
+ private:
+  char value_;
+};
+
+MATCHER_P(ReferencesUncopyable, variable, "") { return &arg == &variable; }
+
+TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
+  UncopyableFoo foo1('1'), foo2('2');
+  const Matcher<const UncopyableFoo&> m =
+      ReferencesUncopyable<const UncopyableFoo&>(foo1);
+
+  EXPECT_TRUE(m.Matches(foo1));
+  EXPECT_FALSE(m.Matches(foo2));
+
+  // We don't want the address of the parameter printed, as most
+  // likely it will just annoy the user.  If the address is
+  // interesting, the user should consider passing the parameter by
+  // pointer instead.
+  EXPECT_EQ("references uncopyable (variable: 1-byte object <31>)",
+            Describe(m));
+}
+
+// Tests that the body of MATCHER_Pn() can reference the parameter
+// types.
+
+MATCHER_P3(ParamTypesAreIntLongAndChar, foo, bar, baz, "") {
+  StaticAssertTypeEq<int, foo_type>();
+  StaticAssertTypeEq<long, bar_type>();  // NOLINT
+  StaticAssertTypeEq<char, baz_type>();
+  return arg == 0;
+}
+
+TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
+  EXPECT_THAT(0, ParamTypesAreIntLongAndChar(10, 20L, 'a'));
+}
+
+// Tests that a MATCHER_Pn matcher can be explicitly instantiated with
+// reference parameter types.
+
+MATCHER_P2(ReferencesAnyOf, variable1, variable2, "") {
+  return &arg == &variable1 || &arg == &variable2;
+}
+
+TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferences) {
+  UncopyableFoo foo1('1'), foo2('2'), foo3('3');
+  const Matcher<const UncopyableFoo&> const_m =
+      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
+
+  EXPECT_TRUE(const_m.Matches(foo1));
+  EXPECT_TRUE(const_m.Matches(foo2));
+  EXPECT_FALSE(const_m.Matches(foo3));
+
+  const Matcher<UncopyableFoo&> m =
+      ReferencesAnyOf<UncopyableFoo&, UncopyableFoo&>(foo1, foo2);
+
+  EXPECT_TRUE(m.Matches(foo1));
+  EXPECT_TRUE(m.Matches(foo2));
+  EXPECT_FALSE(m.Matches(foo3));
+}
+
+TEST(MatcherPnMacroTest,
+     GeneratesCorretDescriptionWhenExplicitlyInstantiatedWithReferences) {
+  UncopyableFoo foo1('1'), foo2('2');
+  const Matcher<const UncopyableFoo&> m =
+      ReferencesAnyOf<const UncopyableFoo&, const UncopyableFoo&>(foo1, foo2);
+
+  // We don't want the addresses of the parameters printed, as most
+  // likely they will just annoy the user.  If the addresses are
+  // interesting, the user should consider passing the parameters by
+  // pointers instead.
+  EXPECT_EQ(
+      "references any of (variable1: 1-byte object <31>, variable2: 1-byte "
+      "object <32>)",
+      Describe(m));
+}
+
+// Tests that a simple MATCHER_P2() definition works.
+
+MATCHER_P2(IsNotInClosedRange, low, hi, "") { return arg < low || arg > hi; }
+
+TEST(MatcherPnMacroTest, Works) {
+  const Matcher<const long&> m = IsNotInClosedRange(10, 20);  // NOLINT
+  EXPECT_TRUE(m.Matches(36L));
+  EXPECT_FALSE(m.Matches(15L));
+
+  EXPECT_EQ("is not in closed range (low: 10, hi: 20)", Describe(m));
+  EXPECT_EQ("not (is not in closed range (low: 10, hi: 20))",
+            DescribeNegation(m));
+  EXPECT_EQ("", Explain(m, 36L));
+  EXPECT_EQ("", Explain(m, 15L));
+}
+
+// Tests that MATCHER*() definitions can be overloaded on the number
+// of parameters; also tests MATCHER_Pn() where n >= 3.
+
+MATCHER(EqualsSumOf, "") { return arg == 0; }
+MATCHER_P(EqualsSumOf, a, "") { return arg == a; }
+MATCHER_P2(EqualsSumOf, a, b, "") { return arg == a + b; }
+MATCHER_P3(EqualsSumOf, a, b, c, "") { return arg == a + b + c; }
+MATCHER_P4(EqualsSumOf, a, b, c, d, "") { return arg == a + b + c + d; }
+MATCHER_P5(EqualsSumOf, a, b, c, d, e, "") { return arg == a + b + c + d + e; }
+MATCHER_P6(EqualsSumOf, a, b, c, d, e, f, "") {
+  return arg == a + b + c + d + e + f;
+}
+MATCHER_P7(EqualsSumOf, a, b, c, d, e, f, g, "") {
+  return arg == a + b + c + d + e + f + g;
+}
+MATCHER_P8(EqualsSumOf, a, b, c, d, e, f, g, h, "") {
+  return arg == a + b + c + d + e + f + g + h;
+}
+MATCHER_P9(EqualsSumOf, a, b, c, d, e, f, g, h, i, "") {
+  return arg == a + b + c + d + e + f + g + h + i;
+}
+MATCHER_P10(EqualsSumOf, a, b, c, d, e, f, g, h, i, j, "") {
+  return arg == a + b + c + d + e + f + g + h + i + j;
+}
+
+TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
+  EXPECT_THAT(0, EqualsSumOf());
+  EXPECT_THAT(1, EqualsSumOf(1));
+  EXPECT_THAT(12, EqualsSumOf(10, 2));
+  EXPECT_THAT(123, EqualsSumOf(100, 20, 3));
+  EXPECT_THAT(1234, EqualsSumOf(1000, 200, 30, 4));
+  EXPECT_THAT(12345, EqualsSumOf(10000, 2000, 300, 40, 5));
+  EXPECT_THAT("abcdef",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f'));
+  EXPECT_THAT("abcdefg",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g'));
+  EXPECT_THAT("abcdefgh", EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e",
+                                      'f', 'g', "h"));
+  EXPECT_THAT("abcdefghi", EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e",
+                                       'f', 'g', "h", 'i'));
+  EXPECT_THAT("abcdefghij",
+              EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g', "h",
+                          'i', ::std::string("j")));
+
+  EXPECT_THAT(1, Not(EqualsSumOf()));
+  EXPECT_THAT(-1, Not(EqualsSumOf(1)));
+  EXPECT_THAT(-12, Not(EqualsSumOf(10, 2)));
+  EXPECT_THAT(-123, Not(EqualsSumOf(100, 20, 3)));
+  EXPECT_THAT(-1234, Not(EqualsSumOf(1000, 200, 30, 4)));
+  EXPECT_THAT(-12345, Not(EqualsSumOf(10000, 2000, 300, 40, 5)));
+  EXPECT_THAT("abcdef ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f')));
+  EXPECT_THAT("abcdefg ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
+                                          "e", 'f', 'g')));
+  EXPECT_THAT("abcdefgh ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
+                                           "e", 'f', 'g', "h")));
+  EXPECT_THAT("abcdefghi ", Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d",
+                                            "e", 'f', 'g', "h", 'i')));
+  EXPECT_THAT("abcdefghij ",
+              Not(EqualsSumOf(::std::string("a"), 'b', 'c', "d", "e", 'f', 'g',
+                              "h", 'i', ::std::string("j"))));
+}
+
+// Tests that a MATCHER_Pn() definition can be instantiated with any
+// compatible parameter types.
+TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
+  EXPECT_THAT(123, EqualsSumOf(100L, 20, static_cast<char>(3)));
+  EXPECT_THAT("abcd", EqualsSumOf(::std::string("a"), "b", 'c', "d"));
+
+  EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
+  EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
+}
+
+// Tests that the matcher body can promote the parameter types.
+
+MATCHER_P2(EqConcat, prefix, suffix, "") {
+  // The following lines promote the two parameters to desired types.
+  std::string prefix_str(prefix);
+  char suffix_char = static_cast<char>(suffix);
+  return arg == prefix_str + suffix_char;
+}
+
+TEST(MatcherPnMacroTest, SimpleTypePromotion) {
+  Matcher<std::string> no_promo = EqConcat(std::string("foo"), 't');
+  Matcher<const std::string&> promo = EqConcat("foo", static_cast<int>('t'));
+  EXPECT_FALSE(no_promo.Matches("fool"));
+  EXPECT_FALSE(promo.Matches("fool"));
+  EXPECT_TRUE(no_promo.Matches("foot"));
+  EXPECT_TRUE(promo.Matches("foot"));
+}
+
+// Verifies the type of a MATCHER*.
+
+TEST(MatcherPnMacroTest, TypesAreCorrect) {
+  // EqualsSumOf() must be assignable to a EqualsSumOfMatcher variable.
+  EqualsSumOfMatcher a0 = EqualsSumOf();
+
+  // EqualsSumOf(1) must be assignable to a EqualsSumOfMatcherP variable.
+  EqualsSumOfMatcherP<int> a1 = EqualsSumOf(1);
+
+  // EqualsSumOf(p1, ..., pk) must be assignable to a EqualsSumOfMatcherPk
+  // variable, and so on.
+  EqualsSumOfMatcherP2<int, char> a2 = EqualsSumOf(1, '2');
+  EqualsSumOfMatcherP3<int, int, char> a3 = EqualsSumOf(1, 2, '3');
+  EqualsSumOfMatcherP4<int, int, int, char> a4 = EqualsSumOf(1, 2, 3, '4');
+  EqualsSumOfMatcherP5<int, int, int, int, char> a5 =
+      EqualsSumOf(1, 2, 3, 4, '5');
+  EqualsSumOfMatcherP6<int, int, int, int, int, char> a6 =
+      EqualsSumOf(1, 2, 3, 4, 5, '6');
+  EqualsSumOfMatcherP7<int, int, int, int, int, int, char> a7 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, '7');
+  EqualsSumOfMatcherP8<int, int, int, int, int, int, int, char> a8 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, '8');
+  EqualsSumOfMatcherP9<int, int, int, int, int, int, int, int, char> a9 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, '9');
+  EqualsSumOfMatcherP10<int, int, int, int, int, int, int, int, int, char> a10 =
+      EqualsSumOf(1, 2, 3, 4, 5, 6, 7, 8, 9, '0');
+
+  // Avoid "unused variable" warnings.
+  (void)a0;
+  (void)a1;
+  (void)a2;
+  (void)a3;
+  (void)a4;
+  (void)a5;
+  (void)a6;
+  (void)a7;
+  (void)a8;
+  (void)a9;
+  (void)a10;
+}
+
+// Tests that matcher-typed parameters can be used in Value() inside a
+// MATCHER_Pn definition.
+
+// Succeeds if arg matches exactly 2 of the 3 matchers.
+MATCHER_P3(TwoOf, m1, m2, m3, "") {
+  const int count = static_cast<int>(Value(arg, m1)) +
+                    static_cast<int>(Value(arg, m2)) +
+                    static_cast<int>(Value(arg, m3));
+  return count == 2;
+}
+
+TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
+  EXPECT_THAT(42, TwoOf(Gt(0), Lt(50), Eq(10)));
+  EXPECT_THAT(0, Not(TwoOf(Gt(-1), Lt(1), Eq(0))));
+}
+
+// Tests Contains().Times().
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(ContainsTimes);
+
+TEST(ContainsTimes, ListMatchesWhenElementQuantityMatches) {
+  list<int> some_list;
+  some_list.push_back(3);
+  some_list.push_back(1);
+  some_list.push_back(2);
+  some_list.push_back(3);
+  EXPECT_THAT(some_list, Contains(3).Times(2));
+  EXPECT_THAT(some_list, Contains(2).Times(1));
+  EXPECT_THAT(some_list, Contains(Ge(2)).Times(3));
+  EXPECT_THAT(some_list, Contains(Ge(2)).Times(Gt(2)));
+  EXPECT_THAT(some_list, Contains(4).Times(0));
+  EXPECT_THAT(some_list, Contains(_).Times(4));
+  EXPECT_THAT(some_list, Not(Contains(5).Times(1)));
+  EXPECT_THAT(some_list, Contains(5).Times(_));  // Times(_) always matches
+  EXPECT_THAT(some_list, Not(Contains(3).Times(1)));
+  EXPECT_THAT(some_list, Contains(3).Times(Not(1)));
+  EXPECT_THAT(list<int>{}, Not(Contains(_)));
+}
+
+TEST_P(ContainsTimesP, ExplainsMatchResultCorrectly) {
+  const int a[2] = {1, 2};
+  Matcher<const int(&)[2]> m = Contains(2).Times(3);
+  EXPECT_EQ(
+      "whose element #1 matches but whose match quantity of 1 does not match",
+      Explain(m, a));
+
+  m = Contains(3).Times(0);
+  EXPECT_EQ("has no element that matches and whose match quantity of 0 matches",
+            Explain(m, a));
+
+  m = Contains(3).Times(4);
+  EXPECT_EQ(
+      "has no element that matches and whose match quantity of 0 does not "
+      "match",
+      Explain(m, a));
+
+  m = Contains(2).Times(4);
+  EXPECT_EQ(
+      "whose element #1 matches but whose match quantity of 1 does not "
+      "match",
+      Explain(m, a));
+
+  m = Contains(GreaterThan(0)).Times(2);
+  EXPECT_EQ("whose elements (0, 1) match and whose match quantity of 2 matches",
+            Explain(m, a));
+
+  m = Contains(GreaterThan(10)).Times(Gt(1));
+  EXPECT_EQ(
+      "has no element that matches and whose match quantity of 0 does not "
+      "match",
+      Explain(m, a));
+
+  m = Contains(GreaterThan(0)).Times(GreaterThan<size_t>(5));
+  EXPECT_EQ(
+      "whose elements (0, 1) match but whose match quantity of 2 does not "
+      "match, which is 3 less than 5",
+      Explain(m, a));
+}
+
+TEST(ContainsTimes, DescribesItselfCorrectly) {
+  Matcher<vector<int>> m = Contains(1).Times(2);
+  EXPECT_EQ("quantity of elements that match is equal to 1 is equal to 2",
+            Describe(m));
+
+  Matcher<vector<int>> m2 = Not(m);
+  EXPECT_EQ("quantity of elements that match is equal to 1 isn't equal to 2",
+            Describe(m2));
+}
+
+// Tests AllOfArray()
+
+TEST(AllOfArrayTest, BasicForms) {
+  // Iterator
+  std::vector<int> v0{};
+  std::vector<int> v1{1};
+  std::vector<int> v2{2, 3};
+  std::vector<int> v3{4, 4, 4};
+  EXPECT_THAT(0, AllOfArray(v0.begin(), v0.end()));
+  EXPECT_THAT(1, AllOfArray(v1.begin(), v1.end()));
+  EXPECT_THAT(2, Not(AllOfArray(v1.begin(), v1.end())));
+  EXPECT_THAT(3, Not(AllOfArray(v2.begin(), v2.end())));
+  EXPECT_THAT(4, AllOfArray(v3.begin(), v3.end()));
+  // Pointer +  size
+  int ar[6] = {1, 2, 3, 4, 4, 4};
+  EXPECT_THAT(0, AllOfArray(ar, 0));
+  EXPECT_THAT(1, AllOfArray(ar, 1));
+  EXPECT_THAT(2, Not(AllOfArray(ar, 1)));
+  EXPECT_THAT(3, Not(AllOfArray(ar + 1, 3)));
+  EXPECT_THAT(4, AllOfArray(ar + 3, 3));
+  // Array
+  // int ar0[0];  Not usable
+  int ar1[1] = {1};
+  int ar2[2] = {2, 3};
+  int ar3[3] = {4, 4, 4};
+  // EXPECT_THAT(0, Not(AllOfArray(ar0)));  // Cannot work
+  EXPECT_THAT(1, AllOfArray(ar1));
+  EXPECT_THAT(2, Not(AllOfArray(ar1)));
+  EXPECT_THAT(3, Not(AllOfArray(ar2)));
+  EXPECT_THAT(4, AllOfArray(ar3));
+  // Container
+  EXPECT_THAT(0, AllOfArray(v0));
+  EXPECT_THAT(1, AllOfArray(v1));
+  EXPECT_THAT(2, Not(AllOfArray(v1)));
+  EXPECT_THAT(3, Not(AllOfArray(v2)));
+  EXPECT_THAT(4, AllOfArray(v3));
+  // Initializer
+  EXPECT_THAT(0, AllOfArray<int>({}));  // Requires template arg.
+  EXPECT_THAT(1, AllOfArray({1}));
+  EXPECT_THAT(2, Not(AllOfArray({1})));
+  EXPECT_THAT(3, Not(AllOfArray({2, 3})));
+  EXPECT_THAT(4, AllOfArray({4, 4, 4}));
+}
+
+TEST(AllOfArrayTest, Matchers) {
+  // vector
+  std::vector<Matcher<int>> matchers{Ge(1), Lt(2)};
+  EXPECT_THAT(0, Not(AllOfArray(matchers)));
+  EXPECT_THAT(1, AllOfArray(matchers));
+  EXPECT_THAT(2, Not(AllOfArray(matchers)));
+  // initializer_list
+  EXPECT_THAT(0, Not(AllOfArray({Ge(0), Ge(1)})));
+  EXPECT_THAT(1, AllOfArray({Ge(0), Ge(1)}));
+}
+
+INSTANTIATE_GTEST_MATCHER_TEST_P(AnyOfArrayTest);
+
+TEST(AnyOfArrayTest, BasicForms) {
+  // Iterator
+  std::vector<int> v0{};
+  std::vector<int> v1{1};
+  std::vector<int> v2{2, 3};
+  EXPECT_THAT(0, Not(AnyOfArray(v0.begin(), v0.end())));
+  EXPECT_THAT(1, AnyOfArray(v1.begin(), v1.end()));
+  EXPECT_THAT(2, Not(AnyOfArray(v1.begin(), v1.end())));
+  EXPECT_THAT(3, AnyOfArray(v2.begin(), v2.end()));
+  EXPECT_THAT(4, Not(AnyOfArray(v2.begin(), v2.end())));
+  // Pointer +  size
+  int ar[3] = {1, 2, 3};
+  EXPECT_THAT(0, Not(AnyOfArray(ar, 0)));
+  EXPECT_THAT(1, AnyOfArray(ar, 1));
+  EXPECT_THAT(2, Not(AnyOfArray(ar, 1)));
+  EXPECT_THAT(3, AnyOfArray(ar + 1, 2));
+  EXPECT_THAT(4, Not(AnyOfArray(ar + 1, 2)));
+  // Array
+  // int ar0[0];  Not usable
+  int ar1[1] = {1};
+  int ar2[2] = {2, 3};
+  // EXPECT_THAT(0, Not(AnyOfArray(ar0)));  // Cannot work
+  EXPECT_THAT(1, AnyOfArray(ar1));
+  EXPECT_THAT(2, Not(AnyOfArray(ar1)));
+  EXPECT_THAT(3, AnyOfArray(ar2));
+  EXPECT_THAT(4, Not(AnyOfArray(ar2)));
+  // Container
+  EXPECT_THAT(0, Not(AnyOfArray(v0)));
+  EXPECT_THAT(1, AnyOfArray(v1));
+  EXPECT_THAT(2, Not(AnyOfArray(v1)));
+  EXPECT_THAT(3, AnyOfArray(v2));
+  EXPECT_THAT(4, Not(AnyOfArray(v2)));
+  // Initializer
+  EXPECT_THAT(0, Not(AnyOfArray<int>({})));  // Requires template arg.
+  EXPECT_THAT(1, AnyOfArray({1}));
+  EXPECT_THAT(2, Not(AnyOfArray({1})));
+  EXPECT_THAT(3, AnyOfArray({2, 3}));
+  EXPECT_THAT(4, Not(AnyOfArray({2, 3})));
+}
+
+TEST(AnyOfArrayTest, Matchers) {
+  // We negate test AllOfArrayTest.Matchers.
+  // vector
+  std::vector<Matcher<int>> matchers{Lt(1), Ge(2)};
+  EXPECT_THAT(0, AnyOfArray(matchers));
+  EXPECT_THAT(1, Not(AnyOfArray(matchers)));
+  EXPECT_THAT(2, AnyOfArray(matchers));
+  // initializer_list
+  EXPECT_THAT(0, AnyOfArray({Lt(0), Lt(1)}));
+  EXPECT_THAT(1, Not(AllOfArray({Lt(0), Lt(1)})));
+}
+
+TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
+  // AnyOfArray and AllOfArray use the same underlying template-template,
+  // thus it is sufficient to test one here.
+  const std::vector<int> v0{};
+  const std::vector<int> v1{1};
+  const std::vector<int> v2{2, 3};
+  const Matcher<int> m0 = AnyOfArray(v0);
+  const Matcher<int> m1 = AnyOfArray(v1);
+  const Matcher<int> m2 = AnyOfArray(v2);
+  EXPECT_EQ("", Explain(m0, 0));
+  EXPECT_EQ("", Explain(m1, 1));
+  EXPECT_EQ("", Explain(m1, 2));
+  EXPECT_EQ("", Explain(m2, 3));
+  EXPECT_EQ("", Explain(m2, 4));
+  EXPECT_EQ("()", Describe(m0));
+  EXPECT_EQ("(is equal to 1)", Describe(m1));
+  EXPECT_EQ("(is equal to 2) or (is equal to 3)", Describe(m2));
+  EXPECT_EQ("()", DescribeNegation(m0));
+  EXPECT_EQ("(isn't equal to 1)", DescribeNegation(m1));
+  EXPECT_EQ("(isn't equal to 2) and (isn't equal to 3)", DescribeNegation(m2));
+  // Explain with matchers
+  const Matcher<int> g1 = AnyOfArray({GreaterThan(1)});
+  const Matcher<int> g2 = AnyOfArray({GreaterThan(1), GreaterThan(2)});
+  // Explains the first positive match and all prior negative matches...
+  EXPECT_EQ("which is 1 less than 1", Explain(g1, 0));
+  EXPECT_EQ("which is the same as 1", Explain(g1, 1));
+  EXPECT_EQ("which is 1 more than 1", Explain(g1, 2));
+  EXPECT_EQ("which is 1 less than 1, and which is 2 less than 2",
+            Explain(g2, 0));
+  EXPECT_EQ("which is the same as 1, and which is 1 less than 2",
+            Explain(g2, 1));
+  EXPECT_EQ("which is 1 more than 1",  // Only the first
+            Explain(g2, 2));
+}
+
+MATCHER(IsNotNull, "") { return arg != nullptr; }
+
+// Verifies that a matcher defined using MATCHER() can work on
+// move-only types.
+TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
+  std::unique_ptr<int> p(new int(3));
+  EXPECT_THAT(p, IsNotNull());
+  EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull()));
+}
+
+MATCHER_P(UniquePointee, pointee, "") { return *arg == pointee; }
+
+// Verifies that a matcher defined using MATCHER_P*() can work on
+// move-only types.
+TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
+  std::unique_ptr<int> p(new int(3));
+  EXPECT_THAT(p, UniquePointee(3));
+  EXPECT_THAT(p, Not(UniquePointee(2)));
+}
+
+MATCHER(EnsureNoUnusedButMarkedUnusedWarning, "") { return (arg % 2) == 0; }
+
+TEST(MockMethodMockFunctionTest, EnsureNoUnusedButMarkedUnusedWarning) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic error "-Wused-but-marked-unused"
+#endif
+  // https://github.com/google/googletest/issues/4055
+  EXPECT_THAT(0, EnsureNoUnusedButMarkedUnusedWarning());
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// std::function<void()> is used below for compatibility with older copies of
+// GCC. Normally, a raw lambda is all that is needed.
+
+// Test that examples from documentation compile
+TEST(ThrowsTest, Examples) {
+  EXPECT_THAT(
+      std::function<void()>([]() { throw std::runtime_error("message"); }),
+      Throws<std::runtime_error>());
+
+  EXPECT_THAT(
+      std::function<void()>([]() { throw std::runtime_error("message"); }),
+      ThrowsMessage<std::runtime_error>(HasSubstr("message")));
+}
+
+TEST(ThrowsTest, PrintsExceptionWhat) {
+  EXPECT_THAT(
+      std::function<void()>([]() { throw std::runtime_error("ABC123XYZ"); }),
+      ThrowsMessage<std::runtime_error>(HasSubstr("ABC123XYZ")));
+}
+
+TEST(ThrowsTest, DoesNotGenerateDuplicateCatchClauseWarning) {
+  EXPECT_THAT(std::function<void()>([]() { throw std::exception(); }),
+              Throws<std::exception>());
+}
+
+TEST(ThrowsTest, CallableExecutedExactlyOnce) {
+  size_t a = 0;
+
+  EXPECT_THAT(std::function<void()>([&a]() {
+                a++;
+                throw 10;
+              }),
+              Throws<int>());
+  EXPECT_EQ(a, 1u);
+
+  EXPECT_THAT(std::function<void()>([&a]() {
+                a++;
+                throw std::runtime_error("message");
+              }),
+              Throws<std::runtime_error>());
+  EXPECT_EQ(a, 2u);
+
+  EXPECT_THAT(std::function<void()>([&a]() {
+                a++;
+                throw std::runtime_error("message");
+              }),
+              ThrowsMessage<std::runtime_error>(HasSubstr("message")));
+  EXPECT_EQ(a, 3u);
+
+  EXPECT_THAT(std::function<void()>([&a]() {
+                a++;
+                throw std::runtime_error("message");
+              }),
+              Throws<std::runtime_error>(
+                  Property(&std::runtime_error::what, HasSubstr("message"))));
+  EXPECT_EQ(a, 4u);
+}
+
+TEST(ThrowsTest, Describe) {
+  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
+  std::stringstream ss;
+  matcher.DescribeTo(&ss);
+  auto explanation = ss.str();
+  EXPECT_THAT(explanation, HasSubstr("std::runtime_error"));
+}
+
+TEST(ThrowsTest, Success) {
+  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
+  StringMatchResultListener listener;
+  EXPECT_TRUE(matcher.MatchAndExplain(
+      []() { throw std::runtime_error("error message"); }, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("std::runtime_error"));
+}
+
+TEST(ThrowsTest, FailWrongType) {
+  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain(
+      []() { throw std::logic_error("error message"); }, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("std::logic_error"));
+  EXPECT_THAT(listener.str(), HasSubstr("\"error message\""));
+}
+
+TEST(ThrowsTest, FailWrongTypeNonStd) {
+  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
+  EXPECT_THAT(listener.str(),
+              HasSubstr("throws an exception of an unknown type"));
+}
+
+TEST(ThrowsTest, FailNoThrow) {
+  Matcher<std::function<void()>> matcher = Throws<std::runtime_error>();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain([]() { (void)0; }, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("does not throw any exception"));
+}
+
+class ThrowsPredicateTest
+    : public TestWithParam<Matcher<std::function<void()>>> {};
+
+TEST_P(ThrowsPredicateTest, Describe) {
+  Matcher<std::function<void()>> matcher = GetParam();
+  std::stringstream ss;
+  matcher.DescribeTo(&ss);
+  auto explanation = ss.str();
+  EXPECT_THAT(explanation, HasSubstr("std::runtime_error"));
+  EXPECT_THAT(explanation, HasSubstr("error message"));
+}
+
+TEST_P(ThrowsPredicateTest, Success) {
+  Matcher<std::function<void()>> matcher = GetParam();
+  StringMatchResultListener listener;
+  EXPECT_TRUE(matcher.MatchAndExplain(
+      []() { throw std::runtime_error("error message"); }, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("std::runtime_error"));
+}
+
+TEST_P(ThrowsPredicateTest, FailWrongType) {
+  Matcher<std::function<void()>> matcher = GetParam();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain(
+      []() { throw std::logic_error("error message"); }, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("std::logic_error"));
+  EXPECT_THAT(listener.str(), HasSubstr("\"error message\""));
+}
+
+TEST_P(ThrowsPredicateTest, FailWrongTypeNonStd) {
+  Matcher<std::function<void()>> matcher = GetParam();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain([]() { throw 10; }, &listener));
+  EXPECT_THAT(listener.str(),
+              HasSubstr("throws an exception of an unknown type"));
+}
+
+TEST_P(ThrowsPredicateTest, FailNoThrow) {
+  Matcher<std::function<void()>> matcher = GetParam();
+  StringMatchResultListener listener;
+  EXPECT_FALSE(matcher.MatchAndExplain([]() {}, &listener));
+  EXPECT_THAT(listener.str(), HasSubstr("does not throw any exception"));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    AllMessagePredicates, ThrowsPredicateTest,
+    Values(Matcher<std::function<void()>>(
+        ThrowsMessage<std::runtime_error>(HasSubstr("error message")))));
+
+// Tests that Throws<E1>(Matcher<E2>{}) compiles even when E2 != const E1&.
+TEST(ThrowsPredicateCompilesTest, ExceptionMatcherAcceptsBroadType) {
+  {
+    Matcher<std::function<void()>> matcher =
+        ThrowsMessage<std::runtime_error>(HasSubstr("error message"));
+    EXPECT_TRUE(
+        matcher.Matches([]() { throw std::runtime_error("error message"); }));
+    EXPECT_FALSE(
+        matcher.Matches([]() { throw std::runtime_error("wrong message"); }));
+  }
+
+  {
+    Matcher<uint64_t> inner = Eq(10);
+    Matcher<std::function<void()>> matcher = Throws<uint32_t>(inner);
+    EXPECT_TRUE(matcher.Matches([]() { throw(uint32_t) 10; }));
+    EXPECT_FALSE(matcher.Matches([]() { throw(uint32_t) 11; }));
+  }
+}
+
+// Tests that ThrowsMessage("message") is equivalent
+// to ThrowsMessage(Eq<std::string>("message")).
+TEST(ThrowsPredicateCompilesTest, MessageMatcherAcceptsNonMatcher) {
+  Matcher<std::function<void()>> matcher =
+      ThrowsMessage<std::runtime_error>("error message");
+  EXPECT_TRUE(
+      matcher.Matches([]() { throw std::runtime_error("error message"); }));
+  EXPECT_FALSE(matcher.Matches(
+      []() { throw std::runtime_error("wrong error message"); }));
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace
+}  // namespace gmock_matchers_test
+}  // namespace testing
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/googletest/googlemock/test/gmock-matchers_test.h b/googletest/googlemock/test/gmock-matchers_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c986e9ff0b87dcf50183e010ecf7184adea736e
--- /dev/null
+++ b/googletest/googlemock/test/gmock-matchers_test.h
@@ -0,0 +1,192 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests some commonly used argument matchers.
+
+#ifndef GOOGLEMOCK_TEST_GMOCK_MATCHERS_TEST_H_
+#define GOOGLEMOCK_TEST_GMOCK_MATCHERS_TEST_H_
+
+#include <string.h>
+#include <time.h>
+
+#include <array>
+#include <cstdint>
+#include <deque>
+#include <forward_list>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace gmock_matchers_test {
+
+using std::greater;
+using std::less;
+using std::list;
+using std::make_pair;
+using std::map;
+using std::multimap;
+using std::multiset;
+using std::ostream;
+using std::pair;
+using std::set;
+using std::stringstream;
+using std::vector;
+using testing::internal::DummyMatchResultListener;
+using testing::internal::ElementMatcherPair;
+using testing::internal::ElementMatcherPairs;
+using testing::internal::ElementsAreArrayMatcher;
+using testing::internal::ExplainMatchFailureTupleTo;
+using testing::internal::FloatingEqMatcher;
+using testing::internal::FormatMatcherDescription;
+using testing::internal::IsReadableTypeName;
+using testing::internal::MatchMatrix;
+using testing::internal::PredicateFormatterFromMatcher;
+using testing::internal::RE;
+using testing::internal::StreamMatchResultListener;
+using testing::internal::Strings;
+
+// Helper for testing container-valued matchers in mock method context. It is
+// important to test matchers in this context, since it requires additional type
+// deduction beyond what EXPECT_THAT does, thus making it more restrictive.
+struct ContainerHelper {
+  MOCK_METHOD1(Call, void(std::vector<std::unique_ptr<int>>));
+};
+
+// For testing ExplainMatchResultTo().
+template <typename T>
+struct GtestGreaterThanMatcher {
+  using is_gtest_matcher = void;
+
+  void DescribeTo(ostream* os) const { *os << "is > " << rhs; }
+  void DescribeNegationTo(ostream* os) const { *os << "is <= " << rhs; }
+
+  bool MatchAndExplain(T lhs, MatchResultListener* listener) const {
+    if (lhs > rhs) {
+      *listener << "which is " << (lhs - rhs) << " more than " << rhs;
+    } else if (lhs == rhs) {
+      *listener << "which is the same as " << rhs;
+    } else {
+      *listener << "which is " << (rhs - lhs) << " less than " << rhs;
+    }
+
+    return lhs > rhs;
+  }
+
+  T rhs;
+};
+
+template <typename T>
+GtestGreaterThanMatcher<typename std::decay<T>::type> GtestGreaterThan(
+    T&& rhs) {
+  return {rhs};
+}
+
+// As the matcher above, but using the base class with virtual functions.
+template <typename T>
+class GreaterThanMatcher : public MatcherInterface<T> {
+ public:
+  explicit GreaterThanMatcher(T rhs) : impl_{rhs} {}
+
+  void DescribeTo(ostream* os) const override { impl_.DescribeTo(os); }
+  void DescribeNegationTo(ostream* os) const override {
+    impl_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(T lhs, MatchResultListener* listener) const override {
+    return impl_.MatchAndExplain(lhs, listener);
+  }
+
+ private:
+  const GtestGreaterThanMatcher<T> impl_;
+};
+
+// Names and instantiates a new instance of GTestMatcherTestP.
+#define INSTANTIATE_GTEST_MATCHER_TEST_P(TestSuite)                         \
+  using TestSuite##P = GTestMatcherTestP;                                   \
+  INSTANTIATE_TEST_SUITE_P(MatcherInterface, TestSuite##P, Values(false));  \
+  INSTANTIATE_TEST_SUITE_P(GtestMatcher, TestSuite##P, Values(true))
+
+class GTestMatcherTestP : public testing::TestWithParam<bool> {
+ public:
+  template <typename T>
+  Matcher<T> GreaterThan(T n) {
+    if (use_gtest_matcher_) {
+      return GtestGreaterThan(n);
+    } else {
+      return MakeMatcher(new GreaterThanMatcher<T>(n));
+    }
+  }
+  const bool use_gtest_matcher_ = GetParam();
+};
+
+// Returns the description of the given matcher.
+template <typename T>
+std::string Describe(const Matcher<T>& m) {
+  return DescribeMatcher<T>(m);
+}
+
+// Returns the description of the negation of the given matcher.
+template <typename T>
+std::string DescribeNegation(const Matcher<T>& m) {
+  return DescribeMatcher<T>(m, true);
+}
+
+// Returns the reason why x matches, or doesn't match, m.
+template <typename MatcherType, typename Value>
+std::string Explain(const MatcherType& m, const Value& x) {
+  StringMatchResultListener listener;
+  ExplainMatchResult(m, x, &listener);
+  return listener.str();
+}
+
+}  // namespace gmock_matchers_test
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_TEST_GMOCK_MATCHERS_TEST_H_
diff --git a/googletest/googlemock/test/gmock-more-actions_test.cc b/googletest/googlemock/test/gmock-more-actions_test.cc
index 53bb029f45c97b8e75ebbc3a5fd47bd03989248e..b9b66bf9000068bcc4ac803fba9c8d7aff5ddacb 100644
--- a/googletest/googlemock/test/gmock-more-actions_test.cc
+++ b/googletest/googlemock/test/gmock-more-actions_test.cc
@@ -145,7 +145,7 @@ class Foo {
 
   std::string Binary(const std::string& str, char c) const { return str + c; }
 
-  int Ternary(int x, bool y, char z) { return value_ + x + y*z; }
+  int Ternary(int x, bool y, char z) { return value_ + x + y * z; }
 
   int SumOf4(int a, int b, int c, int d) const {
     return a + b + c + d + value_;
@@ -291,8 +291,7 @@ TEST(InvokeTest, FunctionWithUnusedParameters) {
       std::make_tuple(10, 2, 5.6, std::string("hi"));
   EXPECT_EQ(12, a1.Perform(dummy));
 
-  Action<int(int, int, bool, int*)> a2 =
-      Invoke(SumOfFirst2);
+  Action<int(int, int, bool, int*)> a2 = Invoke(SumOfFirst2);
   EXPECT_EQ(
       23, a2.Perform(std::make_tuple(20, 3, true, static_cast<int*>(nullptr))));
 }
@@ -303,8 +302,7 @@ TEST(InvokeTest, MethodWithUnusedParameters) {
   Action<int(std::string, bool, int, int)> a1 = Invoke(&foo, &Foo::SumOfLast2);
   EXPECT_EQ(12, a1.Perform(std::make_tuple(CharPtr("hi"), true, 10, 2)));
 
-  Action<int(char, double, int, int)> a2 =
-      Invoke(&foo, &Foo::SumOfLast2);
+  Action<int(char, double, int, int)> a2 = Invoke(&foo, &Foo::SumOfLast2);
   EXPECT_EQ(23, a2.Perform(std::make_tuple('a', 2.5, 20, 3)));
 }
 
@@ -362,7 +360,8 @@ TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
 // Tests using Invoke() with a 5-argument method.
 TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
   Foo foo;
-  Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5);  // NOLINT
+  Action<int(int, int, int, int, int)> a =
+      Invoke(&foo, &Foo::SumOf5);  // NOLINT
   EXPECT_EQ(12345, a.Perform(std::make_tuple(10000, 2000, 300, 40, 5)));
 }
 
@@ -462,6 +461,12 @@ TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
   EXPECT_EQ("seven", a.Perform(std::make_tuple(5, 6, std::string("seven"), 8)));
 }
 
+TEST(ReturnArgActionTest, WorksForNonConstRefArg0) {
+  const Action<std::string&(std::string&)> a = ReturnArg<0>();
+  std::string s = "12345";
+  EXPECT_EQ(&s, &a.Perform(std::forward_as_tuple(s)));
+}
+
 TEST(SaveArgActionTest, WorksForSameType) {
   int result = 0;
   const Action<void(int n)> a1 = SaveArg<0>(&result);
@@ -517,15 +522,12 @@ TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
 // the bool provided to the constructor to true when destroyed.
 class DeletionTester {
  public:
-  explicit DeletionTester(bool* is_deleted)
-    : is_deleted_(is_deleted) {
+  explicit DeletionTester(bool* is_deleted) : is_deleted_(is_deleted) {
     // Make sure the bit is set to false.
     *is_deleted_ = false;
   }
 
-  ~DeletionTester() {
-    *is_deleted_ = true;
-  }
+  ~DeletionTester() { *is_deleted_ = true; }
 
  private:
   bool* is_deleted_;
@@ -534,7 +536,7 @@ class DeletionTester {
 TEST(DeleteArgActionTest, OneArg) {
   bool is_deleted = false;
   DeletionTester* t = new DeletionTester(&is_deleted);
-  const Action<void(DeletionTester*)> a1 = DeleteArg<0>();      // NOLINT
+  const Action<void(DeletionTester*)> a1 = DeleteArg<0>();  // NOLINT
   EXPECT_FALSE(is_deleted);
   a1.Perform(std::make_tuple(t));
   EXPECT_TRUE(is_deleted);
@@ -543,8 +545,9 @@ TEST(DeleteArgActionTest, OneArg) {
 TEST(DeleteArgActionTest, TenArgs) {
   bool is_deleted = false;
   DeletionTester* t = new DeletionTester(&is_deleted);
-  const Action<void(bool, int, int, const char*, bool,
-                    int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
+  const Action<void(bool, int, int, const char*, bool, int, int, int, int,
+                    DeletionTester*)>
+      a1 = DeleteArg<9>();
   EXPECT_FALSE(is_deleted);
   a1.Perform(std::make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
   EXPECT_TRUE(is_deleted);
@@ -602,7 +605,7 @@ TEST(ThrowActionTest, Times0) {
 // pointed to by the N-th (0-based) argument to values in range [first, last).
 TEST(SetArrayArgumentTest, SetsTheNthArray) {
   using MyFunction = void(bool, int*, char*);
-  int numbers[] = { 1, 2, 3 };
+  int numbers[] = {1, 2, 3};
   Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);
 
   int n[4] = {};
@@ -638,7 +641,7 @@ TEST(SetArrayArgumentTest, SetsTheNthArray) {
 // Tests SetArrayArgument<N>(first, last) where first == last.
 TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
   using MyFunction = void(bool, int*);
-  int numbers[] = { 1, 2, 3 };
+  int numbers[] = {1, 2, 3};
   Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
 
   int n[4] = {};
@@ -654,10 +657,10 @@ TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
 // (but not equal) to the argument type.
 TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
   using MyFunction = void(bool, int*);
-  char chars[] = { 97, 98, 99 };
+  char chars[] = {97, 98, 99};
   Action<MyFunction> a = SetArrayArgument<1>(chars, chars + 3);
 
-  int codes[4] = { 111, 222, 333, 444 };
+  int codes[4] = {111, 222, 333, 444};
   int* pcodes = codes;
   a.Perform(std::make_tuple(true, pcodes));
   EXPECT_EQ(97, codes[0]);
diff --git a/googletest/googlemock/test/gmock-nice-strict_test.cc b/googletest/googlemock/test/gmock-nice-strict_test.cc
index 25558ebffe766bb09ab6d06aabc698947932f69c..08254e1acdd077a31034dd40b7d36efde855d960 100644
--- a/googletest/googlemock/test/gmock-nice-strict_test.cc
+++ b/googletest/googlemock/test/gmock-nice-strict_test.cc
@@ -31,6 +31,7 @@
 
 #include <string>
 #include <utility>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
@@ -44,13 +45,13 @@ class Mock {
   MOCK_METHOD0(DoThis, void());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
+  Mock(const Mock&) = delete;
+  Mock& operator=(const Mock&) = delete;
 };
 
 namespace testing {
 namespace gmock_nice_strict_test {
 
-using testing::GMOCK_FLAG(verbose);
 using testing::HasSubstr;
 using testing::NaggyMock;
 using testing::NiceMock;
@@ -93,7 +94,8 @@ class MockFoo : public Foo {
   MOCK_METHOD0(ReturnNonDefaultConstructible, NotDefaultConstructible());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+  MockFoo(const MockFoo&) = delete;
+  MockFoo& operator=(const MockFoo&) = delete;
 };
 
 class MockBar {
@@ -103,7 +105,8 @@ class MockBar {
   MockBar(char a1, char a2, std::string a3, std::string a4, int a5, int a6,
           const std::string& a7, const std::string& a8, bool a9, bool a10) {
     str_ = std::string() + a1 + a2 + a3 + a4 + static_cast<char>(a5) +
-        static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') + (a10 ? 'T' : 'F');
+           static_cast<char>(a6) + a7 + a8 + (a9 ? 'T' : 'F') +
+           (a10 ? 'T' : 'F');
   }
 
   virtual ~MockBar() {}
@@ -116,10 +119,10 @@ class MockBar {
  private:
   std::string str_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
+  MockBar(const MockBar&) = delete;
+  MockBar& operator=(const MockBar&) = delete;
 };
 
-
 class MockBaz {
  public:
   class MoveOnly {
@@ -140,8 +143,8 @@ class MockBaz {
 
 // Tests that a raw mock generates warnings for uninteresting calls.
 TEST(RawMockTest, WarningForUninterestingCall) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "warning");
 
   MockFoo raw_foo;
 
@@ -151,26 +154,25 @@ TEST(RawMockTest, WarningForUninterestingCall) {
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 // Tests that a raw mock generates warnings for uninteresting calls
 // that delete the mock object.
 TEST(RawMockTest, WarningForUninterestingCallAfterDeath) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "warning");
 
   MockFoo* const raw_foo = new MockFoo;
 
-  ON_CALL(*raw_foo, DoThis())
-      .WillByDefault(Invoke(raw_foo, &MockFoo::Delete));
+  ON_CALL(*raw_foo, DoThis()).WillByDefault(Invoke(raw_foo, &MockFoo::Delete));
 
   CaptureStdout();
   raw_foo->DoThis();
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 // Tests that a raw mock generates informational logs for
@@ -178,14 +180,14 @@ TEST(RawMockTest, WarningForUninterestingCallAfterDeath) {
 TEST(RawMockTest, InfoForUninterestingCall) {
   MockFoo raw_foo;
 
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "info";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "info");
   CaptureStdout();
   raw_foo.DoThis();
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 TEST(RawMockTest, IsNaggy_IsNice_IsStrict) {
@@ -223,14 +225,14 @@ TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) {
 TEST(NiceMockTest, InfoForUninterestingCall) {
   NiceMock<MockFoo> nice_foo;
 
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "info";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "info");
   CaptureStdout();
   nice_foo.DoThis();
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
@@ -281,8 +283,8 @@ TEST(NiceMockTest, NonDefaultConstructor) {
 // Tests that NiceMock works with a mock class that has a 10-ary
 // non-default constructor.
 TEST(NiceMockTest, NonDefaultConstructor10) {
-  NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f',
-                             "g", "h", true, false);
+  NiceMock<MockBar> nice_bar('a', 'b', "c", "d", 'e', 'f', "g", "h", true,
+                             false);
   EXPECT_EQ("abcdefghTF", nice_bar.str());
 
   nice_bar.This();
@@ -326,8 +328,8 @@ TEST(NiceMockTest, IsNaggy_IsNice_IsStrict) {
 
 // Tests that a naggy mock generates warnings for uninteresting calls.
 TEST(NaggyMockTest, WarningForUninterestingCall) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "warning");
 
   NaggyMock<MockFoo> naggy_foo;
 
@@ -337,14 +339,14 @@ TEST(NaggyMockTest, WarningForUninterestingCall) {
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 // Tests that a naggy mock generates a warning for an uninteresting call
 // that deletes the mock object.
 TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "warning");
 
   NaggyMock<MockFoo>* const naggy_foo = new NaggyMock<MockFoo>;
 
@@ -356,7 +358,7 @@ TEST(NaggyMockTest, WarningForUninterestingCallAfterDeath) {
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
@@ -391,8 +393,8 @@ TEST(NaggyMockTest, NonDefaultConstructor) {
 // Tests that NaggyMock works with a mock class that has a 10-ary
 // non-default constructor.
 TEST(NaggyMockTest, NonDefaultConstructor10) {
-  NaggyMock<MockBar> naggy_bar('0', '1', "2", "3", '4', '5',
-                               "6", "7", true, false);
+  NaggyMock<MockBar> naggy_bar('0', '1', "2", "3", '4', '5', "6", "7", true,
+                               false);
   EXPECT_EQ("01234567TF", naggy_bar.str());
 
   naggy_bar.This();
@@ -419,8 +421,8 @@ TEST(NaggyMockTest, AcceptsClassNamedMock) {
 }
 
 TEST(NaggyMockTest, IsNaggyInDestructor) {
-  const std::string saved_flag = GMOCK_FLAG(verbose);
-  GMOCK_FLAG(verbose) = "warning";
+  const std::string saved_flag = GMOCK_FLAG_GET(verbose);
+  GMOCK_FLAG_SET(verbose, "warning");
   CaptureStdout();
 
   {
@@ -431,7 +433,7 @@ TEST(NaggyMockTest, IsNaggyInDestructor) {
   EXPECT_THAT(GetCapturedStdout(),
               HasSubstr("Uninteresting mock function call"));
 
-  GMOCK_FLAG(verbose) = saved_flag;
+  GMOCK_FLAG_SET(verbose, saved_flag);
 }
 
 TEST(NaggyMockTest, IsNaggy_IsNice_IsStrict) {
@@ -491,8 +493,8 @@ TEST(StrictMockTest, NonDefaultConstructor) {
 // Tests that StrictMock works with a mock class that has a 10-ary
 // non-default constructor.
 TEST(StrictMockTest, NonDefaultConstructor10) {
-  StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f',
-                                 "g", "h", true, false);
+  StrictMock<MockBar> strict_bar('a', 'b', "c", "d", 'e', 'f', "g", "h", true,
+                                 false);
   EXPECT_EQ("abcdefghTF", strict_bar.str());
 
   EXPECT_NONFATAL_FAILURE(strict_bar.That(5, true),
diff --git a/googletest/googlemock/test/gmock-port_test.cc b/googletest/googlemock/test/gmock-port_test.cc
index a2c2be248864b2bc23711a0ef34666c9fa7a4649..c31af821559b53d54f297a31adea91af409f63df 100644
--- a/googletest/googlemock/test/gmock-port_test.cc
+++ b/googletest/googlemock/test/gmock-port_test.cc
@@ -27,12 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the internal cross-platform support utilities.
 
 #include "gmock/internal/gmock-port.h"
+
 #include "gtest/gtest.h"
 
 // NOTE: if this file is left without tests for some reason, put a dummy
diff --git a/googletest/googlemock/test/gmock-pp-string_test.cc b/googletest/googlemock/test/gmock-pp-string_test.cc
index 6f66cf156a90f9ec413010ac0c8581776dbd362d..53c80f4e3d2f7606d1997cb6613e3ec5dc1cc285 100644
--- a/googletest/googlemock/test/gmock-pp-string_test.cc
+++ b/googletest/googlemock/test/gmock-pp-string_test.cc
@@ -30,11 +30,10 @@
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the internal preprocessor macro library.
-#include "gmock/internal/gmock-pp.h"
-
 #include <string>
 
 #include "gmock/gmock.h"
+#include "gmock/internal/gmock-pp.h"
 
 namespace testing {
 namespace {
diff --git a/googletest/googlemock/test/gmock-spec-builders_test.cc b/googletest/googlemock/test/gmock-spec-builders_test.cc
index fa97411332c67af530547321fd9c7409231c0f79..165944ead44e179792afdf5fd604032269067073 100644
--- a/googletest/googlemock/test/gmock-spec-builders_test.cc
+++ b/googletest/googlemock/test/gmock-spec-builders_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the spec builder syntax.
@@ -38,74 +37,28 @@
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
+#include <type_traits>
 
 #include "gmock/gmock.h"
 #include "gmock/internal/gmock-port.h"
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 #include "gtest/internal/gtest-port.h"
 
 namespace testing {
-namespace internal {
-
-// Helper class for testing the Expectation class template.
-class ExpectationTester {
- public:
-  // Sets the call count of the given expectation to the given number.
-  void SetCallCount(int n, ExpectationBase* exp) {
-    exp->call_count_ = n;
-  }
-};
-
-}  // namespace internal
-}  // namespace testing
-
 namespace {
 
-using testing::_;
-using testing::AnyNumber;
-using testing::AtLeast;
-using testing::AtMost;
-using testing::Between;
-using testing::Cardinality;
-using testing::CardinalityInterface;
-using testing::Const;
-using testing::ContainsRegex;
-using testing::DoAll;
-using testing::DoDefault;
-using testing::Eq;
-using testing::Expectation;
-using testing::ExpectationSet;
-using testing::GMOCK_FLAG(verbose);
-using testing::Gt;
-using testing::IgnoreResult;
-using testing::InSequence;
-using testing::Invoke;
-using testing::InvokeWithoutArgs;
-using testing::IsNotSubstring;
-using testing::IsSubstring;
-using testing::Lt;
-using testing::Message;
-using testing::Mock;
-using testing::NaggyMock;
-using testing::Ne;
-using testing::Return;
-using testing::SaveArg;
-using testing::Sequence;
-using testing::SetArgPointee;
-using testing::internal::ExpectationTester;
-using testing::internal::FormatFileLocation;
-using testing::internal::kAllow;
-using testing::internal::kErrorVerbosity;
-using testing::internal::kFail;
-using testing::internal::kInfoVerbosity;
-using testing::internal::kWarn;
-using testing::internal::kWarningVerbosity;
+using ::testing::internal::FormatFileLocation;
+using ::testing::internal::kAllow;
+using ::testing::internal::kErrorVerbosity;
+using ::testing::internal::kFail;
+using ::testing::internal::kInfoVerbosity;
+using ::testing::internal::kWarn;
+using ::testing::internal::kWarningVerbosity;
 
 #if GTEST_HAS_STREAM_REDIRECTION
-using testing::HasSubstr;
-using testing::internal::CaptureStdout;
-using testing::internal::GetCapturedStdout;
+using ::testing::internal::CaptureStdout;
+using ::testing::internal::GetCapturedStdout;
 #endif
 
 class Incomplete;
@@ -126,8 +79,7 @@ TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
   // use the mock, as long as Google Mock knows how to print the
   // argument.
   MockIncomplete incomplete;
-  EXPECT_CALL(incomplete, ByRefFunc(_))
-      .Times(AnyNumber());
+  EXPECT_CALL(incomplete, ByRefFunc(_)).Times(AnyNumber());
 }
 
 // The definition of the printer for the argument type doesn't have to
@@ -155,7 +107,8 @@ class MockA {
   MOCK_METHOD2(ReturnInt, int(int x, int y));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
+  MockA(const MockA&) = delete;
+  MockA& operator=(const MockA&) = delete;
 };
 
 class MockB {
@@ -163,10 +116,11 @@ class MockB {
   MockB() {}
 
   MOCK_CONST_METHOD0(DoB, int());  // NOLINT
-  MOCK_METHOD1(DoB, int(int n));  // NOLINT
+  MOCK_METHOD1(DoB, int(int n));   // NOLINT
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+  MockB(const MockB&) = delete;
+  MockB& operator=(const MockB&) = delete;
 };
 
 class ReferenceHoldingMock {
@@ -176,7 +130,8 @@ class ReferenceHoldingMock {
   MOCK_METHOD1(AcceptReference, void(std::shared_ptr<MockA>*));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
+  ReferenceHoldingMock(const ReferenceHoldingMock&) = delete;
+  ReferenceHoldingMock& operator=(const ReferenceHoldingMock&) = delete;
 };
 
 // Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
@@ -198,7 +153,8 @@ class MockCC : public CC {
   MOCK_METHOD0(Method, int());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
+  MockCC(const MockCC&) = delete;
+  MockCC& operator=(const MockCC&) = delete;
 };
 
 // Tests that a method with expanded name compiles.
@@ -254,41 +210,42 @@ TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
 TEST(OnCallSyntaxTest, WithIsOptional) {
   MockA a;
 
-  ON_CALL(a, DoA(5))
-      .WillByDefault(Return());
-  ON_CALL(a, DoA(_))
-      .With(_)
-      .WillByDefault(Return());
+  ON_CALL(a, DoA(5)).WillByDefault(Return());
+  ON_CALL(a, DoA(_)).With(_).WillByDefault(Return());
 }
 
 TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(a, ReturnResult(_))
-        .With(_)
-        .With(_)
-        .WillByDefault(Return(Result()));
-  }, ".With() cannot appear more than once in an ON_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        ON_CALL(a, ReturnResult(_))
+            .With(_)
+            .With(_)
+            .WillByDefault(Return(Result()));
+      },
+      ".With() cannot appear more than once in an ON_CALL()");
 }
 
 TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
   MockA a;
 
-  EXPECT_DEATH_IF_SUPPORTED({
-    ON_CALL(a, DoA(5));
-    a.DoA(5);
-  }, "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        ON_CALL(a, DoA(5));
+        a.DoA(5);
+      },
+      "");
 }
 
 TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    ON_CALL(a, DoA(5))
-        .WillByDefault(Return())
-        .WillByDefault(Return());
-  }, ".WillByDefault() must appear exactly once in an ON_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        ON_CALL(a, DoA(5)).WillByDefault(Return()).WillByDefault(Return());
+      },
+      ".WillByDefault() must appear exactly once in an ON_CALL()");
 }
 
 // Tests that EXPECT_CALL evaluates its arguments exactly once as
@@ -316,21 +273,18 @@ TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
 TEST(ExpectCallSyntaxTest, WithIsOptional) {
   MockA a;
 
-  EXPECT_CALL(a, DoA(5))
-      .Times(0);
-  EXPECT_CALL(a, DoA(6))
-      .With(_)
-      .Times(0);
+  EXPECT_CALL(a, DoA(5)).Times(0);
+  EXPECT_CALL(a, DoA(6)).With(_).Times(0);
 }
 
 TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(6))
-        .With(_)
-        .With(_);
-  }, ".With() cannot appear more than once in an EXPECT_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(6)).With(_).With(_);
+      },
+      ".With() cannot appear more than once in an EXPECT_CALL()");
 
   a.DoA(6);
 }
@@ -338,19 +292,19 @@ TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
 TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .Times(1)
-        .With(_);
-  }, ".With() must be the first clause in an EXPECT_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).Times(1).With(_);
+      },
+      ".With() must be the first clause in an EXPECT_CALL()");
 
   a.DoA(1);
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(2))
-        .WillOnce(Return())
-        .With(_);
-  }, ".With() must be the first clause in an EXPECT_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(2)).WillOnce(Return()).With(_);
+      },
+      ".With() must be the first clause in an EXPECT_CALL()");
 
   a.DoA(2);
 }
@@ -358,12 +312,9 @@ TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
 TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
   MockA a;
 
-  EXPECT_CALL(a, DoA(1))
-      .WillOnce(Return());
+  EXPECT_CALL(a, DoA(1)).WillOnce(Return());
 
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return())
-      .WillRepeatedly(Return());
+  EXPECT_CALL(a, DoA(2)).WillOnce(Return()).WillRepeatedly(Return());
 
   a.DoA(1);
   a.DoA(2);
@@ -373,11 +324,11 @@ TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
 TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .Times(1)
-        .Times(2);
-  }, ".Times() cannot appear more than once in an EXPECT_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).Times(1).Times(2);
+      },
+      ".Times() cannot appear more than once in an EXPECT_CALL()");
 
   a.DoA(1);
   a.DoA(1);
@@ -387,11 +338,11 @@ TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
   MockA a;
   Sequence s;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .InSequence(s)
-        .Times(1);
-  }, ".Times() cannot appear after ");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).InSequence(s).Times(1);
+      },
+      ".Times() may only appear *before* ");
 
   a.DoA(1);
 }
@@ -401,8 +352,7 @@ TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
   Sequence s;
 
   EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(2))
-      .InSequence(s);
+  EXPECT_CALL(a, DoA(2)).InSequence(s);
 
   a.DoA(1);
   a.DoA(2);
@@ -412,9 +362,7 @@ TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
   MockA a;
   Sequence s1, s2;
 
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s1, s2)
-      .InSequence(s1);
+  EXPECT_CALL(a, DoA(1)).InSequence(s1, s2).InSequence(s1);
 
   a.DoA(1);
 }
@@ -423,13 +371,12 @@ TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
   MockA a;
   Sequence s;
 
-  Expectation e = EXPECT_CALL(a, DoA(1))
-      .Times(AnyNumber());
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(2))
-        .After(e)
-        .InSequence(s);
-  }, ".InSequence() cannot appear after ");
+  Expectation e = EXPECT_CALL(a, DoA(1)).Times(AnyNumber());
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(2)).After(e).InSequence(s);
+      },
+      ".InSequence() cannot appear after ");
 
   a.DoA(2);
 }
@@ -438,11 +385,11 @@ TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
   MockA a;
   Sequence s;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillOnce(Return())
-        .InSequence(s);
-  }, ".InSequence() cannot appear after ");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).WillOnce(Return()).InSequence(s);
+      },
+      ".InSequence() cannot appear after ");
 
   a.DoA(1);
 }
@@ -451,11 +398,9 @@ TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
   MockA a;
 
   Expectation e = EXPECT_CALL(a, DoA(1));
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_CALL(a, DoA(2))
-        .WillOnce(Return())
-        .After(e);
-  }, ".After() cannot appear after ");
+  EXPECT_NONFATAL_FAILURE(
+      { EXPECT_CALL(a, DoA(2)).WillOnce(Return()).After(e); },
+      ".After() cannot appear after ");
 
   a.DoA(1);
   a.DoA(2);
@@ -465,8 +410,7 @@ TEST(ExpectCallSyntaxTest, WillIsOptional) {
   MockA a;
 
   EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return());
+  EXPECT_CALL(a, DoA(2)).WillOnce(Return());
 
   a.DoA(1);
   a.DoA(2);
@@ -485,11 +429,11 @@ TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
 TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillRepeatedly(Return())
-        .WillOnce(Return());
-  }, ".WillOnce() cannot appear after ");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).WillRepeatedly(Return()).WillOnce(Return());
+      },
+      ".WillOnce() cannot appear after ");
 
   a.DoA(1);
 }
@@ -497,11 +441,8 @@ TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
 TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
   MockA a;
 
-  EXPECT_CALL(a, DoA(1))
-      .WillOnce(Return());
-  EXPECT_CALL(a, DoA(2))
-      .WillOnce(Return())
-      .WillRepeatedly(Return());
+  EXPECT_CALL(a, DoA(1)).WillOnce(Return());
+  EXPECT_CALL(a, DoA(2)).WillOnce(Return()).WillRepeatedly(Return());
 
   a.DoA(1);
   a.DoA(2);
@@ -511,30 +452,30 @@ TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
 TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .WillRepeatedly(Return())
-        .WillRepeatedly(Return());
-  }, ".WillRepeatedly() cannot appear more than once in an "
-     "EXPECT_CALL()");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).WillRepeatedly(Return()).WillRepeatedly(
+            Return());
+      },
+      ".WillRepeatedly() cannot appear more than once in an "
+      "EXPECT_CALL()");
 }
 
 TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .RetiresOnSaturation()
-        .WillRepeatedly(Return());
-  }, ".WillRepeatedly() cannot appear after ");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).RetiresOnSaturation().WillRepeatedly(Return());
+      },
+      ".WillRepeatedly() cannot appear after ");
 }
 
 TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
   MockA a;
 
   EXPECT_CALL(a, DoA(1));
-  EXPECT_CALL(a, DoA(1))
-      .RetiresOnSaturation();
+  EXPECT_CALL(a, DoA(1)).RetiresOnSaturation();
 
   a.DoA(1);
   a.DoA(1);
@@ -543,11 +484,11 @@ TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
 TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
   MockA a;
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_CALL(a, DoA(1))
-        .RetiresOnSaturation()
-        .RetiresOnSaturation();
-  }, ".RetiresOnSaturation() cannot appear more than once");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_CALL(a, DoA(1)).RetiresOnSaturation().RetiresOnSaturation();
+      },
+      ".RetiresOnSaturation() cannot appear more than once");
 
   a.DoA(1);
 }
@@ -558,16 +499,20 @@ TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
     EXPECT_CALL(a, DoA(1));
     a.DoA(1);
   }
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockA a;
-    EXPECT_CALL(a, DoA(1));
-  }, "to be called once");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockA a;
-    EXPECT_CALL(a, DoA(1));
-    a.DoA(1);
-    a.DoA(1);
-  }, "to be called once");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        MockA a;
+        EXPECT_CALL(a, DoA(1));
+      },
+      "to be called once");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        MockA a;
+        EXPECT_CALL(a, DoA(1));
+        a.DoA(1);
+        a.DoA(1);
+      },
+      "to be called once");
 }
 
 #if GTEST_HAS_STREAM_REDIRECTION
@@ -580,13 +525,9 @@ TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
     MockB b;
 
     // It's always fine to omit WillOnce() entirely.
-    EXPECT_CALL(b, DoB())
-        .Times(0);
-    EXPECT_CALL(b, DoB(1))
-        .Times(AtMost(1));
-    EXPECT_CALL(b, DoB(2))
-        .Times(1)
-        .WillRepeatedly(Return(1));
+    EXPECT_CALL(b, DoB()).Times(0);
+    EXPECT_CALL(b, DoB(1)).Times(AtMost(1));
+    EXPECT_CALL(b, DoB(2)).Times(1).WillRepeatedly(Return(1));
 
     // It's fine for the number of WillOnce()s to equal the upper bound.
     EXPECT_CALL(b, DoB(3))
@@ -596,10 +537,8 @@ TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
 
     // It's fine for the number of WillOnce()s to be smaller than the
     // upper bound when there is a WillRepeatedly().
-    EXPECT_CALL(b, DoB(4))
-        .Times(AtMost(3))
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(b, DoB(4)).Times(AtMost(3)).WillOnce(Return(1)).WillRepeatedly(
+        Return(2));
 
     // Satisfies the above expectations.
     b.DoB(2);
@@ -616,13 +555,9 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
     MockB b;
 
     // Warns when the number of WillOnce()s is larger than the upper bound.
-    EXPECT_CALL(b, DoB())
-        .Times(0)
-        .WillOnce(Return(1));  // #1
-    EXPECT_CALL(b, DoB())
-        .Times(AtMost(1))
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));  // #2
+    EXPECT_CALL(b, DoB()).Times(0).WillOnce(Return(1));  // #1
+    EXPECT_CALL(b, DoB()).Times(AtMost(1)).WillOnce(Return(1)).WillOnce(
+        Return(2));  // #2
     EXPECT_CALL(b, DoB(1))
         .Times(1)
         .WillOnce(Return(1))
@@ -631,41 +566,34 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
 
     // Warns when the number of WillOnce()s equals the upper bound and
     // there is a WillRepeatedly().
-    EXPECT_CALL(b, DoB())
-        .Times(0)
-        .WillRepeatedly(Return(1));  // #4
-    EXPECT_CALL(b, DoB(2))
-        .Times(1)
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));  // #5
+    EXPECT_CALL(b, DoB()).Times(0).WillRepeatedly(Return(1));  // #4
+    EXPECT_CALL(b, DoB(2)).Times(1).WillOnce(Return(1)).WillRepeatedly(
+        Return(2));  // #5
 
     // Satisfies the above expectations.
     b.DoB(1);
     b.DoB(2);
   }
   const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be never called, but has 1 WillOnce().",
-      output);  // #1
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be called at most once, "
-      "but has 2 WillOnce()s.",
-      output);  // #2
+  EXPECT_PRED_FORMAT2(IsSubstring,
+                      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+                      "Expected to be never called, but has 1 WillOnce().",
+                      output);  // #1
+  EXPECT_PRED_FORMAT2(IsSubstring,
+                      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+                      "Expected to be called at most once, "
+                      "but has 2 WillOnce()s.",
+                      output);  // #2
   EXPECT_PRED_FORMAT2(
       IsSubstring,
       "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
       "Expected to be called once, but has 2 WillOnce()s.",
       output);  // #3
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be never called, but has 0 WillOnce()s "
-      "and a WillRepeatedly().",
-      output);  // #4
+  EXPECT_PRED_FORMAT2(IsSubstring,
+                      "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+                      "Expected to be never called, but has 0 WillOnce()s "
+                      "and a WillRepeatedly().",
+                      output);  // #4
   EXPECT_PRED_FORMAT2(
       IsSubstring,
       "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
@@ -679,26 +607,23 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
 TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
   MockB b;
 
-  EXPECT_CALL(b, DoB())
-      .Times(Between(2, 3))
-      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB()).Times(Between(2, 3)).WillOnce(Return(1));
 
   CaptureStdout();
   b.DoB();
   const std::string output = GetCapturedStdout();
-  EXPECT_PRED_FORMAT2(
-      IsSubstring,
-      "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
-      "Expected to be called between 2 and 3 times, "
-      "but has only 1 WillOnce().",
-      output);
+  EXPECT_PRED_FORMAT2(IsSubstring,
+                      "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
+                      "Expected to be called between 2 and 3 times, "
+                      "but has only 1 WillOnce().",
+                      output);
   b.DoB();
 }
 
 TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
-  int original_behavior = testing::GMOCK_FLAG(default_mock_behavior);
+  int original_behavior = GMOCK_FLAG_GET(default_mock_behavior);
 
-  testing::GMOCK_FLAG(default_mock_behavior) = kAllow;
+  GMOCK_FLAG_SET(default_mock_behavior, kAllow);
   CaptureStdout();
   {
     MockA a;
@@ -707,7 +632,7 @@ TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
   std::string output = GetCapturedStdout();
   EXPECT_TRUE(output.empty()) << output;
 
-  testing::GMOCK_FLAG(default_mock_behavior) = kWarn;
+  GMOCK_FLAG_SET(default_mock_behavior, kWarn);
   CaptureStdout();
   {
     MockA a;
@@ -718,14 +643,16 @@ TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
   EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
                       warning_output);
 
-  testing::GMOCK_FLAG(default_mock_behavior) = kFail;
-  EXPECT_NONFATAL_FAILURE({
-    MockA a;
-    a.DoA(0);
-  }, "Uninteresting mock function call");
+  GMOCK_FLAG_SET(default_mock_behavior, kFail);
+  EXPECT_NONFATAL_FAILURE(
+      {
+        MockA a;
+        a.DoA(0);
+      },
+      "Uninteresting mock function call");
 
   // Out of bounds values are converted to kWarn
-  testing::GMOCK_FLAG(default_mock_behavior) = -1;
+  GMOCK_FLAG_SET(default_mock_behavior, -1);
   CaptureStdout();
   {
     MockA a;
@@ -735,7 +662,7 @@ TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
   EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
   EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
                       warning_output);
-  testing::GMOCK_FLAG(default_mock_behavior) = 3;
+  GMOCK_FLAG_SET(default_mock_behavior, 3);
   CaptureStdout();
   {
     MockA a;
@@ -746,7 +673,7 @@ TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
   EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
                       warning_output);
 
-  testing::GMOCK_FLAG(default_mock_behavior) = original_behavior;
+  GMOCK_FLAG_SET(default_mock_behavior, original_behavior);
 }
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
@@ -766,8 +693,7 @@ TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
 // matches the invocation.
 TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
   MockB b;
-  ON_CALL(b, DoB(1))
-      .WillByDefault(Return(1));
+  ON_CALL(b, DoB(1)).WillByDefault(Return(1));
   EXPECT_CALL(b, DoB(_));
 
   EXPECT_EQ(0, b.DoB(2));
@@ -776,12 +702,9 @@ TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
 // Tests that the last matching ON_CALL() action is taken.
 TEST(OnCallTest, PicksLastMatchingOnCall) {
   MockB b;
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(3));
-  ON_CALL(b, DoB(2))
-      .WillByDefault(Return(2));
-  ON_CALL(b, DoB(1))
-      .WillByDefault(Return(1));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(3));
+  ON_CALL(b, DoB(2)).WillByDefault(Return(2));
+  ON_CALL(b, DoB(1)).WillByDefault(Return(1));
   EXPECT_CALL(b, DoB(_));
 
   EXPECT_EQ(2, b.DoB(2));
@@ -805,25 +728,25 @@ TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
 // Tests that the last matching EXPECT_CALL() fires.
 TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
   MockB b;
-  EXPECT_CALL(b, DoB(_))
-      .WillRepeatedly(Return(2));
-  EXPECT_CALL(b, DoB(1))
-      .WillRepeatedly(Return(1));
+  EXPECT_CALL(b, DoB(_)).WillRepeatedly(Return(2));
+  EXPECT_CALL(b, DoB(1)).WillRepeatedly(Return(1));
 
   EXPECT_EQ(1, b.DoB(1));
 }
 
 // Tests lower-bound violation.
 TEST(ExpectCallTest, CatchesTooFewCalls) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB(5))
-        .Times(AtLeast(2));
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        MockB b;
+        EXPECT_CALL(b, DoB(5)).Description("DoB Method").Times(AtLeast(2));
 
-    b.DoB(5);
-  }, "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
-     "         Expected: to be called at least twice\n"
-     "           Actual: called once - unsatisfied and active");
+        b.DoB(5);
+      },
+      "Actual function \"DoB Method\" call count "
+      "doesn't match EXPECT_CALL(b, DoB(5))...\n"
+      "         Expected: to be called at least twice\n"
+      "           Actual: called once - unsatisfied and active");
 }
 
 // Tests that the cardinality can be inferred when no Times(...) is
@@ -831,28 +754,24 @@ TEST(ExpectCallTest, CatchesTooFewCalls) {
 TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
   {
     MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
+    EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
 
     EXPECT_EQ(1, b.DoB());
     EXPECT_EQ(2, b.DoB());
   }
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        MockB b;
+        EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
 
-    EXPECT_EQ(1, b.DoB());
-  }, "to be called twice");
+        EXPECT_EQ(1, b.DoB());
+      },
+      "to be called twice");
 
   {  // NOLINT
     MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillOnce(Return(2));
+    EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
 
     EXPECT_EQ(1, b.DoB());
     EXPECT_EQ(2, b.DoB());
@@ -863,40 +782,78 @@ TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
 TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
   {
     MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
 
     EXPECT_EQ(1, b.DoB());
   }
 
   {  // NOLINT
     MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
 
     EXPECT_EQ(1, b.DoB());
     EXPECT_EQ(2, b.DoB());
     EXPECT_EQ(2, b.DoB());
   }
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    MockB b;
-    EXPECT_CALL(b, DoB())
-        .WillOnce(Return(1))
-        .WillRepeatedly(Return(2));
-  }, "to be called at least once");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        MockB b;
+        EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
+      },
+      "to be called at least once");
+}
+
+#if defined(__cplusplus) && __cplusplus >= 201703L
+
+// It should be possible to return a non-moveable type from a mock action in
+// C++17 and above, where it's guaranteed that such a type can be initialized
+// from a prvalue returned from a function.
+TEST(ExpectCallTest, NonMoveableType) {
+  // Define a non-moveable result type.
+  struct Result {
+    explicit Result(int x_in) : x(x_in) {}
+    Result(Result&&) = delete;
+
+    int x;
+  };
+
+  static_assert(!std::is_move_constructible_v<Result>);
+  static_assert(!std::is_copy_constructible_v<Result>);
+
+  static_assert(!std::is_move_assignable_v<Result>);
+  static_assert(!std::is_copy_assignable_v<Result>);
+
+  // We should be able to use a callable that returns that result as both a
+  // OnceAction and an Action, whether the callable ignores arguments or not.
+  const auto return_17 = [] { return Result(17); };
+
+  static_cast<void>(OnceAction<Result()>{return_17});
+  static_cast<void>(Action<Result()>{return_17});
+
+  static_cast<void>(OnceAction<Result(int)>{return_17});
+  static_cast<void>(Action<Result(int)>{return_17});
+
+  // It should be possible to return the result end to end through an
+  // EXPECT_CALL statement, with both WillOnce and WillRepeatedly.
+  MockFunction<Result()> mock;
+  EXPECT_CALL(mock, Call)   //
+      .WillOnce(return_17)  //
+      .WillRepeatedly(return_17);
+
+  EXPECT_EQ(17, mock.AsStdFunction()().x);
+  EXPECT_EQ(17, mock.AsStdFunction()().x);
+  EXPECT_EQ(17, mock.AsStdFunction()().x);
 }
 
+#endif  // C++17 and above
+
 // Tests that the n-th action is taken for the n-th matching
 // invocation.
 TEST(ExpectCallTest, NthMatchTakesNthAction) {
   MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1))
-      .WillOnce(Return(2))
-      .WillOnce(Return(3));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2)).WillOnce(
+      Return(3));
 
   EXPECT_EQ(1, b.DoB());
   EXPECT_EQ(2, b.DoB());
@@ -907,9 +864,7 @@ TEST(ExpectCallTest, NthMatchTakesNthAction) {
 // list is exhausted.
 TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
   MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1))
-      .WillRepeatedly(Return(2));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
 
   EXPECT_EQ(1, b.DoB());
   EXPECT_EQ(2, b.DoB());
@@ -922,8 +877,7 @@ TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
 // exhausted and there is no WillRepeatedly().
 TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
   MockB b;
-  EXPECT_CALL(b, DoB(_))
-      .Times(1);
+  EXPECT_CALL(b, DoB(_)).Times(1);
   EXPECT_CALL(b, DoB())
       .Times(AnyNumber())
       .WillOnce(Return(1))
@@ -985,8 +939,7 @@ TEST(UninterestingCallTest, DoesDefaultAction) {
   // When there is an ON_CALL() statement, the action specified by it
   // should be taken.
   MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
+  ON_CALL(a, Binary(_, _)).WillByDefault(Return(true));
   EXPECT_TRUE(a.Binary(1, 2));
 
   // When there is no ON_CALL(), the default value for the return type
@@ -1000,8 +953,7 @@ TEST(UnexpectedCallTest, DoesDefaultAction) {
   // When there is an ON_CALL() statement, the action specified by it
   // should be taken.
   MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
+  ON_CALL(a, Binary(_, _)).WillByDefault(Return(true));
   EXPECT_CALL(a, Binary(0, 0));
   a.Binary(0, 0);
   bool result = false;
@@ -1012,11 +964,9 @@ TEST(UnexpectedCallTest, DoesDefaultAction) {
   // When there is no ON_CALL(), the default value for the return type
   // should be returned.
   MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .Times(0);
+  EXPECT_CALL(b, DoB(0)).Times(0);
   int n = -1;
-  EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
-                          "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(n = b.DoB(1), "Unexpected mock function call");
   EXPECT_EQ(0, n);
 }
 
@@ -1093,14 +1043,12 @@ TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
 // match the call.
 TEST(UnexpectedCallTest, RetiredExpectation) {
   MockB b;
-  EXPECT_CALL(b, DoB(1))
-      .RetiresOnSaturation();
+  EXPECT_CALL(b, DoB(1)).RetiresOnSaturation();
 
   b.DoB(1);
-  EXPECT_NONFATAL_FAILURE(
-      b.DoB(1),
-      "         Expected: the expectation is active\n"
-      "           Actual: it is retired");
+  EXPECT_NONFATAL_FAILURE(b.DoB(1),
+                          "         Expected: the expectation is active\n"
+                          "           Actual: it is retired");
 }
 
 // Tests that Google Mock explains that an expectation that doesn't
@@ -1109,27 +1057,21 @@ TEST(UnexpectedCallTest, UnmatchedArguments) {
   MockB b;
   EXPECT_CALL(b, DoB(1));
 
-  EXPECT_NONFATAL_FAILURE(
-      b.DoB(2),
-      "  Expected arg #0: is equal to 1\n"
-      "           Actual: 2\n");
+  EXPECT_NONFATAL_FAILURE(b.DoB(2),
+                          "  Expected arg #0: is equal to 1\n"
+                          "           Actual: 2\n");
   b.DoB(1);
 }
 
 // Tests that Google Mock explains that an expectation with
 // unsatisfied pre-requisites doesn't match the call.
-TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
+TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) {
   Sequence s1, s2;
   MockB b;
-  EXPECT_CALL(b, DoB(1))
-      .InSequence(s1);
-  EXPECT_CALL(b, DoB(2))
-      .Times(AnyNumber())
-      .InSequence(s1);
-  EXPECT_CALL(b, DoB(3))
-      .InSequence(s2);
-  EXPECT_CALL(b, DoB(4))
-      .InSequence(s1, s2);
+  EXPECT_CALL(b, DoB(1)).InSequence(s1);
+  EXPECT_CALL(b, DoB(2)).Times(AnyNumber()).InSequence(s1);
+  EXPECT_CALL(b, DoB(3)).InSequence(s2);
+  EXPECT_CALL(b, DoB(4)).InSequence(s1, s2);
 
   ::testing::TestPartResultArray failures;
   {
@@ -1147,23 +1089,27 @@ TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
   // Verifies that the failure message contains the two unsatisfied
   // pre-requisites but not the satisfied one.
 #if GTEST_USES_PCRE
-  EXPECT_THAT(r.message(), ContainsRegex(
-      // PCRE has trouble using (.|\n) to match any character, but
-      // supports the (?s) prefix for using . to match any character.
-      "(?s)the following immediate pre-requisites are not satisfied:\n"
-      ".*: pre-requisite #0\n"
-      ".*: pre-requisite #1"));
+  EXPECT_THAT(
+      r.message(),
+      ContainsRegex(
+          // PCRE has trouble using (.|\n) to match any character, but
+          // supports the (?s) prefix for using . to match any character.
+          "(?s)the following immediate pre-requisites are not satisfied:\n"
+          ".*: pre-requisite #0\n"
+          ".*: pre-requisite #1"));
 #elif GTEST_USES_POSIX_RE
-  EXPECT_THAT(r.message(), ContainsRegex(
-      // POSIX RE doesn't understand the (?s) prefix, but has no trouble
-      // with (.|\n).
-      "the following immediate pre-requisites are not satisfied:\n"
-      "(.|\n)*: pre-requisite #0\n"
-      "(.|\n)*: pre-requisite #1"));
+  EXPECT_THAT(r.message(),
+              ContainsRegex(
+                  // POSIX RE doesn't understand the (?s) prefix, but has no
+                  // trouble with (.|\n).
+                  "the following immediate pre-requisites are not satisfied:\n"
+                  "(.|\n)*: pre-requisite #0\n"
+                  "(.|\n)*: pre-requisite #1"));
 #else
   // We can only use Google Test's own simple regex.
-  EXPECT_THAT(r.message(), ContainsRegex(
-      "the following immediate pre-requisites are not satisfied:"));
+  EXPECT_THAT(r.message(),
+              ContainsRegex(
+                  "the following immediate pre-requisites are not satisfied:"));
   EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #0"));
   EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #1"));
 #endif  // GTEST_USES_PCRE
@@ -1192,8 +1138,7 @@ TEST(ExcessiveCallTest, DoesDefaultAction) {
   // When there is an ON_CALL() statement, the action specified by it
   // should be taken.
   MockA a;
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
+  ON_CALL(a, Binary(_, _)).WillByDefault(Return(true));
   EXPECT_CALL(a, Binary(0, 0));
   a.Binary(0, 0);
   bool result = false;
@@ -1204,11 +1149,11 @@ TEST(ExcessiveCallTest, DoesDefaultAction) {
   // When there is no ON_CALL(), the default value for the return type
   // should be returned.
   MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .Times(0);
+  EXPECT_CALL(b, DoB(0)).Description("DoB Method").Times(0);
   int n = -1;
-  EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
-                          "Mock function called more times than expected");
+  EXPECT_NONFATAL_FAILURE(
+      n = b.DoB(0),
+      "Mock function \"DoB Method\" called more times than expected");
   EXPECT_EQ(0, n);
 }
 
@@ -1216,11 +1161,11 @@ TEST(ExcessiveCallTest, DoesDefaultAction) {
 // the failure message contains the argument values.
 TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
   MockA a;
-  EXPECT_CALL(a, DoA(_))
-      .Times(0);
+  EXPECT_CALL(a, DoA(_)).Description("DoA Method").Times(0);
   EXPECT_NONFATAL_FAILURE(
       a.DoA(9),
-      "Mock function called more times than expected - returning directly.\n"
+      "Mock function \"DoA Method\" called more times than expected - "
+      "returning directly.\n"
       "    Function call: DoA(9)\n"
       "         Expected: to be never called\n"
       "           Actual: called once - over-saturated and active");
@@ -1253,9 +1198,11 @@ TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
     EXPECT_CALL(a, DoA(2));
   }
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(2);
-  }, "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        a.DoA(2);
+      },
+      "Unexpected mock function call");
 
   a.DoA(1);
   a.DoA(2);
@@ -1275,10 +1222,12 @@ TEST(InSequenceTest, NestedInSequence) {
     }
   }
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(1);
-    a.DoA(3);
-  }, "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        a.DoA(1);
+        a.DoA(3);
+      },
+      "Unexpected mock function call");
 
   a.DoA(2);
   a.DoA(3);
@@ -1294,9 +1243,11 @@ TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
   }
   EXPECT_CALL(a, DoA(3));
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    a.DoA(2);
-  }, "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        a.DoA(2);
+      },
+      "Unexpected mock function call");
 
   a.DoA(3);
   a.DoA(1);
@@ -1310,8 +1261,7 @@ TEST(SequenceTest, AnyOrderIsOkByDefault) {
     MockB b;
 
     EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(b, DoB())
-        .Times(AnyNumber());
+    EXPECT_CALL(b, DoB()).Times(AnyNumber());
 
     a.DoA(1);
     b.DoB();
@@ -1322,8 +1272,7 @@ TEST(SequenceTest, AnyOrderIsOkByDefault) {
     MockB b;
 
     EXPECT_CALL(a, DoA(1));
-    EXPECT_CALL(b, DoB())
-        .Times(AnyNumber());
+    EXPECT_CALL(b, DoB()).Times(AnyNumber());
 
     b.DoB();
     a.DoA(1);
@@ -1334,16 +1283,12 @@ TEST(SequenceTest, AnyOrderIsOkByDefault) {
 // is specified.
 TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
   MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
+  ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
 
   Sequence s;
-  EXPECT_CALL(a, ReturnResult(1))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(2))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(3))
-      .InSequence(s);
+  EXPECT_CALL(a, ReturnResult(1)).InSequence(s);
+  EXPECT_CALL(a, ReturnResult(2)).InSequence(s);
+  EXPECT_CALL(a, ReturnResult(3)).InSequence(s);
 
   a.ReturnResult(1);
 
@@ -1358,14 +1303,11 @@ TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
 // is specified.
 TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
   MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
+  ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
 
   Sequence s;
-  EXPECT_CALL(a, ReturnResult(1))
-      .InSequence(s);
-  EXPECT_CALL(a, ReturnResult(2))
-      .InSequence(s);
+  EXPECT_CALL(a, ReturnResult(1)).InSequence(s);
+  EXPECT_CALL(a, ReturnResult(2)).InSequence(s);
 
   // May only be called after a.ReturnResult(1).
   EXPECT_NONFATAL_FAILURE(a.ReturnResult(2), "Unexpected mock function call");
@@ -1378,8 +1320,7 @@ TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
 class PartialOrderTest : public testing::Test {
  protected:
   PartialOrderTest() {
-    ON_CALL(a_, ReturnResult(_))
-        .WillByDefault(Return(Result()));
+    ON_CALL(a_, ReturnResult(_)).WillByDefault(Return(Result()));
 
     // Specifies this partial ordering:
     //
@@ -1387,16 +1328,10 @@ class PartialOrderTest : public testing::Test {
     //                       a.ReturnResult(2) * n  ==>  a.ReturnResult(3)
     // b.DoB() * 2       ==>
     Sequence x, y;
-    EXPECT_CALL(a_, ReturnResult(1))
-        .InSequence(x);
-    EXPECT_CALL(b_, DoB())
-        .Times(2)
-        .InSequence(y);
-    EXPECT_CALL(a_, ReturnResult(2))
-        .Times(AnyNumber())
-        .InSequence(x, y);
-    EXPECT_CALL(a_, ReturnResult(3))
-        .InSequence(x);
+    EXPECT_CALL(a_, ReturnResult(1)).InSequence(x);
+    EXPECT_CALL(b_, DoB()).Times(2).InSequence(y);
+    EXPECT_CALL(a_, ReturnResult(2)).Times(AnyNumber()).InSequence(x, y);
+    EXPECT_CALL(a_, ReturnResult(3)).InSequence(x);
   }
 
   MockA a_;
@@ -1448,13 +1383,9 @@ TEST(SequenceTest, Retirement) {
   MockA a;
   Sequence s;
 
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s);
-  EXPECT_CALL(a, DoA(_))
-      .InSequence(s)
-      .RetiresOnSaturation();
-  EXPECT_CALL(a, DoA(1))
-      .InSequence(s);
+  EXPECT_CALL(a, DoA(1)).InSequence(s);
+  EXPECT_CALL(a, DoA(_)).InSequence(s).RetiresOnSaturation();
+  EXPECT_CALL(a, DoA(1)).InSequence(s);
 
   a.DoA(1);
   a.DoA(2);
@@ -1519,12 +1450,12 @@ TEST(ExpectationSetTest, ConstructorsWork) {
 
   Expectation e1;
   const Expectation e2;
-  ExpectationSet es1;  // Default ctor.
+  ExpectationSet es1;                           // Default ctor.
   ExpectationSet es2 = EXPECT_CALL(a, DoA(1));  // Ctor from EXPECT_CALL.
-  ExpectationSet es3 = e1;  // Ctor from Expectation.
-  ExpectationSet es4(e1);   // Ctor from Expectation; alternative syntax.
-  ExpectationSet es5 = e2;  // Ctor from const Expectation.
-  ExpectationSet es6(e2);   // Ctor from const Expectation; alternative syntax.
+  ExpectationSet es3 = e1;                      // Ctor from Expectation.
+  ExpectationSet es4(e1);    // Ctor from Expectation; alternative syntax.
+  ExpectationSet es5 = e2;   // Ctor from const Expectation.
+  ExpectationSet es6(e2);    // Ctor from const Expectation; alternative syntax.
   ExpectationSet es7 = es2;  // Copy ctor.
 
   EXPECT_EQ(0, es1.size());
@@ -1596,7 +1527,7 @@ TEST(ExpectationSetTest, IsEnumerable) {
   EXPECT_TRUE(it != es.end());
   EXPECT_THAT(*it, Eq(Expectation()));
   ++it;
-  EXPECT_TRUE(it== es.end());
+  EXPECT_TRUE(it == es.end());
 }
 
 // Tests the .After() clause.
@@ -1606,8 +1537,7 @@ TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
   ExpectationSet es;
   es += EXPECT_CALL(a, DoA(1));
   es += EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(es);
+  EXPECT_CALL(a, DoA(3)).After(es);
 
   a.DoA(1);
   a.DoA(2);
@@ -1620,9 +1550,7 @@ TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
   // The following also verifies that const Expectation objects work
   // too.  Do not remove the const modifiers.
   const Expectation e1 = EXPECT_CALL(a, DoA(1));
-  const Expectation e2 = EXPECT_CALL(b, DoB())
-      .Times(2)
-      .After(e1);
+  const Expectation e2 = EXPECT_CALL(b, DoB()).Times(2).After(e1);
   EXPECT_CALL(a, DoA(2)).After(e2);
 
   a.DoA(1);
@@ -1639,10 +1567,8 @@ TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
   // Define ordering:
   //   a.DoA(1) ==> b.DoB() ==> a.DoA(2)
   Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(b, DoB())
-      .After(e1);
-  EXPECT_CALL(a, DoA(2))
-      .After(e2);
+  Expectation e2 = EXPECT_CALL(b, DoB()).After(e1);
+  EXPECT_CALL(a, DoA(2)).After(e2);
 
   a.DoA(1);
 
@@ -1661,11 +1587,8 @@ TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
   // Define ordering:
   //   a.DoA(1) ==> b.DoB() * 2 ==> a.DoA(2)
   Expectation e1 = EXPECT_CALL(a, DoA(1));
-  Expectation e2 = EXPECT_CALL(b, DoB())
-      .Times(2)
-      .After(e1);
-  EXPECT_CALL(a, DoA(2))
-      .After(e2);
+  Expectation e2 = EXPECT_CALL(b, DoB()).Times(2).After(e1);
+  EXPECT_CALL(a, DoA(2)).After(e2);
 
   a.DoA(1);
   b.DoB();
@@ -1680,16 +1603,14 @@ TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
 // Calls must satisfy the partial order when specified so.
 TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
   MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
+  ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
 
   // Define ordering:
   //   a.DoA(1) ==>
   //   a.DoA(2) ==> a.ReturnResult(3)
   Expectation e = EXPECT_CALL(a, DoA(1));
   const ExpectationSet es = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, ReturnResult(3))
-      .After(e, es);
+  EXPECT_CALL(a, ReturnResult(3)).After(e, es);
 
   // May only be called last.
   EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
@@ -1708,8 +1629,7 @@ TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
   //   a.DoA(2) ==> a.DoA(3)
   Expectation e = EXPECT_CALL(a, DoA(1));
   const ExpectationSet es = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(e, es);
+  EXPECT_CALL(a, DoA(3)).After(e, es);
 
   a.DoA(2);
 
@@ -1726,9 +1646,7 @@ TEST(AfterTest, CanBeUsedWithInSequence) {
   Sequence s;
   Expectation e = EXPECT_CALL(a, DoA(1));
   EXPECT_CALL(a, DoA(2)).InSequence(s);
-  EXPECT_CALL(a, DoA(3))
-      .InSequence(s)
-      .After(e);
+  EXPECT_CALL(a, DoA(3)).InSequence(s).After(e);
 
   a.DoA(1);
 
@@ -1745,10 +1663,7 @@ TEST(AfterTest, CanBeCalledManyTimes) {
   Expectation e1 = EXPECT_CALL(a, DoA(1));
   Expectation e2 = EXPECT_CALL(a, DoA(2));
   Expectation e3 = EXPECT_CALL(a, DoA(3));
-  EXPECT_CALL(a, DoA(4))
-      .After(e1)
-      .After(e2)
-      .After(e3);
+  EXPECT_CALL(a, DoA(4)).After(e1).After(e2).After(e3);
 
   a.DoA(3);
   a.DoA(1);
@@ -1764,8 +1679,7 @@ TEST(AfterTest, AcceptsUpToFiveArguments) {
   Expectation e3 = EXPECT_CALL(a, DoA(3));
   ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
   ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
-  EXPECT_CALL(a, DoA(6))
-      .After(e1, e2, e3, es1, es2);
+  EXPECT_CALL(a, DoA(6)).After(e1, e2, e3, es1, es2);
 
   a.DoA(5);
   a.DoA(2);
@@ -1778,8 +1692,7 @@ TEST(AfterTest, AcceptsUpToFiveArguments) {
 // .After() allows input to contain duplicated Expectations.
 TEST(AfterTest, AcceptsDuplicatedInput) {
   MockA a;
-  ON_CALL(a, ReturnResult(_))
-      .WillByDefault(Return(Result()));
+  ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
 
   // Define ordering:
   //   DoA(1) ==>
@@ -1789,8 +1702,7 @@ TEST(AfterTest, AcceptsDuplicatedInput) {
   ExpectationSet es;
   es += e1;
   es += e2;
-  EXPECT_CALL(a, ReturnResult(3))
-      .After(e1, e2, es, e1);
+  EXPECT_CALL(a, ReturnResult(3)).After(e1, e2, es, e1);
 
   a.DoA(1);
 
@@ -1807,8 +1719,7 @@ TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
   MockA a;
   ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
   Expectation e2 = EXPECT_CALL(a, DoA(2));
-  EXPECT_CALL(a, DoA(3))
-      .After(es1);
+  EXPECT_CALL(a, DoA(3)).After(es1);
   es1 += e2;
 
   a.DoA(1);
@@ -1827,14 +1738,11 @@ TEST(DeletingMockEarlyTest, Success1) {
 
   {
     InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
+    EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
     EXPECT_CALL(*a, Binary(_, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return(true));
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
   }
 
   EXPECT_EQ(1, b1->DoB(1));
@@ -1855,13 +1763,9 @@ TEST(DeletingMockEarlyTest, Success2) {
 
   {
     InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
+    EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
   }
 
   delete a;  // a is trivially satisfied.
@@ -1876,14 +1780,14 @@ TEST(DeletingMockEarlyTest, Success2) {
 // Suppresses warning on unreferenced formal parameter in MSVC with
 // -W4.
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #endif
 
 ACTION_P(Delete, ptr) { delete ptr; }
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
@@ -1894,8 +1798,7 @@ TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
 
 TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
   MockA* const a = new MockA;
-  EXPECT_CALL(*a, ReturnResult(_))
-      .WillOnce(DoAll(Delete(a), Return(Result())));
+  EXPECT_CALL(*a, ReturnResult(_)).WillOnce(DoAll(Delete(a), Return(Result())));
   a->ReturnResult(42);  // This will cause a to be deleted.
 }
 
@@ -1907,19 +1810,13 @@ TEST(DeletingMockEarlyTest, Failure1) {
 
   {
     InSequence dummy;
-    EXPECT_CALL(*b1, DoB(_))
-        .WillOnce(Return(1));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return(2));
+    EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
+    EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
   }
 
   delete a;  // a is trivially satisfied.
-  EXPECT_NONFATAL_FAILURE({
-    b2->DoB(2);
-  }, "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE({ b2->DoB(2); }, "Unexpected mock function call");
   EXPECT_EQ(1, b1->DoB(1));
   delete b1;
   delete b2;
@@ -1934,18 +1831,13 @@ TEST(DeletingMockEarlyTest, Failure2) {
   {
     InSequence dummy;
     EXPECT_CALL(*b1, DoB(_));
-    EXPECT_CALL(*a, Binary(_, _))
-        .Times(AnyNumber());
-    EXPECT_CALL(*b2, DoB(_))
-        .Times(AnyNumber());
+    EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
+    EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber());
   }
 
-  EXPECT_NONFATAL_FAILURE(delete b1,
-                          "Actual: never called");
-  EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
-                          "Unexpected mock function call");
-  EXPECT_NONFATAL_FAILURE(b2->DoB(1),
-                          "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(delete b1, "Actual: never called");
+  EXPECT_NONFATAL_FAILURE(a->Binary(0, 1), "Unexpected mock function call");
+  EXPECT_NONFATAL_FAILURE(b2->DoB(1), "Unexpected mock function call");
   delete a;
   delete b2;
 }
@@ -1970,23 +1862,16 @@ class EvenNumberCardinality : public CardinalityInterface {
   }
 };
 
-Cardinality EvenNumber() {
-  return Cardinality(new EvenNumberCardinality);
-}
+Cardinality EvenNumber() { return Cardinality(new EvenNumberCardinality); }
 
 TEST(ExpectationBaseTest,
      AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
   MockA* a = new MockA;
   Sequence s;
 
-  EXPECT_CALL(*a, DoA(1))
-      .Times(EvenNumber())
-      .InSequence(s);
-  EXPECT_CALL(*a, DoA(2))
-      .Times(AnyNumber())
-      .InSequence(s);
-  EXPECT_CALL(*a, DoA(3))
-      .Times(AnyNumber());
+  EXPECT_CALL(*a, DoA(1)).Times(EvenNumber()).InSequence(s);
+  EXPECT_CALL(*a, DoA(2)).Times(AnyNumber()).InSequence(s);
+  EXPECT_CALL(*a, DoA(3)).Times(AnyNumber());
 
   a->DoA(3);
   a->DoA(1);
@@ -1997,8 +1882,7 @@ TEST(ExpectationBaseTest,
 // The following tests verify the message generated when a mock
 // function is called.
 
-struct Printable {
-};
+struct Printable {};
 
 inline void operator<<(::std::ostream& os, const Printable&) {
   os << "Printable";
@@ -2018,22 +1902,25 @@ class MockC {
   MOCK_METHOD0(NonVoidMethod, int());  // NOLINT
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
+  MockC(const MockC&) = delete;
+  MockC& operator=(const MockC&) = delete;
 };
 
 class VerboseFlagPreservingFixture : public testing::Test {
  protected:
   VerboseFlagPreservingFixture()
-      : saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
+      : saved_verbose_flag_(GMOCK_FLAG_GET(verbose)) {}
 
   ~VerboseFlagPreservingFixture() override {
-    GMOCK_FLAG(verbose) = saved_verbose_flag_;
+    GMOCK_FLAG_SET(verbose, saved_verbose_flag_);
   }
 
  private:
   const std::string saved_verbose_flag_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
+  VerboseFlagPreservingFixture(const VerboseFlagPreservingFixture&) = delete;
+  VerboseFlagPreservingFixture& operator=(const VerboseFlagPreservingFixture&) =
+      delete;
 };
 
 #if GTEST_HAS_STREAM_REDIRECTION
@@ -2043,7 +1930,7 @@ class VerboseFlagPreservingFixture : public testing::Test {
 // --gmock_verbose=warning is specified.
 TEST(FunctionCallMessageTest,
      UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  GMOCK_FLAG_SET(verbose, kWarningVerbosity);
   NaggyMock<MockC> c;
   CaptureStdout();
   c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
@@ -2057,7 +1944,7 @@ TEST(FunctionCallMessageTest,
 // --gmock_verbose=info is specified.
 TEST(FunctionCallMessageTest,
      UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
   NaggyMock<MockC> c;
   CaptureStdout();
   c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
@@ -2065,7 +1952,7 @@ TEST(FunctionCallMessageTest,
   EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
   EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
 
-# ifndef NDEBUG
+#ifndef NDEBUG
 
   // We check the stack trace content in dbg-mode only, as opt-mode
   // may inline the call we are interested in seeing.
@@ -2081,7 +1968,7 @@ TEST(FunctionCallMessageTest,
   const std::string output2 = GetCapturedStdout();
   EXPECT_PRED_FORMAT2(IsSubstring, "NonVoidMethod(", output2);
 
-# endif  // NDEBUG
+#endif  // NDEBUG
 }
 
 // Tests that an uninteresting mock function call on a naggy mock
@@ -2097,7 +1984,8 @@ TEST(FunctionCallMessageTest,
       IsSubstring,
       "Uninteresting mock function call - returning default value.\n"
       "    Function call: DoB()\n"
-      "          Returns: 0\n", output1.c_str());
+      "          Returns: 0\n",
+      output1.c_str());
   // Makes sure the return value is printed.
 
   // A void mock function.
@@ -2105,12 +1993,12 @@ TEST(FunctionCallMessageTest,
   CaptureStdout();
   c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
   const std::string output2 = GetCapturedStdout();
-  EXPECT_THAT(output2.c_str(),
-              ContainsRegex(
-                  "Uninteresting mock function call - returning directly\\.\n"
-                  "    Function call: VoidMethod"
-                  "\\(false, 5, \"Hi\", NULL, @.+ "
-                  "Printable, 4-byte object <00-00 00-00>\\)"));
+  EXPECT_THAT(
+      output2.c_str(),
+      ContainsRegex("Uninteresting mock function call - returning directly\\.\n"
+                    "    Function call: VoidMethod"
+                    "\\(false, 5, \"Hi\", NULL, @.+ "
+                    "Printable, 4-byte object <00-00 00-00>\\)"));
   // A void function has no return value to print.
 }
 
@@ -2127,14 +2015,14 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
                     const std::string& function_name) {
     if (should_print) {
       EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
-# ifndef NDEBUG
+#ifndef NDEBUG
       // We check the stack trace content in dbg-mode only, as opt-mode
       // may inline the call we are interested in seeing.
       EXPECT_THAT(output.c_str(), HasSubstr(function_name));
-# else
+#else
       // Suppresses 'unused function parameter' warnings.
       static_cast<void>(function_name);
-# endif  // NDEBUG
+#endif  // NDEBUG
     } else {
       EXPECT_STREQ("", output.c_str());
     }
@@ -2144,31 +2032,26 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
   void TestExpectedCall(bool should_print) {
     MockA a;
     EXPECT_CALL(a, DoA(5));
-    EXPECT_CALL(a, Binary(_, 1))
-        .WillOnce(Return(true));
+    EXPECT_CALL(a, Binary(_, 1)).WillOnce(Return(true));
 
     // A void-returning function.
     CaptureStdout();
     a.DoA(5);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
-        "    Function call: DoA(5)\n"
-        "Stack trace:\n",
-        "DoA");
+    VerifyOutput(GetCapturedStdout(), should_print,
+                 "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
+                 "    Function call: DoA(5)\n"
+                 "Stack trace:\n",
+                 "DoA");
 
     // A non-void-returning function.
     CaptureStdout();
     a.Binary(2, 1);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
-        "    Function call: Binary(2, 1)\n"
-        "          Returns: true\n"
-        "Stack trace:\n",
-        "Binary");
+    VerifyOutput(GetCapturedStdout(), should_print,
+                 "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
+                 "    Function call: Binary(2, 1)\n"
+                 "          Returns: true\n"
+                 "Stack trace:\n",
+                 "Binary");
   }
 
   // Tests how the flag affects uninteresting calls on a naggy mock.
@@ -2179,41 +2062,37 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
         "call should not happen.  Do not suppress it by blindly adding "
         "an EXPECT_CALL() if you don't mean to enforce the call.  "
         "See "
-        "https://github.com/google/googletest/blob/master/docs/"
+        "https://github.com/google/googletest/blob/main/docs/"
         "gmock_cook_book.md#"
         "knowing-when-to-expect for details.";
 
     // A void-returning function.
     CaptureStdout();
     a.DoA(5);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "\nGMOCK WARNING:\n"
-        "Uninteresting mock function call - returning directly.\n"
-        "    Function call: DoA(5)\n" +
-        note,
-        "DoA");
+    VerifyOutput(GetCapturedStdout(), should_print,
+                 "\nGMOCK WARNING:\n"
+                 "Uninteresting mock function call - returning directly.\n"
+                 "    Function call: DoA(5)\n" +
+                     note,
+                 "DoA");
 
     // A non-void-returning function.
     CaptureStdout();
     a.Binary(2, 1);
-    VerifyOutput(
-        GetCapturedStdout(),
-        should_print,
-        "\nGMOCK WARNING:\n"
-        "Uninteresting mock function call - returning default value.\n"
-        "    Function call: Binary(2, 1)\n"
-        "          Returns: false\n" +
-        note,
-        "Binary");
+    VerifyOutput(GetCapturedStdout(), should_print,
+                 "\nGMOCK WARNING:\n"
+                 "Uninteresting mock function call - returning default value.\n"
+                 "    Function call: Binary(2, 1)\n"
+                 "          Returns: false\n" +
+                     note,
+                 "Binary");
   }
 };
 
 // Tests that --gmock_verbose=info causes both expected and
 // uninteresting calls to be reported.
 TEST_F(GMockVerboseFlagTest, Info) {
-  GMOCK_FLAG(verbose) = kInfoVerbosity;
+  GMOCK_FLAG_SET(verbose, kInfoVerbosity);
   TestExpectedCall(true);
   TestUninterestingCallOnNaggyMock(true);
 }
@@ -2221,7 +2100,7 @@ TEST_F(GMockVerboseFlagTest, Info) {
 // Tests that --gmock_verbose=warning causes uninteresting calls to be
 // reported.
 TEST_F(GMockVerboseFlagTest, Warning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
+  GMOCK_FLAG_SET(verbose, kWarningVerbosity);
   TestExpectedCall(false);
   TestUninterestingCallOnNaggyMock(true);
 }
@@ -2229,7 +2108,7 @@ TEST_F(GMockVerboseFlagTest, Warning) {
 // Tests that --gmock_verbose=warning causes neither expected nor
 // uninteresting calls to be reported.
 TEST_F(GMockVerboseFlagTest, Error) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
+  GMOCK_FLAG_SET(verbose, kErrorVerbosity);
   TestExpectedCall(false);
   TestUninterestingCallOnNaggyMock(false);
 }
@@ -2237,7 +2116,7 @@ TEST_F(GMockVerboseFlagTest, Error) {
 // Tests that --gmock_verbose=SOME_INVALID_VALUE has the same effect
 // as --gmock_verbose=warning.
 TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
-  GMOCK_FLAG(verbose) = "invalid";  // Treated as "warning".
+  GMOCK_FLAG_SET(verbose, "invalid");  // Treated as "warning".
   TestExpectedCall(false);
   TestUninterestingCallOnNaggyMock(true);
 }
@@ -2261,7 +2140,8 @@ class LogTestHelper {
   MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
+  LogTestHelper(const LogTestHelper&) = delete;
+  LogTestHelper& operator=(const LogTestHelper&) = delete;
 };
 
 class GMockLogTest : public VerboseFlagPreservingFixture {
@@ -2270,23 +2150,20 @@ class GMockLogTest : public VerboseFlagPreservingFixture {
 };
 
 TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
-  GMOCK_FLAG(verbose) = kWarningVerbosity;
-  EXPECT_CALL(helper_, Foo(_))
-      .WillOnce(Return(PrintMeNot()));
+  GMOCK_FLAG_SET(verbose, kWarningVerbosity);
+  EXPECT_CALL(helper_, Foo(_)).WillOnce(Return(PrintMeNot()));
   helper_.Foo(PrintMeNot());  // This is an expected call.
 }
 
 TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  EXPECT_CALL(helper_, Foo(_))
-      .WillOnce(Return(PrintMeNot()));
+  GMOCK_FLAG_SET(verbose, kErrorVerbosity);
+  EXPECT_CALL(helper_, Foo(_)).WillOnce(Return(PrintMeNot()));
   helper_.Foo(PrintMeNot());  // This is an expected call.
 }
 
 TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
-  GMOCK_FLAG(verbose) = kErrorVerbosity;
-  ON_CALL(helper_, Foo(_))
-      .WillByDefault(Return(PrintMeNot()));
+  GMOCK_FLAG_SET(verbose, kErrorVerbosity);
+  ON_CALL(helper_, Foo(_)).WillByDefault(Return(PrintMeNot()));
   helper_.Foo(PrintMeNot());  // This should generate a warning.
 }
 
@@ -2347,8 +2224,7 @@ TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
 // verification succeeds.
 TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
   MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(1));
   b.DoB();
   ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
 
@@ -2363,8 +2239,7 @@ TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
 // verification fails.
 TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
   MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(1));
   bool result = true;
   EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
                           "Actual: never called");
@@ -2380,10 +2255,8 @@ TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
 // when all of its methods have expectations.
 TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
   MockB b;
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(1));
+  EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
   b.DoB();
   b.DoB(1);
   ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
@@ -2398,10 +2271,8 @@ TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
 // when a method has more than one expectation.
 TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
   MockB b;
-  EXPECT_CALL(b, DoB(0))
-      .WillOnce(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
+  EXPECT_CALL(b, DoB(0)).WillOnce(Return(1));
+  EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
   b.DoB(1);
   bool result = true;
   EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
@@ -2422,8 +2293,7 @@ TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
   b.DoB();
   Mock::VerifyAndClearExpectations(&b);
 
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(1));
+  EXPECT_CALL(b, DoB(_)).WillOnce(Return(1));
   b.DoB(1);
   Mock::VerifyAndClearExpectations(&b);
   Mock::VerifyAndClearExpectations(&b);
@@ -2447,8 +2317,7 @@ TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
 // but not all of its methods have default actions.
 TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
   MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
+  ON_CALL(b, DoB()).WillByDefault(Return(1));
 
   Mock::VerifyAndClear(&b);
 
@@ -2460,10 +2329,8 @@ TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
 // its methods have default actions.
 TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
   MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(2));
+  ON_CALL(b, DoB()).WillByDefault(Return(1));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(2));
 
   Mock::VerifyAndClear(&b);
 
@@ -2478,10 +2345,8 @@ TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
 // method has more than one ON_CALL() set on it.
 TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
   MockB b;
-  ON_CALL(b, DoB(0))
-      .WillByDefault(Return(1));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(2));
+  ON_CALL(b, DoB(0)).WillByDefault(Return(1));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(2));
 
   Mock::VerifyAndClear(&b);
 
@@ -2495,13 +2360,11 @@ TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
 // times.
 TEST(VerifyAndClearTest, CanCallManyTimes) {
   MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
+  ON_CALL(b, DoB()).WillByDefault(Return(1));
   Mock::VerifyAndClear(&b);
   Mock::VerifyAndClear(&b);
 
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(1));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(1));
   Mock::VerifyAndClear(&b);
 
   EXPECT_EQ(0, b.DoB());
@@ -2511,10 +2374,8 @@ TEST(VerifyAndClearTest, CanCallManyTimes) {
 // Tests that VerifyAndClear() works when the verification succeeds.
 TEST(VerifyAndClearTest, Success) {
   MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(1))
-      .WillOnce(Return(2));
+  ON_CALL(b, DoB()).WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(1)).WillOnce(Return(2));
 
   b.DoB();
   b.DoB(1);
@@ -2529,10 +2390,8 @@ TEST(VerifyAndClearTest, Success) {
 // Tests that VerifyAndClear() works when the verification fails.
 TEST(VerifyAndClearTest, Failure) {
   MockB b;
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(2));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(2));
 
   b.DoB(1);
   bool result = true;
@@ -2550,12 +2409,9 @@ TEST(VerifyAndClearTest, Failure) {
 // expectations are set on a const mock object.
 TEST(VerifyAndClearTest, Const) {
   MockB b;
-  ON_CALL(Const(b), DoB())
-      .WillByDefault(Return(1));
+  ON_CALL(Const(b), DoB()).WillByDefault(Return(1));
 
-  EXPECT_CALL(Const(b), DoB())
-      .WillOnce(DoDefault())
-      .WillOnce(Return(2));
+  EXPECT_CALL(Const(b), DoB()).WillOnce(DoDefault()).WillOnce(Return(2));
 
   b.DoB();
   b.DoB();
@@ -2571,18 +2427,14 @@ TEST(VerifyAndClearTest, Const) {
 // object after VerifyAndClear() has been called on it.
 TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
   MockB b;
-  ON_CALL(b, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b, DoB(_))
-      .WillOnce(Return(2));
+  ON_CALL(b, DoB()).WillByDefault(Return(1));
+  EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
   b.DoB(1);
 
   Mock::VerifyAndClear(&b);
 
-  EXPECT_CALL(b, DoB())
-      .WillOnce(Return(3));
-  ON_CALL(b, DoB(_))
-      .WillByDefault(Return(4));
+  EXPECT_CALL(b, DoB()).WillOnce(Return(3));
+  ON_CALL(b, DoB(_)).WillByDefault(Return(4));
 
   EXPECT_EQ(3, b.DoB());
   EXPECT_EQ(4, b.DoB(1));
@@ -2595,19 +2447,13 @@ TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
   MockB b1;
   MockB b2;
 
-  ON_CALL(a, Binary(_, _))
-      .WillByDefault(Return(true));
-  EXPECT_CALL(a, Binary(_, _))
-      .WillOnce(DoDefault())
-      .WillOnce(Return(false));
+  ON_CALL(a, Binary(_, _)).WillByDefault(Return(true));
+  EXPECT_CALL(a, Binary(_, _)).WillOnce(DoDefault()).WillOnce(Return(false));
 
-  ON_CALL(b1, DoB())
-      .WillByDefault(Return(1));
-  EXPECT_CALL(b1, DoB(_))
-      .WillOnce(Return(2));
+  ON_CALL(b1, DoB()).WillByDefault(Return(1));
+  EXPECT_CALL(b1, DoB(_)).WillOnce(Return(2));
 
-  ON_CALL(b2, DoB())
-      .WillByDefault(Return(3));
+  ON_CALL(b2, DoB()).WillByDefault(Return(3));
   EXPECT_CALL(b2, DoB(_));
 
   b2.DoB(0);
@@ -2648,8 +2494,7 @@ TEST(VerifyAndClearTest,
   ReferenceHoldingMock test_mock;
 
   // ON_CALL stores a reference to a inside test_mock.
-  ON_CALL(test_mock, AcceptReference(_))
-      .WillByDefault(SetArgPointee<0>(a));
+  ON_CALL(test_mock, AcceptReference(_)).WillByDefault(SetArgPointee<0>(a));
 
   // Throw away the reference to the mock that we have in a. After this, the
   // only reference to it is stored by test_mock.
@@ -2670,9 +2515,8 @@ TEST(VerifyAndClearTest,
 TEST(SynchronizationTest, CanCallMockMethodInAction) {
   MockA a;
   MockC c;
-  ON_CALL(a, DoA(_))
-      .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
-                                                    &MockC::NonVoidMethod)));
+  ON_CALL(a, DoA(_)).WillByDefault(
+      IgnoreResult(InvokeWithoutArgs(&c, &MockC::NonVoidMethod)));
   EXPECT_CALL(a, DoA(1));
   EXPECT_CALL(a, DoA(1))
       .WillOnce(Invoke(&a, &MockA::DoA))
@@ -2756,20 +2600,21 @@ TEST(ParameterlessExpectationsTest,
 }
 
 }  // namespace
+}  // namespace testing
 
 // Allows the user to define their own main and then invoke gmock_main
 // from it. This might be necessary on some platforms which require
 // specific setup and teardown.
 #if GMOCK_RENAME_MAIN
-int gmock_main(int argc, char **argv) {
+int gmock_main(int argc, char** argv) {
 #else
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
 #endif  // GMOCK_RENAME_MAIN
   testing::InitGoogleMock(&argc, argv);
   // Ensures that the tests pass no matter what value of
   // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
-  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
-  testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
+  GMOCK_FLAG_SET(catch_leaked_mocks, true);
+  GMOCK_FLAG_SET(verbose, testing::internal::kWarningVerbosity);
 
   return RUN_ALL_TESTS();
 }
diff --git a/googletest/googlemock/test/gmock_all_test.cc b/googletest/googlemock/test/gmock_all_test.cc
index fffbb8b66f09f966425ceac3f3a515672c69d9b6..6db0086bb724406d446e1b09983f477041165d28 100644
--- a/googletest/googlemock/test/gmock_all_test.cc
+++ b/googletest/googlemock/test/gmock_all_test.cc
@@ -38,7 +38,10 @@
 #include "test/gmock-actions_test.cc"
 #include "test/gmock-cardinalities_test.cc"
 #include "test/gmock-internal-utils_test.cc"
-#include "test/gmock-matchers_test.cc"
+#include "test/gmock-matchers-arithmetic_test.cc"
+#include "test/gmock-matchers-comparisons_test.cc"
+#include "test/gmock-matchers-containers_test.cc"
+#include "test/gmock-matchers-misc_test.cc"
 #include "test/gmock-more-actions_test.cc"
 #include "test/gmock-nice-strict_test.cc"
 #include "test/gmock-port_test.cc"
diff --git a/googletest/googlemock/test/gmock_ex_test.cc b/googletest/googlemock/test/gmock_ex_test.cc
index 72eb43f74ef4b8f5e9e4e3b199abe4657bec13fd..44e5e35f66a9b3fc165be147cc9e3b55c36f640e 100644
--- a/googletest/googlemock/test/gmock_ex_test.cc
+++ b/googletest/googlemock/test/gmock_ex_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests Google Mock's functionality that depends on exceptions.
 
 #include "gmock/gmock.h"
@@ -75,6 +74,5 @@ TEST(DefaultValueTest, ThrowsRuntimeErrorWhenNoDefaultValue) {
   }
 }
 
-
 }  // unnamed namespace
 #endif
diff --git a/googletest/googlemock/test/gmock_leak_test.py b/googletest/googlemock/test/gmock_leak_test.py
index 7e4b1eea9ae89107cd861352850e9abad94a14a4..4f41c7bbd0e9ce202840ca6ee39ae5b7ba5821d0 100644
--- a/googletest/googlemock/test/gmock_leak_test.py
+++ b/googletest/googlemock/test/gmock_leak_test.py
@@ -31,7 +31,7 @@
 
 """Tests that leaked mock objects can be caught be Google Mock."""
 
-import gmock_test_utils
+from googlemock.test import gmock_test_utils
 
 PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_leak_test_')
 TEST_WITH_EXPECT_CALL = [PROGRAM_PATH, '--gtest_filter=*ExpectCall*']
diff --git a/googletest/googlemock/test/gmock_leak_test_.cc b/googletest/googlemock/test/gmock_leak_test_.cc
index 2e095abcf49689dfd8bbbaa22b42f301471e3b4f..fa645916f89c8276a016d707bb260a6675f98d8b 100644
--- a/googletest/googlemock/test/gmock_leak_test_.cc
+++ b/googletest/googlemock/test/gmock_leak_test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This program is for verifying that a leaked mock object can be
@@ -52,7 +51,8 @@ class MockFoo : public FooInterface {
   MOCK_METHOD0(DoThis, void());
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+  MockFoo(const MockFoo&) = delete;
+  MockFoo& operator=(const MockFoo&) = delete;
 };
 
 TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
diff --git a/googletest/googlemock/test/gmock_link2_test.cc b/googletest/googlemock/test/gmock_link2_test.cc
index d27ce176887bf8b2879bcbf2ad597c28fca4d1de..cd3d6908876129c79c0bbe795f8f634821198df3 100644
--- a/googletest/googlemock/test/gmock_link2_test.cc
+++ b/googletest/googlemock/test/gmock_link2_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file is for verifying that various Google Mock constructs do not
diff --git a/googletest/googlemock/test/gmock_link_test.cc b/googletest/googlemock/test/gmock_link_test.cc
index e7c54cc230683de2d5688b00f251cb5c9fda116d..f51e3988df3a3bc54c53609d4ef6717a40a8ed5a 100644
--- a/googletest/googlemock/test/gmock_link_test.cc
+++ b/googletest/googlemock/test/gmock_link_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file is for verifying that various Google Mock constructs do not
diff --git a/googletest/googlemock/test/gmock_link_test.h b/googletest/googlemock/test/gmock_link_test.h
index 5734b2e11c853647e0363638b7d550e9bfc8ad06..eaf18e9d8c6355031e062bf9845b7d64cb4de33b 100644
--- a/googletest/googlemock/test/gmock_link_test.h
+++ b/googletest/googlemock/test/gmock_link_test.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests that:
@@ -118,7 +117,7 @@
 #include "gmock/gmock.h"
 
 #if !GTEST_OS_WINDOWS_MOBILE
-# include <errno.h>
+#include <errno.h>
 #endif
 
 #include <iostream>
@@ -200,14 +199,14 @@ class Interface {
   virtual char* StringFromString(char* str) = 0;
   virtual int IntFromString(char* str) = 0;
   virtual int& IntRefFromString(char* str) = 0;
-  virtual void VoidFromFunc(void(*func)(char* str)) = 0;
+  virtual void VoidFromFunc(void (*func)(char* str)) = 0;
   virtual void VoidFromIntRef(int& n) = 0;  // NOLINT
   virtual void VoidFromFloat(float n) = 0;
   virtual void VoidFromDouble(double n) = 0;
   virtual void VoidFromVector(const std::vector<int>& v) = 0;
 };
 
-class Mock: public Interface {
+class Mock : public Interface {
  public:
   Mock() {}
 
@@ -215,14 +214,15 @@ class Mock: public Interface {
   MOCK_METHOD1(StringFromString, char*(char* str));
   MOCK_METHOD1(IntFromString, int(char* str));
   MOCK_METHOD1(IntRefFromString, int&(char* str));
-  MOCK_METHOD1(VoidFromFunc, void(void(*func)(char* str)));
+  MOCK_METHOD1(VoidFromFunc, void(void (*func)(char* str)));
   MOCK_METHOD1(VoidFromIntRef, void(int& n));  // NOLINT
   MOCK_METHOD1(VoidFromFloat, void(float n));
   MOCK_METHOD1(VoidFromDouble, void(double n));
   MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
+  Mock(const Mock&) = delete;
+  Mock& operator=(const Mock&) = delete;
 };
 
 class InvokeHelper {
@@ -301,8 +301,8 @@ TEST(LinkTest, TestSetArrayArgument) {
   char ch = 'x';
   char ch2 = 'y';
 
-  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(SetArrayArgument<0>(&ch2,
-                                                                    &ch2 + 1));
+  EXPECT_CALL(mock, VoidFromString(_))
+      .WillOnce(SetArrayArgument<0>(&ch2, &ch2 + 1));
   mock.VoidFromString(&ch);
 }
 
@@ -339,8 +339,8 @@ TEST(LinkTest, TestInvokeWithoutArgs) {
 
   EXPECT_CALL(mock, VoidFromString(_))
       .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
-      .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
-                                  &InvokeHelper::VoidFromVoid));
+      .WillOnce(
+          InvokeWithoutArgs(&test_invoke_helper, &InvokeHelper::VoidFromVoid));
   mock.VoidFromString(nullptr);
   mock.VoidFromString(nullptr);
 }
@@ -424,14 +424,14 @@ TEST(LinkTest, TestThrow) {
 // is expanded and macro expansion cannot contain #pragma.  Therefore
 // we suppress them here.
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #endif
 
 // Tests the linkage of actions created using ACTION macro.
 namespace {
 ACTION(Return1) { return 1; }
-}
+}  // namespace
 
 TEST(LinkTest, TestActionMacro) {
   Mock mock;
@@ -443,7 +443,7 @@ TEST(LinkTest, TestActionMacro) {
 // Tests the linkage of actions created using ACTION_P macro.
 namespace {
 ACTION_P(ReturnArgument, ret_value) { return ret_value; }
-}
+}  // namespace
 
 TEST(LinkTest, TestActionPMacro) {
   Mock mock;
@@ -457,10 +457,10 @@ namespace {
 ACTION_P2(ReturnEqualsEitherOf, first, second) {
   return arg0 == first || arg0 == second;
 }
-}
+}  // namespace
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 TEST(LinkTest, TestActionP2Macro) {
@@ -492,8 +492,7 @@ TEST(LinkTest, TestMatchersEq) {
   const char* p = "x";
 
   ON_CALL(mock, VoidFromString(Eq(p))).WillByDefault(Return());
-  ON_CALL(mock, VoidFromString(const_cast<char*>("y")))
-      .WillByDefault(Return());
+  ON_CALL(mock, VoidFromString(const_cast<char*>("y"))).WillByDefault(Return());
 }
 
 // Tests the linkage of the Lt, Gt, Le, Ge, and Ne matchers.
@@ -592,7 +591,7 @@ TEST(LinkTest, TestMatcherElementsAre) {
 // Tests the linkage of the ElementsAreArray matcher.
 TEST(LinkTest, TestMatcherElementsAreArray) {
   Mock mock;
-  char arr[] = { 'a', 'b' };
+  char arr[] = {'a', 'b'};
 
   ON_CALL(mock, VoidFromVector(ElementsAreArray(arr))).WillByDefault(Return());
 }
diff --git a/googletest/googlemock/test/gmock_output_test.py b/googletest/googlemock/test/gmock_output_test.py
index 25f99f2b7977dfe060c27ea9cf6598e36536915b..d7c3f27e876b661be4c8e204f27544c7839438ab 100644
--- a/googletest/googlemock/test/gmock_output_test.py
+++ b/googletest/googlemock/test/gmock_output_test.py
@@ -43,7 +43,7 @@ from io import open    # pylint: disable=redefined-builtin, g-importing-member
 import os
 import re
 import sys
-import gmock_test_utils
+from googlemock.test import gmock_test_utils
 
 
 # The flag for generating the golden file
@@ -159,15 +159,18 @@ class GMockOutputTest(gmock_test_utils.TestCase):
     golden_file = open(GOLDEN_PATH, 'rb')
     golden = golden_file.read().decode('utf-8')
     golden_file.close()
+    # On Windows the repository might have been checked out with \r\n line
+    # endings, so normalize it here.
+    golden = ToUnixLineEnding(golden)
 
     # The normalized output should match the golden file.
-    self.assertEquals(golden, output)
+    self.assertEqual(golden, output)
 
     # The raw output should contain 2 leaked mock object errors for
     # test GMockOutputTest.CatchesLeakedMocks.
-    self.assertEquals(['GMockOutputTest.CatchesLeakedMocks',
-                       'GMockOutputTest.CatchesLeakedMocks'],
-                      leaky_tests)
+    self.assertEqual(['GMockOutputTest.CatchesLeakedMocks',
+                      'GMockOutputTest.CatchesLeakedMocks'],
+                     leaky_tests)
 
 
 if __name__ == '__main__':
diff --git a/googletest/googlemock/test/gmock_output_test_.cc b/googletest/googlemock/test/gmock_output_test_.cc
index 3955c7331a1233b60cb4f22e6f3a264472684d2f..a178691591bc1ef8117ee81a5d418d539f48df20 100644
--- a/googletest/googlemock/test/gmock_output_test_.cc
+++ b/googletest/googlemock/test/gmock_output_test_.cc
@@ -27,21 +27,20 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests Google Mock's output in various scenarios.  This ensures that
 // Google Mock's messages are readable and useful.
 
-#include "gmock/gmock.h"
-
 #include <stdio.h>
+
 #include <string>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 // Silence C4100 (unreferenced formal parameter)
 #ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#pragma warning(push)
+#pragma warning(disable : 4100)
 #endif
 
 using testing::_;
@@ -63,7 +62,8 @@ class MockFoo {
   MOCK_METHOD2(Bar3, void(int x, int y));
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
+  MockFoo(const MockFoo&) = delete;
+  MockFoo& operator=(const MockFoo&) = delete;
 };
 
 class GMockOutputTest : public testing::Test {
@@ -72,27 +72,25 @@ class GMockOutputTest : public testing::Test {
 };
 
 TEST_F(GMockOutputTest, ExpectedCall) {
-  testing::GMOCK_FLAG(verbose) = "info";
+  GMOCK_FLAG_SET(verbose, "info");
 
   EXPECT_CALL(foo_, Bar2(0, _));
   foo_.Bar2(0, 0);  // Expected call
 
-  testing::GMOCK_FLAG(verbose) = "warning";
+  GMOCK_FLAG_SET(verbose, "warning");
 }
 
 TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
-  testing::GMOCK_FLAG(verbose) = "info";
+  GMOCK_FLAG_SET(verbose, "info");
 
   EXPECT_CALL(foo_, Bar3(0, _));
   foo_.Bar3(0, 0);  // Expected call
 
-  testing::GMOCK_FLAG(verbose) = "warning";
+  GMOCK_FLAG_SET(verbose, "warning");
 }
 
 TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .Times(2)
-      .WillOnce(Return(false));
+  EXPECT_CALL(foo_, Bar2(_, _)).Times(2).WillOnce(Return(false));
   foo_.Bar2(2, 2);
   foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
 }
@@ -134,8 +132,7 @@ TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
 }
 
 TEST_F(GMockOutputTest, RetiredExpectation) {
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .RetiresOnSaturation();
+  EXPECT_CALL(foo_, Bar2(_, _)).RetiresOnSaturation();
   EXPECT_CALL(foo_, Bar2(0, 0));
 
   foo_.Bar2(1, 1);
@@ -160,12 +157,9 @@ TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
 TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
   Sequence s1, s2;
 
-  EXPECT_CALL(foo_, Bar(_, 0, _))
-      .InSequence(s1);
-  EXPECT_CALL(foo_, Bar2(0, 0))
-      .InSequence(s2);
-  EXPECT_CALL(foo_, Bar2(1, _))
-      .InSequence(s1, s2);
+  EXPECT_CALL(foo_, Bar(_, 0, _)).InSequence(s1);
+  EXPECT_CALL(foo_, Bar2(0, 0)).InSequence(s2);
+  EXPECT_CALL(foo_, Bar2(1, _)).InSequence(s1, s2);
 
   foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
   foo_.Bar("Hi", 0, 0);
@@ -179,8 +173,7 @@ TEST_F(GMockOutputTest, UnsatisfiedWith) {
 
 TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
   EXPECT_CALL(foo_, Bar(_, _, _));
-  EXPECT_CALL(foo_, Bar2(0, _))
-      .Times(2);
+  EXPECT_CALL(foo_, Bar2(0, _)).Times(2);
 
   foo_.Bar2(0, 1);
 }
@@ -194,26 +187,22 @@ TEST_F(GMockOutputTest, MismatchArguments) {
 }
 
 TEST_F(GMockOutputTest, MismatchWith) {
-  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
-      .With(Ge());
+  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))).With(Ge());
 
   foo_.Bar2(2, 3);  // Mismatch With()
   foo_.Bar2(2, 1);
 }
 
 TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
-  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
-      .With(Ge());
+  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))).With(Ge());
 
   foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
   foo_.Bar2(2, 1);
 }
 
 TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
+  ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 
   EXPECT_CALL(foo_, Bar2(2, 2));
   foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
@@ -222,10 +211,8 @@ TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
 }
 
 TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
+  ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 
   EXPECT_CALL(foo_, Bar2(2, 2));
   EXPECT_CALL(foo_, Bar2(1, 1));
@@ -237,22 +224,17 @@ TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
 }
 
 TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
-  ON_CALL(foo_, Bar2(1, _))
-      .WillByDefault(Return(false));  // Default action #2
+  ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(1, _)).WillByDefault(Return(false));  // Default action #2
 
   foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
   foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
 }
 
 TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
-  ON_CALL(foo_, Bar2(_, _))
-      .WillByDefault(Return(true));   // Default action #1
+  ON_CALL(foo_, Bar2(_, _)).WillByDefault(Return(true));  // Default action #1
 
-  EXPECT_CALL(foo_, Bar2(_, _))
-      .Times(2)
-      .WillOnce(Return(false));
+  EXPECT_CALL(foo_, Bar2(_, _)).Times(2).WillOnce(Return(false));
   foo_.Bar2(2, 2);
   foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
 }
@@ -293,17 +275,17 @@ void TestCatchesLeakedMocksInAdHocTests() {
   // foo is deliberately leaked.
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleMock(&argc, argv);
   // Ensures that the tests pass no matter what value of
   // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
-  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
-  testing::GMOCK_FLAG(verbose) = "warning";
+  GMOCK_FLAG_SET(catch_leaked_mocks, true);
+  GMOCK_FLAG_SET(verbose, "warning");
 
   TestCatchesLeakedMocksInAdHocTests();
   return RUN_ALL_TESTS();
 }
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
diff --git a/googletest/googlemock/test/gmock_output_test_golden.txt b/googletest/googlemock/test/gmock_output_test_golden.txt
index 4846c12430771e403030e43577051ca289b265f5..467fa20ef3ea5f0be74b66d19e7477b06ec78e86 100644
--- a/googletest/googlemock/test/gmock_output_test_golden.txt
+++ b/googletest/googlemock/test/gmock_output_test_golden.txt
@@ -75,14 +75,14 @@ GMOCK WARNING:
 Uninteresting mock function call - returning default value.
     Function call: Bar2(0, 1)
           Returns: false
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md#knowing-when-to-expect for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details.
 [       OK ] GMockOutputTest.UninterestingCall
 [ RUN      ] GMockOutputTest.UninterestingCallToVoidFunction
 
 GMOCK WARNING:
 Uninteresting mock function call - returning directly.
     Function call: Bar3(0, 1)
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md#knowing-when-to-expect for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details.
 [       OK ] GMockOutputTest.UninterestingCallToVoidFunction
 [ RUN      ] GMockOutputTest.RetiredExpectation
 unknown file: Failure
@@ -266,14 +266,14 @@ Uninteresting mock function call - taking default action specified at:
 FILE:#:
     Function call: Bar2(2, 2)
           Returns: true
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md#knowing-when-to-expect for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details.
 
 GMOCK WARNING:
 Uninteresting mock function call - taking default action specified at:
 FILE:#:
     Function call: Bar2(1, 1)
           Returns: false
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md#knowing-when-to-expect for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details.
 [       OK ] GMockOutputTest.UninterestingCallWithDefaultAction
 [ RUN      ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
 
@@ -291,7 +291,7 @@ Stack trace:
 [ RUN      ] GMockOutputTest.PrintsMatcher
 FILE:#: Failure
 Value of: (std::pair<int, bool>(42, true))
-Expected: is pair (is >= 48, true)
+Expected: is pair (first: is >= 48, second: true)
   Actual: (42, true) (of type std::pair<int, bool>)
 [  FAILED  ] GMockOutputTest.PrintsMatcher
 [  FAILED  ] GMockOutputTest.UnexpectedCall
diff --git a/googletest/googlemock/test/gmock_stress_test.cc b/googletest/googlemock/test/gmock_stress_test.cc
index 20725d69b7bf76fab1f8d91f59ff8d024588cae3..9e42cd935847c76914abf2ebd36f6e696ffc72b6 100644
--- a/googletest/googlemock/test/gmock_stress_test.cc
+++ b/googletest/googlemock/test/gmock_stress_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests that Google Mock constructs can be used in a large number of
 // threads concurrently.
 
@@ -49,7 +48,7 @@ const int kRepeat = 50;
 
 class MockFoo {
  public:
-  MOCK_METHOD1(Bar, int(int n));  // NOLINT
+  MOCK_METHOD1(Bar, int(int n));                                   // NOLINT
   MOCK_METHOD2(Baz, char(const char* s1, const std::string& s2));  // NOLINT
 };
 
@@ -62,21 +61,16 @@ void JoinAndDelete(ThreadWithParam<T>* t) {
 
 struct Dummy {};
 
-
 // Tests that different mock objects can be used in their respective
 // threads.  This should generate no Google Test failure.
 void TestConcurrentMockObjects(Dummy /* dummy */) {
   // Creates a mock and does some typical operations on it.
   MockFoo foo;
-  ON_CALL(foo, Bar(_))
-      .WillByDefault(Return(1));
-  ON_CALL(foo, Baz(_, _))
-      .WillByDefault(Return('b'));
-  ON_CALL(foo, Baz(_, "you"))
-      .WillByDefault(Return('a'));
-
-  EXPECT_CALL(foo, Bar(0))
-      .Times(AtMost(3));
+  ON_CALL(foo, Bar(_)).WillByDefault(Return(1));
+  ON_CALL(foo, Baz(_, _)).WillByDefault(Return('b'));
+  ON_CALL(foo, Baz(_, "you")).WillByDefault(Return('a'));
+
+  EXPECT_CALL(foo, Bar(0)).Times(AtMost(3));
   EXPECT_CALL(foo, Baz(_, _));
   EXPECT_CALL(foo, Baz("hi", "you"))
       .WillOnce(Return('z'))
@@ -119,22 +113,19 @@ void Helper1(Helper1Param param) {
 void TestConcurrentCallsOnSameObject(Dummy /* dummy */) {
   MockFoo foo;
 
-  ON_CALL(foo, Bar(_))
-      .WillByDefault(Return(1));
-  EXPECT_CALL(foo, Baz(_, "b"))
-      .Times(kRepeat)
-      .WillRepeatedly(Return('a'));
+  ON_CALL(foo, Bar(_)).WillByDefault(Return(1));
+  EXPECT_CALL(foo, Baz(_, "b")).Times(kRepeat).WillRepeatedly(Return('a'));
   EXPECT_CALL(foo, Baz(_, "c"));  // Expected to be unsatisfied.
 
   // This chunk of code should generate kRepeat failures about
   // excessive calls, and 2*kRepeat failures about unexpected calls.
   int count1 = 0;
-  const Helper1Param param = { &foo, &count1 };
+  const Helper1Param param = {&foo, &count1};
   ThreadWithParam<Helper1Param>* const t =
       new ThreadWithParam<Helper1Param>(Helper1, param, nullptr);
 
   int count2 = 0;
-  const Helper1Param param2 = { &foo, &count2 };
+  const Helper1Param param2 = {&foo, &count2};
   Helper1(param2);
   JoinAndDelete(t);
 
@@ -162,22 +153,18 @@ void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
   {
     InSequence dummy;
     EXPECT_CALL(foo, Bar(0));
-    EXPECT_CALL(foo, Bar(1))
-        .InSequence(s1, s2);
+    EXPECT_CALL(foo, Bar(1)).InSequence(s1, s2);
   }
 
   EXPECT_CALL(foo, Bar(2))
-      .Times(2*kRepeat)
+      .Times(2 * kRepeat)
       .InSequence(s1)
       .RetiresOnSaturation();
-  EXPECT_CALL(foo, Bar(3))
-      .Times(2*kRepeat)
-      .InSequence(s2);
+  EXPECT_CALL(foo, Bar(3)).Times(2 * kRepeat).InSequence(s2);
 
   {
     InSequence dummy;
-    EXPECT_CALL(foo, Bar(2))
-        .InSequence(s1, s2);
+    EXPECT_CALL(foo, Bar(2)).InSequence(s1, s2);
     EXPECT_CALL(foo, Bar(4));
   }
 
@@ -196,12 +183,12 @@ void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
 // Tests using Google Mock constructs in many threads concurrently.
 TEST(StressTest, CanUseGMockWithThreads) {
   void (*test_routines[])(Dummy dummy) = {
-    &TestConcurrentMockObjects,
-    &TestConcurrentCallsOnSameObject,
-    &TestPartiallyOrderedExpectationsWithThreads,
+      &TestConcurrentMockObjects,
+      &TestConcurrentCallsOnSameObject,
+      &TestPartiallyOrderedExpectationsWithThreads,
   };
 
-  const int kRoutines = sizeof(test_routines)/sizeof(test_routines[0]);
+  const int kRoutines = sizeof(test_routines) / sizeof(test_routines[0]);
   const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines;
   const int kTestThreads = kCopiesOfEachRoutine * kRoutines;
   ThreadWithParam<Dummy>* threads[kTestThreads] = {};
@@ -220,7 +207,7 @@ TEST(StressTest, CanUseGMockWithThreads) {
   // Ensures that the correct number of failures have been reported.
   const TestInfo* const info = UnitTest::GetInstance()->current_test_info();
   const TestResult& result = *info->result();
-  const int kExpectedFailures = (3*kRepeat + 1)*kCopiesOfEachRoutine;
+  const int kExpectedFailures = (3 * kRepeat + 1) * kCopiesOfEachRoutine;
   GTEST_CHECK_(kExpectedFailures == result.total_part_count())
       << "Expected " << kExpectedFailures << " failures, but got "
       << result.total_part_count();
@@ -229,7 +216,7 @@ TEST(StressTest, CanUseGMockWithThreads) {
 }  // namespace
 }  // namespace testing
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleMock(&argc, argv);
 
   const int exit_code = RUN_ALL_TESTS();  // Expected to fail.
diff --git a/googletest/googlemock/test/gmock_test.cc b/googletest/googlemock/test/gmock_test.cc
index e9840a337db87d13052f5f416bbc48a1845f1aa8..8f1bd5d03eb89b8149cf574a95d52cd0e25bac3d 100644
--- a/googletest/googlemock/test/gmock_test.cc
+++ b/googletest/googlemock/test/gmock_test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests code in gmock.cc.
@@ -35,13 +34,12 @@
 #include "gmock/gmock.h"
 
 #include <string>
+
 #include "gtest/gtest.h"
 #include "gtest/internal/custom/gtest.h"
 
 #if !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 
-using testing::GMOCK_FLAG(default_mock_behavior);
-using testing::GMOCK_FLAG(verbose);
 using testing::InitGoogleMock;
 
 // Verifies that calling InitGoogleMock() on argv results in new_argv,
@@ -49,7 +47,7 @@ using testing::InitGoogleMock;
 template <typename Char, int M, int N>
 void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
                         const ::std::string& expected_gmock_verbose) {
-  const ::std::string old_verbose = GMOCK_FLAG(verbose);
+  const ::std::string old_verbose = GMOCK_FLAG_GET(verbose);
 
   int argc = M - 1;
   InitGoogleMock(&argc, const_cast<Char**>(argv));
@@ -59,8 +57,8 @@ void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
     EXPECT_STREQ(new_argv[i], argv[i]);
   }
 
-  EXPECT_EQ(expected_gmock_verbose, GMOCK_FLAG(verbose).c_str());
-  GMOCK_FLAG(verbose) = old_verbose;  // Restores the gmock_verbose flag.
+  EXPECT_EQ(expected_gmock_verbose, GMOCK_FLAG_GET(verbose));
+  GMOCK_FLAG_SET(verbose, old_verbose);  // Restores the gmock_verbose flag.
 }
 
 TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
@@ -68,7 +66,7 @@ TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
 
   const char* new_argv[] = {nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
@@ -76,7 +74,7 @@ TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
 
   const char* new_argv[] = {"foo.exe", nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(InitGoogleMockTest, ParsesSingleFlag) {
@@ -88,16 +86,16 @@ TEST(InitGoogleMockTest, ParsesSingleFlag) {
 }
 
 TEST(InitGoogleMockTest, ParsesMultipleFlags) {
-  int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
+  int old_default_behavior = GMOCK_FLAG_GET(default_mock_behavior);
   const wchar_t* argv[] = {L"foo.exe", L"--gmock_verbose=info",
                            L"--gmock_default_mock_behavior=2", nullptr};
 
   const wchar_t* new_argv[] = {L"foo.exe", nullptr};
 
   TestInitGoogleMock(argv, new_argv, "info");
-  EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
+  EXPECT_EQ(2, GMOCK_FLAG_GET(default_mock_behavior));
   EXPECT_NE(2, old_default_behavior);
-  GMOCK_FLAG(default_mock_behavior) = old_default_behavior;
+  GMOCK_FLAG_SET(default_mock_behavior, old_default_behavior);
 }
 
 TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
@@ -105,7 +103,7 @@ TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
 
   const char* new_argv[] = {"foo.exe", "--non_gmock_flag=blah", nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
@@ -122,7 +120,7 @@ TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
 
   const wchar_t* new_argv[] = {nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
@@ -130,7 +128,7 @@ TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
 
   const wchar_t* new_argv[] = {L"foo.exe", nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
@@ -142,16 +140,16 @@ TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
 }
 
 TEST(WideInitGoogleMockTest, ParsesMultipleFlags) {
-  int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
+  int old_default_behavior = GMOCK_FLAG_GET(default_mock_behavior);
   const wchar_t* argv[] = {L"foo.exe", L"--gmock_verbose=info",
                            L"--gmock_default_mock_behavior=2", nullptr};
 
   const wchar_t* new_argv[] = {L"foo.exe", nullptr};
 
   TestInitGoogleMock(argv, new_argv, "info");
-  EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
+  EXPECT_EQ(2, GMOCK_FLAG_GET(default_mock_behavior));
   EXPECT_NE(2, old_default_behavior);
-  GMOCK_FLAG(default_mock_behavior) = old_default_behavior;
+  GMOCK_FLAG_SET(default_mock_behavior, old_default_behavior);
 }
 
 TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
@@ -159,7 +157,7 @@ TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
 
   const wchar_t* new_argv[] = {L"foo.exe", L"--non_gmock_flag=blah", nullptr};
 
-  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
+  TestInitGoogleMock(argv, new_argv, GMOCK_FLAG_GET(verbose));
 }
 
 TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
@@ -175,7 +173,7 @@ TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
 
 // Makes sure Google Mock flags can be accessed in code.
 TEST(FlagTest, IsAccessibleInCode) {
-  bool dummy = testing::GMOCK_FLAG(catch_leaked_mocks) &&
-      testing::GMOCK_FLAG(verbose) == "";
+  bool dummy =
+      GMOCK_FLAG_GET(catch_leaked_mocks) && GMOCK_FLAG_GET(verbose) == "";
   (void)dummy;  // Avoids the "unused local variable" warning.
 }
diff --git a/googletest/googlemock/test/gmock_test_utils.py b/googletest/googlemock/test/gmock_test_utils.py
index 7dc4e119d3c5b97c3815e6b0d2602770240cce1d..d7bc0974a7095b706041ba91f5f7d6e27fe89e62 100644
--- a/googletest/googlemock/test/gmock_test_utils.py
+++ b/googletest/googlemock/test/gmock_test_utils.py
@@ -30,21 +30,9 @@
 """Unit test utilities for Google C++ Mocking Framework."""
 
 import os
-import sys
-
-# Determines path to gtest_test_utils and imports it.
-SCRIPT_DIR = os.path.dirname(__file__) or '.'
-
-# isdir resolves symbolic links.
-gtest_tests_util_dir = os.path.join(SCRIPT_DIR, '../../googletest/test')
-if os.path.isdir(gtest_tests_util_dir):
-  GTEST_TESTS_UTIL_DIR = gtest_tests_util_dir
-else:
-  GTEST_TESTS_UTIL_DIR = os.path.join(SCRIPT_DIR, '../../googletest/test')
-sys.path.append(GTEST_TESTS_UTIL_DIR)
 
 # pylint: disable=C6204
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 
 def GetSourceDir():
diff --git a/googletest/googletest/CMakeLists.txt b/googletest/googletest/CMakeLists.txt
index 15b8f0c37bbd9c6173d3ef7fea097521281c44fe..95bfa4420486a541a8240e2b28a2e03386df8c75 100644
--- a/googletest/googletest/CMakeLists.txt
+++ b/googletest/googletest/CMakeLists.txt
@@ -125,19 +125,39 @@ include_directories(${gtest_build_include_dirs})
 # aggressive about warnings.
 cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
 set_target_properties(gtest PROPERTIES VERSION ${GOOGLETEST_VERSION})
+if(GTEST_HAS_ABSL)
+  target_compile_definitions(gtest PUBLIC GTEST_HAS_ABSL=1)
+  target_link_libraries(gtest PUBLIC
+    absl::failure_signal_handler
+    absl::stacktrace
+    absl::symbolize
+    absl::flags_parse
+    absl::flags_reflection
+    absl::flags_usage
+    absl::strings
+    absl::any
+    absl::optional
+    absl::variant
+    re2::re2
+  )
+endif()
 cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
 set_target_properties(gtest_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
 # If the CMake version supports it, attach header directory information
 # to the targets for when we are part of a parent build (ie being pulled
 # in via add_subdirectory() rather than being a standalone build).
 if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  string(REPLACE ";" "$<SEMICOLON>" dirs "${gtest_build_include_dirs}")
   target_include_directories(gtest SYSTEM INTERFACE
-    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    "$<BUILD_INTERFACE:${dirs}>"
     "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
   target_include_directories(gtest_main SYSTEM INTERFACE
-    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    "$<BUILD_INTERFACE:${dirs}>"
     "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
 endif()
+if(CMAKE_SYSTEM_NAME MATCHES "QNX")
+  target_link_libraries(gtest PUBLIC regex)
+endif()
 target_link_libraries(gtest_main PUBLIC gtest)
 
 ########################################################################
diff --git a/googletest/googletest/README.md b/googletest/googletest/README.md
index 1f8b349ae70d7235c62e23fcdfa15d7be3451765..9bdbcec04c985e9b5b28858c08255b3020b40ae4 100644
--- a/googletest/googletest/README.md
+++ b/googletest/googletest/README.md
@@ -9,7 +9,7 @@ depends on which build system you use, and is usually straightforward.
 ### Build with CMake
 
 GoogleTest comes with a CMake build script
-([CMakeLists.txt](https://github.com/google/googletest/blob/master/CMakeLists.txt))
+([CMakeLists.txt](https://github.com/google/googletest/blob/main/CMakeLists.txt))
 that can be used on a wide range of platforms ("C" stands for cross-platform.).
 If you don't have CMake installed already, you can download it for free from
 <http://www.cmake.org/>.
@@ -25,7 +25,7 @@ When building GoogleTest as a standalone project, the typical workflow starts
 with
 
 ```
-git clone https://github.com/google/googletest.git -b release-1.10.0
+git clone https://github.com/google/googletest.git -b release-1.12.1
 cd googletest        # Main directory of the cloned repository.
 mkdir build          # Create a directory to hold the build output.
 cd build
@@ -94,7 +94,7 @@ include(FetchContent)
 FetchContent_Declare(
   googletest
   # Specify the commit you depend on and update it regularly.
-  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
+  URL https://github.com/google/googletest/archive/5376968f6948923e2411081fd9372e71a59d8e77.zip
 )
 # For Windows: Prevent overriding the parent project's compiler/linker settings
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
@@ -140,7 +140,7 @@ command line. Generally, these macros are named like `GTEST_XYZ` and you define
 them to either 1 or 0 to enable or disable a certain feature.
 
 We list the most frequently used macros below. For a complete list, see file
-[include/gtest/internal/gtest-port.h](https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-port.h).
+[include/gtest/internal/gtest-port.h](https://github.com/google/googletest/blob/main/googletest/include/gtest/internal/gtest-port.h).
 
 ### Multi-threaded Tests
 
@@ -186,9 +186,9 @@ to the compiler flags.
 Note: while the above steps aren't technically necessary today when using some
 compilers (e.g. GCC), they may become necessary in the future, if we decide to
 improve the speed of loading the library (see
-<http://gcc.gnu.org/wiki/Visibility> for details). Therefore you are recommended
-to always add the above flags when using GoogleTest as a shared library.
-Otherwise a future release of GoogleTest may break your build script.
+<https://gcc.gnu.org/wiki/Visibility> for details). Therefore you are
+recommended to always add the above flags when using GoogleTest as a shared
+library. Otherwise a future release of GoogleTest may break your build script.
 
 ### Avoiding Macro Name Clashes
 
@@ -203,7 +203,9 @@ add
     -DGTEST_DONT_DEFINE_FOO=1
 
 to the compiler flags to tell GoogleTest to change the macro's name from `FOO`
-to `GTEST_FOO`. Currently `FOO` can be `FAIL`, `SUCCEED`, or `TEST`. For
+to `GTEST_FOO`. Currently `FOO` can be `ASSERT_EQ`, `ASSERT_FALSE`, `ASSERT_GE`,
+`ASSERT_GT`, `ASSERT_LE`, `ASSERT_LT`, `ASSERT_NE`, `ASSERT_TRUE`,
+`EXPECT_FALSE`, `EXPECT_TRUE`, `FAIL`, `SUCCEED`, `TEST`, or `TEST_F`. For
 example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write
 
     GTEST_TEST(SomeTest, DoesThis) { ... }
diff --git a/googletest/googletest/cmake/internal_utils.cmake b/googletest/googletest/cmake/internal_utils.cmake
index d059cd9ab1869300800d18c70ad6d11ee4959b88..41405587fdd5938adfc5978bccd852766de11b4c 100644
--- a/googletest/googletest/cmake/internal_utils.cmake
+++ b/googletest/googletest/cmake/internal_utils.cmake
@@ -21,8 +21,9 @@ endif (POLICY CMP0054)
 # This must be a macro(), as inside a function string() can only
 # update variables in the function scope.
 macro(fix_default_compiler_settings_)
-  if (MSVC)
-    # For MSVC, CMake sets certain flags to defaults we want to override.
+  if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC|Clang")
+    # For MSVC and Clang, CMake sets certain flags to defaults we want to
+    # override.
     # This replacement code is taken from sample in the CMake Wiki at
     # https://gitlab.kitware.com/cmake/community/wikis/FAQ#dynamic-replace.
     foreach (flag_var
@@ -39,6 +40,10 @@ macro(fix_default_compiler_settings_)
         # on CRT DLLs being available. CMake always defaults to using shared
         # CRT libraries, so we override that default here.
         string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
+
+        # When using Ninja with Clang, static builds pass -D_DLL on Windows.
+        # This is incorrect and should not happen, so we fix that here.
+        string(REPLACE "-D_DLL" "" ${flag_var} "${${flag_var}}")
       endif()
 
       # We prefer more strict warning checking for building Google Test.
@@ -82,15 +87,17 @@ macro(config_compiler_and_linker)
     # http://stackoverflow.com/questions/3232669 explains the issue.
     set(cxx_base_flags "${cxx_base_flags} -wd4702")
     # Ensure MSVC treats source files as UTF-8 encoded.
-    set(cxx_base_flags "${cxx_base_flags} -utf-8")
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+      set(cxx_base_flags "${cxx_base_flags} -utf-8")
+    endif()
   elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set(cxx_base_flags "-Wall -Werror -Wconversion")
+    set(cxx_base_flags "-Wall -Wshadow -Wconversion")
     set(cxx_exception_flags "-fexceptions")
     set(cxx_no_exception_flags "-fno-exceptions")
     set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wredundant-decls")
     set(cxx_no_rtti_flags "-fno-rtti")
   elseif (CMAKE_COMPILER_IS_GNUCXX)
-    set(cxx_base_flags "-Wall -Werror")
+    set(cxx_base_flags "-Wall -Wshadow")
     if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0)
       set(cxx_base_flags "${cxx_base_flags} -Wno-error=dangling-else")
     endif()
@@ -154,17 +161,14 @@ function(cxx_library_with_type name type cxx_flags)
   set_target_properties(${name}
     PROPERTIES
     COMPILE_FLAGS "${cxx_flags}")
-  # Generate debug library name with a postfix.
-  set_target_properties(${name}
-    PROPERTIES
-    DEBUG_POSTFIX "d")
   # Set the output directory for build artifacts
   set_target_properties(${name}
     PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
     LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
     ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
-    PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+    PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
+    COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
   # make PDBs match library name
   get_target_property(pdb_debug_postfix ${name} DEBUG_POSTFIX)
   set_target_properties(${name}
@@ -193,7 +197,7 @@ function(cxx_library_with_type name type cxx_flags)
   endif()
 
   if (NOT "${CMAKE_VERSION}" VERSION_LESS "3.8")
-    target_compile_features(${name} PUBLIC cxx_std_11)
+    target_compile_features(${name} PUBLIC cxx_std_14)
   endif()
 endfunction()
 
@@ -246,6 +250,12 @@ function(cxx_executable name dir libs)
     ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
 endfunction()
 
+# CMP0094 policy enables finding a Python executable in the LOCATION order, as
+# specified by the PATH environment variable.
+if (POLICY CMP0094)
+  cmake_policy(SET CMP0094 NEW)
+endif()
+
 # Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
 if ("${CMAKE_VERSION}" VERSION_LESS "3.12.0")
   find_package(PythonInterp)
@@ -304,6 +314,8 @@ function(py_test name)
         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
           --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE} ${ARGN})
     endif()
+    # Make the Python import path consistent between Bazel and CMake.
+    set_tests_properties(${name} PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_SOURCE_DIR})
   endif(PYTHONINTERP_FOUND)
 endfunction()
 
diff --git a/googletest/googletest/include/gtest/gtest-assertion-result.h b/googletest/googletest/include/gtest/gtest-assertion-result.h
new file mode 100644
index 0000000000000000000000000000000000000000..addbb59c6413c2dec2ccee11b20a875343c2a02d
--- /dev/null
+++ b/googletest/googletest/include/gtest/gtest-assertion-result.h
@@ -0,0 +1,237 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements the AssertionResult type.
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
+
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-port.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251                                   \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
+// This warning is not emitted in Visual Studio 2017.
+// This warning is off by default starting in Visual Studio 2019 but can be
+// enabled with command-line options.
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+#endif
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename std::enable_if<
+          !std::is_convertible<T, AssertionResult>::value>::type*
+      /*enabler*/
+      = nullptr)
+      : success_(success) {}
+
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true if and only if the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != nullptr ? message_->c_str() : "";
+  }
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T>
+  AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  std::unique_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
diff --git a/googletest/googletest/include/gtest/gtest-death-test.h b/googletest/googletest/include/gtest/gtest-death-test.h
index 9b4d4d1337481ee11e1c484b8a38ddad9a2259e7..84e5a5bbd372df80f268165a601bc995e907641d 100644
--- a/googletest/googletest/include/gtest/gtest-death-test.h
+++ b/googletest/googletest/include/gtest/gtest-death-test.h
@@ -27,21 +27,21 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines the public API for death tests.  It is
 // #included by gtest.h so a user doesn't need to include this
 // directly.
-// GOOGLETEST_CM0001 DO NOT DELETE
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
 
 #include "gtest/internal/gtest-death-test-internal.h"
 
-namespace testing {
-
 // This flag controls the style of death tests.  Valid values are "threadsafe",
 // meaning that the death test child process will re-execute the test binary
 // from the start, running only a single death test, or "fast",
@@ -49,6 +49,8 @@ namespace testing {
 // after forking.
 GTEST_DECLARE_string_(death_test_style);
 
+namespace testing {
+
 #if GTEST_HAS_DEATH_TEST
 
 namespace internal {
@@ -103,7 +105,6 @@ GTEST_API_ bool InDeathTestChild();
 //
 // On the regular expressions used in death tests:
 //
-//   GOOGLETEST_CM0005 DO NOT DELETE
 //   On POSIX-compliant systems (*nix), we use the <regex.h> library,
 //   which uses the POSIX extended regex syntax.
 //
@@ -169,24 +170,24 @@ GTEST_API_ bool InDeathTestChild();
 // Asserts that a given `statement` causes the program to exit, with an
 // integer exit status that satisfies `predicate`, and emitting error output
 // that matches `matcher`.
-# define ASSERT_EXIT(statement, predicate, matcher) \
-    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_)
+#define ASSERT_EXIT(statement, predicate, matcher) \
+  GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_)
 
 // Like `ASSERT_EXIT`, but continues on to successive tests in the
 // test suite, if any:
-# define EXPECT_EXIT(statement, predicate, matcher) \
-    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_EXIT(statement, predicate, matcher) \
+  GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_)
 
 // Asserts that a given `statement` causes the program to exit, either by
 // explicitly exiting with a nonzero exit code or being killed by a
 // signal, and emitting error output that matches `matcher`.
-# define ASSERT_DEATH(statement, matcher) \
-    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+#define ASSERT_DEATH(statement, matcher) \
+  ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
 
 // Like `ASSERT_DEATH`, but continues on to successive tests in the
 // test suite, if any:
-# define EXPECT_DEATH(statement, matcher) \
-    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+#define EXPECT_DEATH(statement, matcher) \
+  EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
 
 // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
 
@@ -197,22 +198,23 @@ class GTEST_API_ ExitedWithCode {
   ExitedWithCode(const ExitedWithCode&) = default;
   void operator=(const ExitedWithCode& other) = delete;
   bool operator()(int exit_status) const;
+
  private:
   const int exit_code_;
 };
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 // Tests that an exit code describes an exit due to termination by a
 // given signal.
-// GOOGLETEST_CM0006 DO NOT DELETE
 class GTEST_API_ KilledBySignal {
  public:
   explicit KilledBySignal(int signum);
   bool operator()(int exit_status) const;
+
  private:
   const int signum_;
 };
-# endif  // !GTEST_OS_WINDOWS
+#endif  // !GTEST_OS_WINDOWS
 
 // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
 // The death testing framework causes this to have interesting semantics,
@@ -257,23 +259,21 @@ class GTEST_API_ KilledBySignal {
 //   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
 // }, "death");
 //
-# ifdef NDEBUG
+#ifdef NDEBUG
 
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
+#define EXPECT_DEBUG_DEATH(statement, regex) \
   GTEST_EXECUTE_STATEMENT_(statement, regex)
 
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
+#define ASSERT_DEBUG_DEATH(statement, regex) \
   GTEST_EXECUTE_STATEMENT_(statement, regex)
 
-# else
+#else
 
-#  define EXPECT_DEBUG_DEATH(statement, regex) \
-  EXPECT_DEATH(statement, regex)
+#define EXPECT_DEBUG_DEATH(statement, regex) EXPECT_DEATH(statement, regex)
 
-#  define ASSERT_DEBUG_DEATH(statement, regex) \
-  ASSERT_DEATH(statement, regex)
+#define ASSERT_DEBUG_DEATH(statement, regex) ASSERT_DEATH(statement, regex)
 
-# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // NDEBUG for EXPECT_DEBUG_DEATH
 #endif  // GTEST_HAS_DEATH_TEST
 
 // This macro is used for implementing macros such as
@@ -311,18 +311,17 @@ class GTEST_API_ KilledBySignal {
 //  statement unconditionally returns or throws. The Message constructor at
 //  the end allows the syntax of streaming additional messages into the
 //  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::AlwaysTrue()) { \
-      GTEST_LOG_(WARNING) \
-          << "Death tests are not supported on this platform.\n" \
-          << "Statement '" #statement "' cannot be verified."; \
-    } else if (::testing::internal::AlwaysFalse()) { \
-      ::testing::internal::RE::PartialMatch(".*", (regex)); \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-      terminator; \
-    } else \
-      ::testing::Message()
+#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator)             \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::internal::AlwaysTrue()) {                                     \
+    GTEST_LOG_(WARNING) << "Death tests are not supported on this platform.\n" \
+                        << "Statement '" #statement "' cannot be verified.";   \
+  } else if (::testing::internal::AlwaysFalse()) {                             \
+    ::testing::internal::RE::PartialMatch(".*", (regex));                      \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);                 \
+    terminator;                                                                \
+  } else                                                                       \
+    ::testing::Message()
 
 // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
 // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
@@ -330,15 +329,15 @@ class GTEST_API_ KilledBySignal {
 // useful when you are combining death test assertions with normal test
 // assertions in one test.
 #if GTEST_HAS_DEATH_TEST
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    EXPECT_DEATH(statement, regex)
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    ASSERT_DEATH(statement, regex)
+#define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+#define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+  ASSERT_DEATH(statement, regex)
 #else
-# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
-# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
+#define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+  GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
+#define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+  GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
 #endif
 
 }  // namespace testing
diff --git a/googletest/googletest/include/gtest/gtest-matchers.h b/googletest/googletest/include/gtest/gtest-matchers.h
index 9fa34a05ba418ee8450d7d57b3ca88757e621492..4a60b0d0b8da61b9581ca98c01def55848ecfed9 100644
--- a/googletest/googletest/include/gtest/gtest-matchers.h
+++ b/googletest/googletest/include/gtest/gtest-matchers.h
@@ -32,6 +32,10 @@
 // This file implements just enough of the matcher interface to allow
 // EXPECT_DEATH and friends to accept a matcher argument.
 
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
 
@@ -98,11 +102,11 @@ class MatchResultListener {
  private:
   ::std::ostream* const stream_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
+  MatchResultListener(const MatchResultListener&) = delete;
+  MatchResultListener& operator=(const MatchResultListener&) = delete;
 };
 
-inline MatchResultListener::~MatchResultListener() {
-}
+inline MatchResultListener::~MatchResultListener() {}
 
 // An instance of a subclass of this knows how to describe itself as a
 // matcher.
@@ -176,27 +180,39 @@ namespace internal {
 
 struct AnyEq {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a == b; }
+  bool operator()(const A& a, const B& b) const {
+    return a == b;
+  }
 };
 struct AnyNe {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a != b; }
+  bool operator()(const A& a, const B& b) const {
+    return a != b;
+  }
 };
 struct AnyLt {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a < b; }
+  bool operator()(const A& a, const B& b) const {
+    return a < b;
+  }
 };
 struct AnyGt {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a > b; }
+  bool operator()(const A& a, const B& b) const {
+    return a > b;
+  }
 };
 struct AnyLe {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a <= b; }
+  bool operator()(const A& a, const B& b) const {
+    return a <= b;
+  }
 };
 struct AnyGe {
   template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a >= b; }
+  bool operator()(const A& a, const B& b) const {
+    return a >= b;
+  }
 };
 
 // A match result listener that ignores the explanation.
@@ -205,7 +221,8 @@ class DummyMatchResultListener : public MatchResultListener {
   DummyMatchResultListener() : MatchResultListener(nullptr) {}
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
+  DummyMatchResultListener(const DummyMatchResultListener&) = delete;
+  DummyMatchResultListener& operator=(const DummyMatchResultListener&) = delete;
 };
 
 // A match result listener that forwards the explanation to a given
@@ -217,7 +234,9 @@ class StreamMatchResultListener : public MatchResultListener {
       : MatchResultListener(os) {}
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
+  StreamMatchResultListener(const StreamMatchResultListener&) = delete;
+  StreamMatchResultListener& operator=(const StreamMatchResultListener&) =
+      delete;
 };
 
 struct SharedPayloadBase {
@@ -284,17 +303,18 @@ class MatcherBase : private MatcherDescriberInterface {
   }
 
  protected:
-  MatcherBase() : vtable_(nullptr) {}
+  MatcherBase() : vtable_(nullptr), buffer_() {}
 
   // Constructs a matcher from its implementation.
   template <typename U>
-  explicit MatcherBase(const MatcherInterface<U>* impl) {
+  explicit MatcherBase(const MatcherInterface<U>* impl)
+      : vtable_(nullptr), buffer_() {
     Init(impl);
   }
 
   template <typename M, typename = typename std::remove_reference<
                             M>::type::is_gtest_matcher>
-  MatcherBase(M&& m) {  // NOLINT
+  MatcherBase(M&& m) : vtable_(nullptr), buffer_() {  // NOLINT
     Init(std::forward<M>(m));
   }
 
@@ -420,8 +440,8 @@ class MatcherBase : private MatcherDescriberInterface {
     static const M& Get(const MatcherBase& m) {
       // When inlined along with Init, need to be explicit to avoid violating
       // strict aliasing rules.
-      const M *ptr = static_cast<const M*>(
-          static_cast<const void*>(&m.buffer_));
+      const M* ptr =
+          static_cast<const M*>(static_cast<const void*>(&m.buffer_));
       return *ptr;
     }
     static void Init(MatcherBase& m, M impl) {
@@ -741,7 +761,7 @@ template <typename Rhs>
 class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
  public:
   explicit EqMatcher(const Rhs& rhs)
-      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) {}
   static const char* Desc() { return "is equal to"; }
   static const char* NegatedDesc() { return "isn't equal to"; }
 };
@@ -749,7 +769,7 @@ template <typename Rhs>
 class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
  public:
   explicit NeMatcher(const Rhs& rhs)
-      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) {}
   static const char* Desc() { return "isn't equal to"; }
   static const char* NegatedDesc() { return "is equal to"; }
 };
@@ -757,7 +777,7 @@ template <typename Rhs>
 class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
  public:
   explicit LtMatcher(const Rhs& rhs)
-      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) {}
   static const char* Desc() { return "is <"; }
   static const char* NegatedDesc() { return "isn't <"; }
 };
@@ -765,7 +785,7 @@ template <typename Rhs>
 class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
  public:
   explicit GtMatcher(const Rhs& rhs)
-      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) {}
   static const char* Desc() { return "is >"; }
   static const char* NegatedDesc() { return "isn't >"; }
 };
@@ -773,7 +793,7 @@ template <typename Rhs>
 class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
  public:
   explicit LeMatcher(const Rhs& rhs)
-      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) {}
   static const char* Desc() { return "is <="; }
   static const char* NegatedDesc() { return "isn't <="; }
 };
@@ -781,7 +801,7 @@ template <typename Rhs>
 class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
  public:
   explicit GeMatcher(const Rhs& rhs)
-      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) {}
   static const char* Desc() { return "is >="; }
   static const char* NegatedDesc() { return "isn't >="; }
 };
@@ -822,7 +842,7 @@ class MatchesRegexMatcher {
   template <class MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
-    const std::string& s2(s);
+    const std::string s2(s);
     return full_match_ ? RE::FullMatch(s2, *regex_)
                        : RE::PartialMatch(s2, *regex_);
   }
@@ -872,12 +892,16 @@ PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
 // Note: if the parameter of Eq() were declared as const T&, Eq("foo")
 // wouldn't compile.
 template <typename T>
-inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
+inline internal::EqMatcher<T> Eq(T x) {
+  return internal::EqMatcher<T>(x);
+}
 
 // Constructs a Matcher<T> from a 'value' of type T.  The constructed
 // matcher matches any value that's equal to 'value'.
 template <typename T>
-Matcher<T>::Matcher(T value) { *this = Eq(value); }
+Matcher<T>::Matcher(T value) {
+  *this = Eq(value);
+}
 
 // Creates a monomorphic matcher that matches anything with type Lhs
 // and equal to rhs.  A user may need to use this instead of Eq(...)
@@ -892,7 +916,9 @@ Matcher<T>::Matcher(T value) { *this = Eq(value); }
 // can always write Matcher<T>(Lt(5)) to be explicit about the type,
 // for example.
 template <typename Lhs, typename Rhs>
-inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) {
+  return Eq(rhs);
+}
 
 // Creates a polymorphic matcher that matches anything >= x.
 template <typename Rhs>
diff --git a/googletest/googletest/include/gtest/gtest-message.h b/googletest/googletest/include/gtest/gtest-message.h
index becfd49fcba9c5ab986e4b4396bc8143a3c587a1..4d4b152b1d8b708cd9f39385039432a5f3502010 100644
--- a/googletest/googletest/include/gtest/gtest-message.h
+++ b/googletest/googletest/include/gtest/gtest-message.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines the Message class.
@@ -42,14 +41,18 @@
 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
 // program!
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
 
 #include <limits>
 #include <memory>
+#include <ostream>
 #include <sstream>
+#include <string>
 
 #include "gtest/internal/gtest-port.h"
 
@@ -110,8 +113,8 @@ class GTEST_API_ Message {
 
   // Streams a non-pointer value to this object.
   template <typename T>
-  inline Message& operator <<(const T& val) {
-    // Some libraries overload << for STL containers.  These
+  inline Message& operator<<(const T& val) {
+        // Some libraries overload << for STL containers.  These
     // overloads are defined in the global namespace instead of ::std.
     //
     // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
@@ -125,7 +128,7 @@ class GTEST_API_ Message {
     // from the global namespace.  With this using declaration,
     // overloads of << defined in the global namespace and those
     // visible via Koenig lookup are both exposed in this function.
-    using ::operator <<;
+    using ::operator<<;
     *ss_ << val;
     return *this;
   }
@@ -144,7 +147,7 @@ class GTEST_API_ Message {
   // ensure consistent result across compilers, we always treat NULL
   // as "(null)".
   template <typename T>
-  inline Message& operator <<(T* const& pointer) {  // NOLINT
+  inline Message& operator<<(T* const& pointer) {  // NOLINT
     if (pointer == nullptr) {
       *ss_ << "(null)";
     } else {
@@ -159,25 +162,23 @@ class GTEST_API_ Message {
   // templatized version above.  Without this definition, streaming
   // endl or other basic IO manipulators to Message will confuse the
   // compiler.
-  Message& operator <<(BasicNarrowIoManip val) {
+  Message& operator<<(BasicNarrowIoManip val) {
     *ss_ << val;
     return *this;
   }
 
   // Instead of 1/0, we want to see true/false for bool values.
-  Message& operator <<(bool b) {
-    return *this << (b ? "true" : "false");
-  }
+  Message& operator<<(bool b) { return *this << (b ? "true" : "false"); }
 
   // These two overloads allow streaming a wide C string to a Message
   // using the UTF-8 encoding.
-  Message& operator <<(const wchar_t* wide_c_str);
-  Message& operator <<(wchar_t* wide_c_str);
+  Message& operator<<(const wchar_t* wide_c_str);
+  Message& operator<<(wchar_t* wide_c_str);
 
 #if GTEST_HAS_STD_WSTRING
   // Converts the given wide string to a narrow string using the UTF-8
   // encoding, and streams the result to this Message object.
-  Message& operator <<(const ::std::wstring& wstr);
+  Message& operator<<(const ::std::wstring& wstr);
 #endif  // GTEST_HAS_STD_WSTRING
 
   // Gets the text streamed to this object so far as an std::string.
@@ -196,7 +197,7 @@ class GTEST_API_ Message {
 };
 
 // Streams a Message to an ostream.
-inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+inline std::ostream& operator<<(std::ostream& os, const Message& sb) {
   return os << sb.GetString();
 }
 
diff --git a/googletest/googletest/include/gtest/gtest-param-test.h b/googletest/googletest/include/gtest/gtest-param-test.h
index 804e702817b03b90a3e77fd8bdc8a037e72f5e7d..1adb9a725203ed86d3a9708fdd9ce8547e549766 100644
--- a/googletest/googletest/include/gtest/gtest-param-test.h
+++ b/googletest/googletest/include/gtest/gtest-param-test.h
@@ -26,11 +26,14 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // Macros and functions for implementing parameterized tests
 // in Google C++ Testing and Mocking Framework (Google Test)
-//
-// GOOGLETEST_CM0001 DO NOT DELETE
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
+
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
 
@@ -353,9 +356,7 @@ internal::ValueArray<T...> Values(T... v) {
 // }
 // INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
 //
-inline internal::ParamGenerator<bool> Bool() {
-  return Values(false, true);
-}
+inline internal::ParamGenerator<bool> Bool() { return Values(false, true); }
 
 // Combine() allows the user to combine two or more sequences to produce
 // values of a Cartesian product of those sequences' elements.
@@ -406,9 +407,49 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
   return internal::CartesianProductHolder<Generator...>(g...);
 }
 
+// ConvertGenerator() wraps a parameter generator in order to cast each produced
+// value through a known type before supplying it to the test suite
+//
+// Synopsis:
+// ConvertGenerator<T>(gen)
+//   - returns a generator producing the same elements as generated by gen, but
+//     each element is static_cast to type T before being returned
+//
+// It is useful when using the Combine() function to get the generated
+// parameters in a custom type instead of std::tuple
+//
+// Example:
+//
+// This will instantiate tests in test suite AnimalTest each one with
+// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
+// tuple("dog", BLACK), and tuple("dog", WHITE):
+//
+// enum Color { BLACK, GRAY, WHITE };
+// struct ParamType {
+//   using TupleT = std::tuple<const char*, Color>;
+//   std::string animal;
+//   Color color;
+//   ParamType(TupleT t) : animal(std::get<0>(t)), color(std::get<1>(t)) {}
+// };
+// class AnimalTest
+//     : public testing::TestWithParam<ParamType> {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
+//                          ConvertGenerator<ParamType::TupleT>(
+//                              Combine(Values("cat", "dog"),
+//                                      Values(BLACK, WHITE))));
+//
+template <typename T>
+internal::ParamConverterGenerator<T> ConvertGenerator(
+    internal::ParamGenerator<T> gen) {
+  return internal::ParamConverterGenerator<T>(gen);
+}
+
 #define TEST_P(test_suite_name, test_name)                                     \
   class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
-      : public test_suite_name {                                               \
+      : public test_suite_name, private ::testing::internal::GTestNonCopyable {\
    public:                                                                     \
     GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
     void TestBody() override;                                                  \
@@ -428,8 +469,6 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
       return 0;                                                                \
     }                                                                          \
     static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
-                                                           test_name));        \
   };                                                                           \
   int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                              test_name)::gtest_registering_dummy_ =            \
@@ -453,43 +492,42 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
 #define GTEST_GET_FIRST_(first, ...) first
 #define GTEST_GET_SECOND_(first, second, ...) second
 
-#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
-  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
-      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
-    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
-  }                                                                           \
-  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
-      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
-    if (::testing::internal::AlwaysFalse()) {                                 \
-      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
-          __VA_ARGS__,                                                        \
-          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
-          DUMMY_PARAM_)));                                                    \
-      auto t = std::make_tuple(__VA_ARGS__);                                  \
-      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
-                    "Too Many Args!");                                        \
-    }                                                                         \
-    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
-        __VA_ARGS__,                                                          \
-        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
-        DUMMY_PARAM_))))(info);                                               \
-  }                                                                           \
-  static int gtest_##prefix##test_suite_name##_dummy_                         \
-      GTEST_ATTRIBUTE_UNUSED_ =                                               \
-          ::testing::UnitTest::GetInstance()                                  \
-              ->parameterized_test_registry()                                 \
-              .GetTestSuitePatternHolder<test_suite_name>(                    \
-                  GTEST_STRINGIFY_(test_suite_name),                          \
-                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
-              ->AddTestSuiteInstantiation(                                    \
-                  GTEST_STRINGIFY_(prefix),                                   \
-                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
-                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
+#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)               \
+  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>     \
+      gtest_##prefix##test_suite_name##_EvalGenerator_() {                   \
+    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));       \
+  }                                                                          \
+  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(  \
+      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {    \
+    if (::testing::internal::AlwaysFalse()) {                                \
+      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(     \
+          __VA_ARGS__,                                                       \
+          ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \
+          DUMMY_PARAM_)));                                                   \
+      auto t = std::make_tuple(__VA_ARGS__);                                 \
+      static_assert(std::tuple_size<decltype(t)>::value <= 2,                \
+                    "Too Many Args!");                                       \
+    }                                                                        \
+    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                \
+        __VA_ARGS__,                                                         \
+        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,   \
+        DUMMY_PARAM_))))(info);                                              \
+  }                                                                          \
+  static int gtest_##prefix##test_suite_name##_dummy_                        \
+      GTEST_ATTRIBUTE_UNUSED_ =                                              \
+          ::testing::UnitTest::GetInstance()                                 \
+              ->parameterized_test_registry()                                \
+              .GetTestSuitePatternHolder<test_suite_name>(                   \
+                  GTEST_STRINGIFY_(test_suite_name),                         \
+                  ::testing::internal::CodeLocation(__FILE__, __LINE__))     \
+              ->AddTestSuiteInstantiation(                                   \
+                  GTEST_STRINGIFY_(prefix),                                  \
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,         \
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,      \
                   __FILE__, __LINE__)
 
-
 // Allow Marking a Parameterized test class as not needing to be instantiated.
-#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
+#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                  \
   namespace gtest_do_not_use_outside_namespace_scope {}                   \
   static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
       GTEST_STRINGIFY_(T))
diff --git a/googletest/googletest/include/gtest/gtest-printers.h b/googletest/googletest/include/gtest/gtest-printers.h
index 076c9de1f41ea8e12c3c06846d3b9ae9f9b7e95d..0055e37ffa7c96edeb856222462a2d3465682ae0 100644
--- a/googletest/googletest/include/gtest/gtest-printers.h
+++ b/googletest/googletest/include/gtest/gtest-printers.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Test - The Google C++ Testing and Mocking Framework
 //
 // This file implements a universal value printer that can print a
@@ -95,7 +94,9 @@
 // being defined as many user-defined container types don't have
 // value_type.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
@@ -107,6 +108,7 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
+#include <typeinfo>
 #include <utility>
 #include <vector>
 
@@ -257,12 +259,10 @@ struct ConvertibleToStringViewPrinter {
 #endif
 };
 
-
 // Prints the given number of bytes in the given object to the given
 // ostream.
 GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
-                                     size_t count,
-                                     ::std::ostream* os);
+                                     size_t count, ::std::ostream* os);
 struct RawBytesPrinter {
   // SFINAE on `sizeof` to make sure we have a complete type.
   template <typename T, size_t = sizeof(T)>
@@ -360,7 +360,7 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
 #endif
@@ -375,17 +375,17 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
 // to point to a NUL-terminated string, and thus can print it as a string.
 
 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
-  template <>                                                           \
-  class FormatForComparison<CharType*, OtherStringType> {               \
-   public:                                                              \
-    static ::std::string Format(CharType* value) {                      \
-      return ::testing::PrintToString(value);                           \
-    }                                                                   \
+  template <>                                                            \
+  class FormatForComparison<CharType*, OtherStringType> {                \
+   public:                                                               \
+    static ::std::string Format(CharType* value) {                       \
+      return ::testing::PrintToString(value);                            \
+    }                                                                    \
   }
 
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
 #endif
@@ -410,8 +410,8 @@ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 template <typename T1, typename T2>
-std::string FormatForComparisonFailureMessage(
-    const T1& value, const T2& /* other_operand */) {
+std::string FormatForComparisonFailureMessage(const T1& value,
+                                              const T2& /* other_operand */) {
   return FormatForComparison<T1, T2>::Format(value);
 }
 
@@ -479,6 +479,87 @@ inline void PrintTo(char8_t c, ::std::ostream* os) {
 }
 #endif
 
+// gcc/clang __{u,}int128_t
+#if defined(__SIZEOF_INT128__)
+GTEST_API_ void PrintTo(__uint128_t v, ::std::ostream* os);
+GTEST_API_ void PrintTo(__int128_t v, ::std::ostream* os);
+#endif  // __SIZEOF_INT128__
+
+// The default resolution used to print floating-point values uses only
+// 6 digits, which can be confusing if a test compares two values whose
+// difference lies in the 7th digit.  So we'd like to print out numbers
+// in full precision.
+// However if the value is something simple like 1.1, full will print a
+// long string like 1.100000001 due to floating-point numbers not using
+// a base of 10.  This routiune returns an appropriate resolution for a
+// given floating-point number, that is, 6 if it will be accurate, or a
+// max_digits10 value (full precision) if it won't,  for values between
+// 0.0001 and one million.
+// It does this by computing what those digits would be (by multiplying
+// by an appropriate power of 10), then dividing by that power again to
+// see if gets the original value back.
+// A similar algorithm applies for values larger than one million; note
+// that for those values, we must divide to get a six-digit number, and
+// then multiply to possibly get the original value again.
+template <typename FloatType>
+int AppropriateResolution(FloatType val) {
+  int full = std::numeric_limits<FloatType>::max_digits10;
+  if (val < 0) val = -val;
+
+  if (val < 1000000) {
+    FloatType mulfor6 = 1e10;
+    if (val >= 100000.0) {  // 100,000 to 999,999
+      mulfor6 = 1.0;
+    } else if (val >= 10000.0) {
+      mulfor6 = 1e1;
+    } else if (val >= 1000.0) {
+      mulfor6 = 1e2;
+    } else if (val >= 100.0) {
+      mulfor6 = 1e3;
+    } else if (val >= 10.0) {
+      mulfor6 = 1e4;
+    } else if (val >= 1.0) {
+      mulfor6 = 1e5;
+    } else if (val >= 0.1) {
+      mulfor6 = 1e6;
+    } else if (val >= 0.01) {
+      mulfor6 = 1e7;
+    } else if (val >= 0.001) {
+      mulfor6 = 1e8;
+    } else if (val >= 0.0001) {
+      mulfor6 = 1e9;
+    }
+    if (static_cast<int32_t>(val * mulfor6 + 0.5) / mulfor6 == val) return 6;
+  } else if (val < 1e10) {
+    FloatType divfor6 = 1.0;
+    if (val >= 1e9) {  // 1,000,000,000 to 9,999,999,999
+      divfor6 = 10000;
+    } else if (val >= 1e8) {  // 100,000,000 to 999,999,999
+      divfor6 = 1000;
+    } else if (val >= 1e7) {  // 10,000,000 to 99,999,999
+      divfor6 = 100;
+    } else if (val >= 1e6) {  // 1,000,000 to 9,999,999
+      divfor6 = 10;
+    }
+    if (static_cast<int32_t>(val / divfor6 + 0.5) * divfor6 == val) return 6;
+  }
+  return full;
+}
+
+inline void PrintTo(float f, ::std::ostream* os) {
+  auto old_precision = os->precision();
+  os->precision(AppropriateResolution(f));
+  *os << f;
+  os->precision(old_precision);
+}
+
+inline void PrintTo(double d, ::std::ostream* os) {
+  auto old_precision = os->precision();
+  os->precision(AppropriateResolution(d));
+  *os << d;
+  os->precision(old_precision);
+}
+
 // Overloads for C strings.
 GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
 inline void PrintTo(char* s, ::std::ostream* os) {
@@ -545,13 +626,13 @@ void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
 }
 
 // Overloads for ::std::string.
-GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
+GTEST_API_ void PrintStringTo(const ::std::string& s, ::std::ostream* os);
 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
   PrintStringTo(s, os);
 }
 
 // Overloads for ::std::u8string
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
 inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
   PrintU8StringTo(s, os);
@@ -572,7 +653,7 @@ inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
 
 // Overloads for ::std::wstring.
 #if GTEST_HAS_STD_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
+GTEST_API_ void PrintWideStringTo(const ::std::wstring& s, ::std::ostream* os);
 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
   PrintWideStringTo(s, os);
 }
@@ -587,6 +668,12 @@ inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
 
 inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
 
+#if GTEST_HAS_RTTI
+inline void PrintTo(const std::type_info& info, std::ostream* os) {
+  *os << internal::GetTypeName(info);
+}
+#endif  // GTEST_HAS_RTTI
+
 template <typename T>
 void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
   UniversalPrinter<T&>::Print(ref.get(), os);
@@ -744,6 +831,14 @@ class UniversalPrinter<Optional<T>> {
   }
 };
 
+template <>
+class UniversalPrinter<decltype(Nullopt())> {
+ public:
+  static void Print(decltype(Nullopt()), ::std::ostream* os) {
+    *os << "(nullopt)";
+  }
+};
+
 #endif  // GTEST_INTERNAL_HAS_OPTIONAL
 
 #if GTEST_INTERNAL_HAS_VARIANT
@@ -802,8 +897,8 @@ void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
   }
 }
 // This overload prints a (const) char array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const char* begin, size_t len, ::std::ostream* os);
+GTEST_API_ void UniversalPrintArray(const char* begin, size_t len,
+                                    ::std::ostream* os);
 
 #ifdef __cpp_char8_t
 // This overload prints a (const) char8_t array compactly.
@@ -820,8 +915,8 @@ GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
                                     ::std::ostream* os);
 
 // This overload prints a (const) wchar_t array compactly.
-GTEST_API_ void UniversalPrintArray(
-    const wchar_t* begin, size_t len, ::std::ostream* os);
+GTEST_API_ void UniversalPrintArray(const wchar_t* begin, size_t len,
+                                    ::std::ostream* os);
 
 // Implements printing an array type T[N].
 template <typename T, size_t N>
@@ -872,6 +967,13 @@ class UniversalTersePrinter<T&> {
     UniversalPrint(value, os);
   }
 };
+template <typename T>
+class UniversalTersePrinter<std::reference_wrapper<T>> {
+ public:
+  static void Print(std::reference_wrapper<T> value, ::std::ostream* os) {
+    UniversalTersePrinter<T>::Print(value.get(), os);
+  }
+};
 template <typename T, size_t N>
 class UniversalTersePrinter<T[N]> {
  public:
@@ -980,10 +1082,10 @@ void UniversalPrint(const T& value, ::std::ostream* os) {
   UniversalPrinter<T1>::Print(value, os);
 }
 
-typedef ::std::vector< ::std::string> Strings;
+typedef ::std::vector<::std::string> Strings;
 
-  // Tersely prints the first N fields of a tuple to a string vector,
-  // one element for each field.
+// Tersely prints the first N fields of a tuple to a string vector,
+// one element for each field.
 template <typename Tuple>
 void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
                                Strings*) {}
diff --git a/googletest/googletest/include/gtest/gtest-spi.h b/googletest/googletest/include/gtest/gtest-spi.h
index eacef44669e8104a3d28daa054edadcdeb23c548..c0613b6959560be931c52f5d0fd8f9bdf927dcbd 100644
--- a/googletest/googletest/include/gtest/gtest-spi.h
+++ b/googletest/googletest/include/gtest/gtest-spi.h
@@ -27,15 +27,14 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
 // Utilities for testing Google Test itself and code that uses Google Test
 // (e.g. frameworks built on top of Google Test).
 
-// GOOGLETEST_CM0004 DO NOT DELETE
-
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
 
+#include <string>
+
 #include "gtest/gtest.h"
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
@@ -88,7 +87,10 @@ class GTEST_API_ ScopedFakeTestPartResultReporter
   TestPartResultReporterInterface* old_reporter_;
   TestPartResultArray* const result_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+  ScopedFakeTestPartResultReporter(const ScopedFakeTestPartResultReporter&) =
+      delete;
+  ScopedFakeTestPartResultReporter& operator=(
+      const ScopedFakeTestPartResultReporter&) = delete;
 };
 
 namespace internal {
@@ -104,12 +106,14 @@ class GTEST_API_ SingleFailureChecker {
   SingleFailureChecker(const TestPartResultArray* results,
                        TestPartResult::Type type, const std::string& substr);
   ~SingleFailureChecker();
+
  private:
   const TestPartResultArray* const results_;
   const TestPartResult::Type type_;
   const std::string substr_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+  SingleFailureChecker(const SingleFailureChecker&) = delete;
+  SingleFailureChecker& operator=(const SingleFailureChecker&) = delete;
 };
 
 }  // namespace internal
@@ -119,7 +123,8 @@ class GTEST_API_ SingleFailureChecker {
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 
 // A set of macros for testing Google Test assertions or code that's expected
-// to generate Google Test fatal failures.  It verifies that the given
+// to generate Google Test fatal failures (e.g. a failure from an ASSERT_EQ, but
+// not a non-fatal failure, as from EXPECT_EQ).  It verifies that the given
 // statement will cause exactly one fatal Google Test failure with 'substr'
 // being part of the failure message.
 //
@@ -141,44 +146,46 @@ GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 // helper macro, due to some peculiarity in how the preprocessor
 // works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
 // gtest_unittest.cc will fail to compile if we do that.
-#define EXPECT_FATAL_FAILURE(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
+#define EXPECT_FATAL_FAILURE(statement, substr)                               \
+  do {                                                                        \
+    class GTestExpectFatalFailureHelper {                                     \
+     public:                                                                  \
+      static void Execute() { statement; }                                    \
+    };                                                                        \
+    ::testing::TestPartResultArray gtest_failures;                            \
+    ::testing::internal::SingleFailureChecker gtest_checker(                  \
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \
+    {                                                                         \
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(             \
+          ::testing::ScopedFakeTestPartResultReporter::                       \
+              INTERCEPT_ONLY_CURRENT_THREAD,                                  \
+          &gtest_failures);                                                   \
+      GTestExpectFatalFailureHelper::Execute();                               \
+    }                                                                         \
   } while (::testing::internal::AlwaysFalse())
 
-#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do { \
-    class GTestExpectFatalFailureHelper {\
-     public:\
-      static void Execute() { statement; }\
-    };\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ALL_THREADS, &gtest_failures);\
-      GTestExpectFatalFailureHelper::Execute();\
-    }\
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr)                \
+  do {                                                                        \
+    class GTestExpectFatalFailureHelper {                                     \
+     public:                                                                  \
+      static void Execute() { statement; }                                    \
+    };                                                                        \
+    ::testing::TestPartResultArray gtest_failures;                            \
+    ::testing::internal::SingleFailureChecker gtest_checker(                  \
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \
+    {                                                                         \
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(             \
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);                                                   \
+      GTestExpectFatalFailureHelper::Execute();                               \
+    }                                                                         \
   } while (::testing::internal::AlwaysFalse())
 
 // A macro for testing Google Test assertions or code that's expected to
-// generate Google Test non-fatal failures.  It asserts that the given
-// statement will cause exactly one non-fatal Google Test failure with 'substr'
-// being part of the failure message.
+// generate Google Test non-fatal failures (e.g. a failure from an EXPECT_EQ,
+// but not from an ASSERT_EQ). It asserts that the given statement will cause
+// exactly one non-fatal Google Test failure with 'substr' being part of the
+// failure message.
 //
 // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
 // affects and considers failures generated in the current thread and
@@ -207,32 +214,37 @@ GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 // instead of
 //   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
 // to avoid an MSVC warning on unreachable code.
-#define EXPECT_NONFATAL_FAILURE(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
+#define EXPECT_NONFATAL_FAILURE(statement, substr)                    \
+  do {                                                                \
+    ::testing::TestPartResultArray gtest_failures;                    \
+    ::testing::internal::SingleFailureChecker gtest_checker(          \
         &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
-          ::testing::ScopedFakeTestPartResultReporter:: \
-          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
+        (substr));                                                    \
+    {                                                                 \
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(     \
+          ::testing::ScopedFakeTestPartResultReporter::               \
+              INTERCEPT_ONLY_CURRENT_THREAD,                          \
+          &gtest_failures);                                           \
+      if (::testing::internal::AlwaysTrue()) {                        \
+        statement;                                                    \
+      }                                                               \
+    }                                                                 \
   } while (::testing::internal::AlwaysFalse())
 
-#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
-  do {\
-    ::testing::TestPartResultArray gtest_failures;\
-    ::testing::internal::SingleFailureChecker gtest_checker(\
-        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
-        (substr));\
-    {\
-      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr)             \
+  do {                                                                        \
+    ::testing::TestPartResultArray gtest_failures;                            \
+    ::testing::internal::SingleFailureChecker gtest_checker(                  \
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure,         \
+        (substr));                                                            \
+    {                                                                         \
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(             \
           ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
-          &gtest_failures);\
-      if (::testing::internal::AlwaysTrue()) { statement; }\
-    }\
+          &gtest_failures);                                                   \
+      if (::testing::internal::AlwaysTrue()) {                                \
+        statement;                                                            \
+      }                                                                       \
+    }                                                                         \
   } while (::testing::internal::AlwaysFalse())
 
 #endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/googletest/googletest/include/gtest/gtest-test-part.h b/googletest/googletest/include/gtest/gtest-test-part.h
index 203fdf98c69fcdf9647437cdc8e6cc70ae18e609..8290b4d653d1678433db6c27e1ebe5b3499387b7 100644
--- a/googletest/googletest/include/gtest/gtest-test-part.h
+++ b/googletest/googletest/include/gtest/gtest-test-part.h
@@ -26,14 +26,19 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// GOOGLETEST_CM0001 DO NOT DELETE
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
 
 #include <iosfwd>
+#include <ostream>
+#include <string>
 #include <vector>
+
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"
 
@@ -142,7 +147,8 @@ class GTEST_API_ TestPartResultArray {
  private:
   std::vector<TestPartResult> array_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+  TestPartResultArray(const TestPartResultArray&) = delete;
+  TestPartResultArray& operator=(const TestPartResultArray&) = delete;
 };
 
 // This interface knows how to report a test part result.
@@ -168,11 +174,13 @@ class GTEST_API_ HasNewFatalFailureHelper
   ~HasNewFatalFailureHelper() override;
   void ReportTestPartResult(const TestPartResult& result) override;
   bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+
  private:
   bool has_new_fatal_failure_;
   TestPartResultReporterInterface* original_reporter_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+  HasNewFatalFailureHelper(const HasNewFatalFailureHelper&) = delete;
+  HasNewFatalFailureHelper& operator=(const HasNewFatalFailureHelper&) = delete;
 };
 
 }  // namespace internal
diff --git a/googletest/googletest/include/gtest/gtest-typed-test.h b/googletest/googletest/include/gtest/gtest-typed-test.h
index 9fdc6be10dc26b8033e1aa5a0f5af05f82547915..bd35a32660130403369577f61fb68c85c4f85eb3 100644
--- a/googletest/googletest/include/gtest/gtest-typed-test.h
+++ b/googletest/googletest/include/gtest/gtest-typed-test.h
@@ -27,7 +27,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
@@ -190,7 +192,7 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
   typedef ::testing::internal::GenerateTypeList<Types>::type            \
       GTEST_TYPE_PARAMS_(CaseName);                                     \
   typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
-      GTEST_NAME_GENERATOR_(CaseName)
+  GTEST_NAME_GENERATOR_(CaseName)
 
 #define TYPED_TEST(CaseName, TestName)                                        \
   static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
@@ -256,7 +258,7 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
 // #included in multiple translation units linked together.
 #define TYPED_TEST_SUITE_P(SuiteName)              \
   static ::testing::internal::TypedTestSuitePState \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
+  GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
 
 // Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@@ -301,21 +303,21 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
   REGISTER_TYPED_TEST_SUITE_P
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
-#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
-  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \
-                "test-suit-prefix must not be empty");                      \
-  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
-      ::testing::internal::TypeParameterizedTestSuite<                      \
-          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
-          ::testing::internal::GenerateTypeList<Types>::type>::             \
-          Register(GTEST_STRINGIFY_(Prefix),                                \
-                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
-                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
-                   GTEST_STRINGIFY_(SuiteName),                             \
-                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
-                   ::testing::internal::GenerateNames<                      \
-                       ::testing::internal::NameGeneratorSelector<          \
-                           __VA_ARGS__>::type,                              \
+#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)     \
+  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                     \
+                "test-suit-prefix must not be empty");                    \
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =      \
+      ::testing::internal::TypeParameterizedTestSuite<                    \
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,  \
+          ::testing::internal::GenerateTypeList<Types>::type>::           \
+          Register(GTEST_STRINGIFY_(Prefix),                              \
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),           \
+                   GTEST_STRINGIFY_(SuiteName),                           \
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),               \
+                   ::testing::internal::GenerateNames<                    \
+                       ::testing::internal::NameGeneratorSelector<        \
+                           __VA_ARGS__>::type,                            \
                        ::testing::internal::GenerateTypeList<Types>::type>())
 
 // Legacy API is deprecated but still available
diff --git a/googletest/googletest/include/gtest/gtest.h b/googletest/googletest/include/gtest/gtest.h
index 74a28dddd9a50155ef6f478ec1b3aaccd323f36e..d665a5a3c949faf31ffe46e9e9d2482b5e00aa17 100644
--- a/googletest/googletest/include/gtest/gtest.h
+++ b/googletest/googletest/include/gtest/gtest.h
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines the public API for Google Test.  It should be
@@ -49,26 +48,36 @@
 
 // GOOGLETEST_CM0001 DO NOT DELETE
 
+/* 2024.01.11 - Extend the interface parameters of gtest
+   Copyright (C) 2018. Huawei Technologies Co., Ltd. All rights reserved.*/
+
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
 
 #include <cstddef>
+#include <cstdint>
+#include <iomanip>
 #include <limits>
 #include <memory>
 #include <ostream>
+#include <set>
+#include <sstream>
+#include <string>
 #include <type_traits>
 #include <vector>
 
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-string.h"
+#include "gtest/gtest-assertion-result.h"
 #include "gtest/gtest-death-test.h"
 #include "gtest/gtest-matchers.h"
 #include "gtest/gtest-message.h"
 #include "gtest/gtest-param-test.h"
 #include "gtest/gtest-printers.h"
-#include "gtest/gtest_prod.h"
 #include "gtest/gtest-test-part.h"
 #include "gtest/gtest-typed-test.h"
+#include "gtest/gtest_pred_impl.h"
+#include "gtest/gtest_prod.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
 
 #include "gtest/hwext/gtest-tag.h"
 #include "gtest/hwext/gtest-ext.h"
@@ -77,17 +86,6 @@
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
 
-namespace testing {
-
-// Silence C4100 (unreferenced formal parameter) and 4805
-// unsafe mix of type 'const int' and type 'const bool'
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4805)
-# pragma warning(disable:4100)
-#endif
-
-
 // Declares the flags.
 
 // This flag temporary enables the disabled tests.
@@ -142,6 +140,12 @@ GTEST_DECLARE_int32_(random_seed);
 // is 1. If the value is -1 the tests are repeating forever.
 GTEST_DECLARE_int32_(repeat);
 
+// This flag controls whether Google Test Environments are recreated for each
+// repeat of the tests. The default value is true. If set to false the global
+// test Environment objects are only set up once, for the first iteration, and
+// only torn down once, for the last.
+GTEST_DECLARE_bool_(recreate_environments_when_repeating);
+
 // This flag controls whether Google Test includes Google Test internal
 // stack frames in failure stack traces.
 GTEST_DECLARE_bool_(show_internal_stack_frames);
@@ -167,6 +171,16 @@ GTEST_DECLARE_string_(stream_result_to);
 GTEST_DECLARE_string_(flagfile);
 #endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
 
+namespace testing {
+
+// Silence C4100 (unreferenced formal parameter) and 4805
+// unsafe mix of type 'const int' and type 'const bool'
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4805)
+#pragma warning(disable : 4100)
+#endif
+
 // The upper limit for valid stack trace depths.
 const int kMaxStackTraceDepth = 100;
 
@@ -190,6 +204,17 @@ void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                     const std::string& message);
 std::set<std::string>* GetIgnoredParameterizedTestSuites();
 
+// A base class that prevents subclasses from being copyable.
+// We do this instead of using '= delete' so as to avoid triggering warnings
+// inside user code regarding any of our declarations.
+class GTestNonCopyable {
+ public:
+  GTestNonCopyable() = default;
+  GTestNonCopyable(const GTestNonCopyable &) = delete;
+  GTestNonCopyable &operator=(const GTestNonCopyable &) = delete;
+  ~GTestNonCopyable() = default;
+};
+
 }  // namespace internal
 
 // The friend relationship of some of these classes is cyclic.
@@ -205,193 +230,6 @@ using TestCase = TestSuite;
 class TestInfo;
 class UnitTest;
 
-// A class for indicating whether an assertion was successful.  When
-// the assertion wasn't successful, the AssertionResult object
-// remembers a non-empty message that describes how it failed.
-//
-// To create an instance of this class, use one of the factory functions
-// (AssertionSuccess() and AssertionFailure()).
-//
-// This class is useful for two purposes:
-//   1. Defining predicate functions to be used with Boolean test assertions
-//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
-//   2. Defining predicate-format functions to be
-//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
-//
-// For example, if you define IsEven predicate:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
-// will print the message
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false (5 is odd)
-//   Expected: true
-//
-// instead of a more opaque
-//
-//   Value of: IsEven(Fib(5))
-//     Actual: false
-//   Expected: true
-//
-// in case IsEven is a simple Boolean predicate.
-//
-// If you expect your predicate to be reused and want to support informative
-// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
-// about half as often as positive ones in our tests), supply messages for
-// both success and failure cases:
-//
-//   testing::AssertionResult IsEven(int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess() << n << " is even";
-//     else
-//       return testing::AssertionFailure() << n << " is odd";
-//   }
-//
-// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
-//
-//   Value of: IsEven(Fib(6))
-//     Actual: true (8 is even)
-//   Expected: false
-//
-// NB: Predicates that support negative Boolean assertions have reduced
-// performance in positive ones so be careful not to use them in tests
-// that have lots (tens of thousands) of positive Boolean assertions.
-//
-// To use this class with EXPECT_PRED_FORMAT assertions such as:
-//
-//   // Verifies that Foo() returns an even number.
-//   EXPECT_PRED_FORMAT1(IsEven, Foo());
-//
-// you need to define:
-//
-//   testing::AssertionResult IsEven(const char* expr, int n) {
-//     if ((n % 2) == 0)
-//       return testing::AssertionSuccess();
-//     else
-//       return testing::AssertionFailure()
-//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
-//   }
-//
-// If Foo() returns 5, you will see the following message:
-//
-//   Expected: Foo() is even
-//     Actual: it's 5
-//
-class GTEST_API_ AssertionResult {
- public:
-  // Copy constructor.
-  // Used in EXPECT_TRUE/FALSE(assertion_result).
-  AssertionResult(const AssertionResult& other);
-
-// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
-// This warning is not emitted in Visual Studio 2017.
-// This warning is off by default starting in Visual Studio 2019 but can be
-// enabled with command-line options.
-#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
-  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
-#endif
-
-  // Used in the EXPECT_TRUE/FALSE(bool_expression).
-  //
-  // T must be contextually convertible to bool.
-  //
-  // The second parameter prevents this overload from being considered if
-  // the argument is implicitly convertible to AssertionResult. In that case
-  // we want AssertionResult's copy constructor to be used.
-  template <typename T>
-  explicit AssertionResult(
-      const T& success,
-      typename std::enable_if<
-          !std::is_convertible<T, AssertionResult>::value>::type*
-      /*enabler*/
-      = nullptr)
-      : success_(success) {}
-
-#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
-  GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
-
-  // Assignment operator.
-  AssertionResult& operator=(AssertionResult other) {
-    swap(other);
-    return *this;
-  }
-
-  // Returns true if and only if the assertion succeeded.
-  operator bool() const { return success_; }  // NOLINT
-
-  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-  AssertionResult operator!() const;
-
-  // Returns the text streamed into this AssertionResult. Test assertions
-  // use it when they fail (i.e., the predicate's outcome doesn't match the
-  // assertion's expectation). When nothing has been streamed into the
-  // object, returns an empty string.
-  const char* message() const {
-    return message_.get() != nullptr ? message_->c_str() : "";
-  }
-  // Deprecated; please use message() instead.
-  const char* failure_message() const { return message(); }
-
-  // Streams a custom failure message into this object.
-  template <typename T> AssertionResult& operator<<(const T& value) {
-    AppendMessage(Message() << value);
-    return *this;
-  }
-
-  // Allows streaming basic output manipulators such as endl or flush into
-  // this object.
-  AssertionResult& operator<<(
-      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
-    AppendMessage(Message() << basic_manipulator);
-    return *this;
-  }
-
- private:
-  // Appends the contents of message to message_.
-  void AppendMessage(const Message& a_message) {
-    if (message_.get() == nullptr) message_.reset(new ::std::string);
-    message_->append(a_message.GetString().c_str());
-  }
-
-  // Swap the contents of this AssertionResult with other.
-  void swap(AssertionResult& other);
-
-  // Stores result of the assertion predicate.
-  bool success_;
-  // Stores the message describing the condition in case the expectation
-  // construct is not satisfied with the predicate's outcome.
-  // Referenced via a pointer to avoid taking too much stack frame space
-  // with test assertions.
-  std::unique_ptr< ::std::string> message_;
-};
-
-// Makes a successful assertion result.
-GTEST_API_ AssertionResult AssertionSuccess();
-
-// Makes a failed assertion result.
-GTEST_API_ AssertionResult AssertionFailure();
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << msg.
-GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
-
-}  // namespace testing
-
-// Includes the auto-generated header that implements a family of generic
-// predicate assertion macros. This include comes late because it relies on
-// APIs declared above.
-#include "gtest/gtest_pred_impl.h"
-
-namespace testing {
-
 // The abstract class that all tests inherit from.
 //
 // In Google Test, a unit test program contains one or many TestSuites, and
@@ -472,7 +310,7 @@ class GTEST_API_ Test {
   // SetUp/TearDown method of Environment objects registered with Google
   // Test) will be output as attributes of the <testsuites> element.
   static void RecordProperty(const std::string& key, const std::string& value);
-  static void RecordProperty(const std::string& key, int value);
+  static void RecordProperty(const std::string& key, int64_t value);
 
  protected:
   // Creates a Test object.
@@ -526,7 +364,8 @@ class GTEST_API_ Test {
   virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
 
   // We disallow copying Tests.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+  Test(const Test&) = delete;
+  Test& operator=(const Test&) = delete;
 };
 
 typedef internal::TimeInMillis TimeInMillis;
@@ -540,24 +379,17 @@ class TestProperty {
   // C'tor.  TestProperty does NOT have a default constructor.
   // Always use this constructor (with parameters) to create a
   // TestProperty object.
-  TestProperty(const std::string& a_key, const std::string& a_value) :
-    key_(a_key), value_(a_value) {
-  }
+  TestProperty(const std::string& a_key, const std::string& a_value)
+      : key_(a_key), value_(a_value) {}
 
   // Gets the user supplied key.
-  const char* key() const {
-    return key_.c_str();
-  }
+  const char* key() const { return key_.c_str(); }
 
   // Gets the user supplied value.
-  const char* value() const {
-    return value_.c_str();
-  }
+  const char* value() const { return value_.c_str(); }
 
   // Sets a new value, overriding the one supplied in the constructor.
-  void SetValue(const std::string& new_value) {
-    value_ = new_value;
-  }
+  void SetValue(const std::string& new_value) { value_ = new_value; }
 
  private:
   // The key supplied by the user.
@@ -691,7 +523,8 @@ class GTEST_API_ TestResult {
   TimeInMillis elapsed_time_;
 
   // We disallow copying TestResult.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+  TestResult(const TestResult&) = delete;
+  TestResult& operator=(const TestResult&) = delete;
 };  // class TestResult
 
 // A TestInfo object stores the following information about a test:
@@ -815,8 +648,8 @@ class GTEST_API_ TestInfo {
   }
 
   // These fields are immutable properties of the test.
-  const std::string test_suite_name_;    // test suite name
-  const std::string name_;               // Test name
+  const std::string test_suite_name_;  // test suite name
+  const std::string name_;             // Test name
   // Name of the parameter type, or NULL if this is not a typed or a
   // type-parameterized test.
   const std::unique_ptr<const ::std::string> type_param_;
@@ -837,7 +670,8 @@ class GTEST_API_ TestInfo {
   // test for the second time.
   TestResult result_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+  TestInfo(const TestInfo&) = delete;
+  TestInfo& operator=(const TestInfo&) = delete;
 };
 
 // A test suite, which consists of a vector of TestInfos.
@@ -945,7 +779,7 @@ class GTEST_API_ TestSuite {
 
   // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
   // destruction of the TestSuite object.
-  void AddTestInfo(TestInfo * test_info);
+  void AddTestInfo(TestInfo* test_info);
 
   // Clears the results of all tests in this test suite.
   void ClearResult();
@@ -1046,7 +880,8 @@ class GTEST_API_ TestSuite {
   TestResult ad_hoc_test_result_;
 
   // We disallow copying TestSuites.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
+  TestSuite(const TestSuite&) = delete;
+  TestSuite& operator=(const TestSuite&) = delete;
 };
 
 // An Environment object is capable of setting up and tearing down an
@@ -1073,6 +908,7 @@ class Environment {
 
   // Override this to define how to tear down the environment.
   virtual void TearDown() {}
+
  private:
   // If you see an error about overriding the following function or
   // about it being private, you have mis-spelled SetUp() as Setup().
@@ -1124,6 +960,9 @@ class TestEventListener {
   // Fired before the test starts.
   virtual void OnTestStart(const TestInfo& test_info) = 0;
 
+  // Fired when a test is disabled
+  virtual void OnTestDisabled(const TestInfo& /*test_info*/) {}
+
   // Fired after a failed assertion or a SUCCEED() invocation.
   // If you want to throw an exception from this function to skip to the next
   // TEST, it must be AssertionException defined above, or inherited from it.
@@ -1147,8 +986,7 @@ class TestEventListener {
   virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
 
   // Fired after each iteration of tests finishes.
-  virtual void OnTestIterationEnd(const UnitTest& unit_test,
-                                  int iteration) = 0;
+  virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration) = 0;
 
   // Fired after all test activities have ended.
   virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
@@ -1173,6 +1011,7 @@ class EmptyTestEventListener : public TestEventListener {
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   void OnTestStart(const TestInfo& /*test_info*/) override {}
+  void OnTestDisabled(const TestInfo& /*test_info*/) override {}
   void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
   void OnTestEnd(const TestInfo& /*test_info*/) override {}
   void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
@@ -1262,7 +1101,8 @@ class GTEST_API_ TestEventListeners {
   TestEventListener* default_xml_generator_;
 
   // We disallow copying TestEventListeners.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+  TestEventListeners(const TestEventListeners&) = delete;
+  TestEventListeners& operator=(const TestEventListeners&) = delete;
 };
 
 // A UnitTest consists of a vector of TestSuites.
@@ -1305,8 +1145,7 @@ class GTEST_API_ UnitTest {
 
   // Returns the TestInfo object for the test that's currently running,
   // or NULL if no test is running.
-  const TestInfo* current_test_info() const
-      GTEST_LOCK_EXCLUDED_(mutex_);
+  const TestInfo* current_test_info() const GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Returns the random seed used at the start of the current test run.
   int random_seed() const;
@@ -1412,8 +1251,7 @@ class GTEST_API_ UnitTest {
   // eventually call this to report their results.  The user code
   // should use the assertion macros instead of calling this directly.
   void AddTestPartResult(TestPartResult::Type result_type,
-                         const char* file_name,
-                         int line_number,
+                         const char* file_name, int line_number,
                          const std::string& message,
                          const std::string& os_stack_trace)
       GTEST_LOCK_EXCLUDED_(mutex_);
@@ -1444,8 +1282,7 @@ class GTEST_API_ UnitTest {
   friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
   friend void internal::ReportFailureInUnknownLocation(
-      TestPartResult::Type result_type,
-      const std::string& message);
+      TestPartResult::Type result_type, const std::string& message);
 
   // Creates an empty UnitTest.
   UnitTest();
@@ -1459,8 +1296,7 @@ class GTEST_API_ UnitTest {
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Pops a trace from the per-thread Google Test trace stack.
-  void PopGTestTrace()
-      GTEST_LOCK_EXCLUDED_(mutex_);
+  void PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Protects mutable state in *impl_.  This is mutable as some const
   // methods need to lock it too.
@@ -1473,7 +1309,8 @@ class GTEST_API_ UnitTest {
   internal::UnitTestImpl* impl_;
 
   // We disallow copying UnitTest.
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+  UnitTest(const UnitTest&) = delete;
+  UnitTest& operator=(const UnitTest&) = delete;
 };
 
 // A convenient wrapper for adding an environment for the test
@@ -1524,13 +1361,11 @@ namespace internal {
 // when calling EXPECT_* in a tight loop.
 template <typename T1, typename T2>
 AssertionResult CmpHelperEQFailure(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const T1& lhs, const T2& rhs) {
-  return EqFailure(lhs_expression,
-                   rhs_expression,
+                                   const char* rhs_expression, const T1& lhs,
+                                   const T2& rhs) {
+  return EqFailure(lhs_expression, rhs_expression,
                    FormatForComparisonFailureMessage(lhs, rhs),
-                   FormatForComparisonFailureMessage(rhs, lhs),
-                   false);
+                   FormatForComparisonFailureMessage(rhs, lhs), false);
 }
 
 // This block of code defines operator==/!=
@@ -1543,8 +1378,7 @@ inline bool operator!=(faketype, faketype) { return false; }
 // The helper function for {ASSERT|EXPECT}_EQ.
 template <typename T1, typename T2>
 AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression,
-                            const T1& lhs,
+                            const char* rhs_expression, const T1& lhs,
                             const T2& rhs) {
   if (lhs == rhs) {
     return AssertionSuccess();
@@ -1575,8 +1409,7 @@ class EqHelper {
   // Even though its body looks the same as the above version, we
   // cannot merge the two, as it will make anonymous enums unhappy.
   static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression,
-                                 BiggestInt lhs,
+                                 const char* rhs_expression, BiggestInt lhs,
                                  BiggestInt rhs) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
@@ -1611,16 +1444,16 @@ AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
-template <typename T1, typename T2>\
-AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                   const T1& val1, const T2& val2) {\
-  if (val1 op val2) {\
-    return AssertionSuccess();\
-  } else {\
-    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
-  }\
-}
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)                                \
+  template <typename T1, typename T2>                                      \
+  AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                     const T1& val1, const T2& val2) {     \
+    if (val1 op val2) {                                                    \
+      return AssertionSuccess();                                           \
+    } else {                                                               \
+      return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);            \
+    }                                                                      \
+  }
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
@@ -1642,49 +1475,42 @@ GTEST_IMPL_CMP_HELPER_(GT, >)
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                           const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
+                                          const char* s1, const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
                                               const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
+                                              const char* s1, const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRNE.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                           const char* s2_expression,
-                                          const char* s1,
-                                          const char* s2);
+                                          const char* s1, const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRCASENE.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                               const char* s2_expression,
-                                              const char* s1,
-                                              const char* s2);
-
+                                              const char* s1, const char* s2);
 
 // Helper function for *_STREQ on wide strings.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                           const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
+                                          const wchar_t* s1, const wchar_t* s2);
 
 // Helper function for *_STRNE on wide strings.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                           const char* s2_expression,
-                                          const wchar_t* s1,
-                                          const wchar_t* s2);
+                                          const wchar_t* s1, const wchar_t* s2);
 
 }  // namespace internal
 
@@ -1696,32 +1522,40 @@ GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
 //
 // The {needle,haystack}_expr arguments are the stringified
 // expressions that generated the two real arguments.
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack);
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsSubstring(const char* needle_expr,
+                                       const char* haystack_expr,
+                                       const char* needle,
+                                       const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(const char* needle_expr,
+                                       const char* haystack_expr,
+                                       const wchar_t* needle,
+                                       const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr,
+                                          const char* haystack_expr,
+                                          const char* needle,
+                                          const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr,
+                                          const char* haystack_expr,
+                                          const wchar_t* needle,
+                                          const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(const char* needle_expr,
+                                       const char* haystack_expr,
+                                       const ::std::string& needle,
+                                       const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr,
+                                          const char* haystack_expr,
+                                          const ::std::string& needle,
+                                          const ::std::string& haystack);
 
 #if GTEST_HAS_STD_WSTRING
-GTEST_API_ AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
-GTEST_API_ AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsSubstring(const char* needle_expr,
+                                       const char* haystack_expr,
+                                       const ::std::wstring& needle,
+                                       const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(const char* needle_expr,
+                                          const char* haystack_expr,
+                                          const ::std::wstring& needle,
+                                          const ::std::wstring& haystack);
 #endif  // GTEST_HAS_STD_WSTRING
 
 namespace internal {
@@ -1736,8 +1570,7 @@ namespace internal {
 template <typename RawType>
 AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
                                          const char* rhs_expression,
-                                         RawType lhs_value,
-                                         RawType rhs_value) {
+                                         RawType lhs_value, RawType rhs_value) {
   const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
 
   if (lhs.AlmostEquals(rhs)) {
@@ -1752,10 +1585,8 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
   rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << rhs_value;
 
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   StringStreamToString(&lhs_ss),
-                   StringStreamToString(&rhs_ss),
+  return EqFailure(lhs_expression, rhs_expression,
+                   StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
                    false);
 }
 
@@ -1765,8 +1596,7 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
 GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
                                                 const char* expr2,
                                                 const char* abs_error_expr,
-                                                double val1,
-                                                double val2,
+                                                double val1, double val2,
                                                 double abs_error);
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
@@ -1774,9 +1604,7 @@ GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
 class GTEST_API_ AssertHelper {
  public:
   // Constructor.
-  AssertHelper(TestPartResult::Type type,
-               const char* file,
-               int line,
+  AssertHelper(TestPartResult::Type type, const char* file, int line,
                const char* message);
   ~AssertHelper();
 
@@ -1790,11 +1618,9 @@ class GTEST_API_ AssertHelper {
   // re-using stack space even for temporary variables, so every EXPECT_EQ
   // reserves stack space for another AssertHelper.
   struct AssertHelperData {
-    AssertHelperData(TestPartResult::Type t,
-                     const char* srcfile,
-                     int line_num,
+    AssertHelperData(TestPartResult::Type t, const char* srcfile, int line_num,
                      const char* msg)
-        : type(t), file(srcfile), line(line_num), message(msg) { }
+        : type(t), file(srcfile), line(line_num), message(msg) {}
 
     TestPartResult::Type const type;
     const char* const file;
@@ -1802,12 +1628,14 @@ class GTEST_API_ AssertHelper {
     std::string const message;
 
    private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+    AssertHelperData(const AssertHelperData&) = delete;
+    AssertHelperData& operator=(const AssertHelperData&) = delete;
   };
 
   AssertHelperData* const data_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+  AssertHelper(const AssertHelper&) = delete;
+  AssertHelper& operator=(const AssertHelper&) = delete;
 };
 
 }  // namespace internal
@@ -1822,7 +1650,7 @@ class GTEST_API_ AssertHelper {
 // the GetParam() method.
 //
 // Use it with one of the parameter generator defining functions, like Range(),
-// Values(), ValuesIn(), Bool(), and Combine().
+// Values(), ValuesIn(), Bool(), Combine(), and ConvertGenerator<T>().
 //
 // class FooTest : public ::testing::TestWithParam<int> {
 //  protected:
@@ -1864,15 +1692,14 @@ class WithParamInterface {
  private:
   // Sets parameter value. The caller is responsible for making sure the value
   // remains alive and unchanged throughout the current test.
-  static void SetParam(const ParamType* parameter) {
-    parameter_ = parameter;
-  }
+  static void SetParam(const ParamType* parameter) { parameter_ = parameter; }
 
   // Static value used for accessing parameter during a test lifetime.
   static const ParamType* parameter_;
 
   // TestClass must be a subclass of WithParamInterface<T> and Test.
-  template <class TestClass> friend class internal::ParameterizedTestFactory;
+  template <class TestClass>
+  friend class internal::ParameterizedTestFactory;
 };
 
 template <typename T>
@@ -1882,8 +1709,7 @@ const T* WithParamInterface<T>::parameter_ = nullptr;
 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
 
 template <typename T>
-class TestWithParam : public Test, public WithParamInterface<T> {
-};
+class TestWithParam : public Test, public WithParamInterface<T> {};
 
 // Macros for indicating success/failure in test code.
 
@@ -1914,7 +1740,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 
 // Generates a nonfatal failure at the given source file location with
 // a generic message.
-#define ADD_FAILURE_AT(file, line) \
+#define ADD_FAILURE_AT(file, line)        \
   GTEST_MESSAGE_AT_(file, line, "Failed", \
                     ::testing::TestPartResult::kNonFatalFailure)
 
@@ -1922,14 +1748,14 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
 
 // Like GTEST_FAIL(), but at the given source file location.
-#define GTEST_FAIL_AT(file, line)         \
-  GTEST_MESSAGE_AT_(file, line, "Failed", \
-                    ::testing::TestPartResult::kFatalFailure)
+#define GTEST_FAIL_AT(file, line)                \
+  return GTEST_MESSAGE_AT_(file, line, "Failed", \
+                           ::testing::TestPartResult::kFatalFailure)
 
 // Define this macro to 1 to omit the definition of FAIL(), which is a
 // generic name and clashes with some other libraries.
 #if !GTEST_DONT_DEFINE_FAIL
-# define FAIL() GTEST_FAIL()
+#define FAIL() GTEST_FAIL()
 #endif
 
 // Generates a success with a generic message.
@@ -1938,7 +1764,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // Define this macro to 1 to omit the definition of SUCCEED(), which
 // is a generic name and clashes with some other libraries.
 #if !GTEST_DONT_DEFINE_SUCCEED
-# define SUCCEED() GTEST_SUCCEED()
+#define SUCCEED() GTEST_SUCCEED()
 #endif
 
 // Macros for testing exceptions.
@@ -1966,16 +1792,15 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // Boolean assertions. Condition can be either a Boolean expression or an
 // AssertionResult. For more information on how to use AssertionResult with
 // these macros see comments on that class.
-#define GTEST_EXPECT_TRUE(condition) \
+#define GTEST_EXPECT_TRUE(condition)                      \
   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                       GTEST_NONFATAL_FAILURE_)
-#define GTEST_EXPECT_FALSE(condition) \
+#define GTEST_EXPECT_FALSE(condition)                        \
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_NONFATAL_FAILURE_)
 #define GTEST_ASSERT_TRUE(condition) \
-  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
-                      GTEST_FATAL_FAILURE_)
-#define GTEST_ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_)
+#define GTEST_ASSERT_FALSE(condition)                        \
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_FATAL_FAILURE_)
 
@@ -2074,27 +1899,27 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // ASSERT_XY(), which clashes with some users' own code.
 
 #if !GTEST_DONT_DEFINE_ASSERT_EQ
-# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_NE
-# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_LE
-# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_LT
-# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_GE
-# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_GT
-# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
 #endif
 
 // C-string Comparisons.  All tests treat NULL and any non-NULL string
@@ -2119,7 +1944,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
 #define EXPECT_STRCASEEQ(s1, s2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define EXPECT_STRCASENE(s1, s2)\
+#define EXPECT_STRCASENE(s1, s2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
 
 #define ASSERT_STREQ(s1, s2) \
@@ -2128,7 +1953,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
 #define ASSERT_STRCASEEQ(s1, s2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
-#define ASSERT_STRCASENE(s1, s2)\
+#define ASSERT_STRCASENE(s1, s2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
 
 // Macros for comparing floating-point numbers.
@@ -2145,29 +1970,29 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // FloatingPoint template class in gtest-internal.h if you are
 // interested in the implementation details.
 
-#define EXPECT_FLOAT_EQ(val1, val2)\
+#define EXPECT_FLOAT_EQ(val1, val2)                                         \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                       val1, val2)
 
-#define EXPECT_DOUBLE_EQ(val1, val2)\
+#define EXPECT_DOUBLE_EQ(val1, val2)                                         \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                       val1, val2)
 
-#define ASSERT_FLOAT_EQ(val1, val2)\
+#define ASSERT_FLOAT_EQ(val1, val2)                                         \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                       val1, val2)
 
-#define ASSERT_DOUBLE_EQ(val1, val2)\
+#define ASSERT_DOUBLE_EQ(val1, val2)                                         \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                       val1, val2)
 
-#define EXPECT_NEAR(val1, val2, abs_error)\
-  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
+#define EXPECT_NEAR(val1, val2, abs_error)                                   \
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \
+                      abs_error)
 
-#define ASSERT_NEAR(val1, val2, abs_error)\
-  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
-                      val1, val2, abs_error)
+#define ASSERT_NEAR(val1, val2, abs_error)                                   \
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, val1, val2, \
+                      abs_error)
 
 // These predicate format functions work on floating-point values, and
 // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
@@ -2181,7 +2006,6 @@ GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
                                     double val1, double val2);
 
-
 #if GTEST_OS_WINDOWS
 
 // Macros that test for HRESULT failure and success, these are only useful
@@ -2193,17 +2017,17 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
 // expected result and the actual result with both a human-readable
 // string representation of the error, if available, as well as the
 // hex result code.
-# define EXPECT_HRESULT_SUCCEEDED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+#define EXPECT_HRESULT_SUCCEEDED(expr) \
+  EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
 
-# define ASSERT_HRESULT_SUCCEEDED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+#define ASSERT_HRESULT_SUCCEEDED(expr) \
+  ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
 
-# define EXPECT_HRESULT_FAILED(expr) \
-    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+#define EXPECT_HRESULT_FAILED(expr) \
+  EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
 
-# define ASSERT_HRESULT_FAILED(expr) \
-    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+#define ASSERT_HRESULT_FAILED(expr) \
+  ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
 
 #endif  // GTEST_OS_WINDOWS
 
@@ -2218,9 +2042,9 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
 //   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
 //
 #define ASSERT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+  GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
 #define EXPECT_NO_FATAL_FAILURE(statement) \
-    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+  GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
 
 // Causes a trace (including the given source file path and line number,
 // and the given message) to be included in every test failure message generated
@@ -2262,10 +2086,9 @@ class GTEST_API_ ScopedTrace {
  private:
   void PushTrace(const char* file, int line, std::string message);
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
-} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
-                            // c'tor and d'tor.  Therefore it doesn't
-                            // need to be used otherwise.
+  ScopedTrace(const ScopedTrace&) = delete;
+  ScopedTrace& operator=(const ScopedTrace&) = delete;
+};
 
 // Causes a trace (including the source file path, the current line
 // number, and the given message) to be included in every test failure
@@ -2282,9 +2105,9 @@ class GTEST_API_ ScopedTrace {
 // Assuming that each thread maintains its own stack of traces.
 // Therefore, a SCOPED_TRACE() would (correctly) only affect the
 // assertions in its own thread.
-#define SCOPED_TRACE(message) \
-  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
-    __FILE__, __LINE__, (message))
+#define SCOPED_TRACE(message)                                         \
+  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)( \
+      __FILE__, __LINE__, (message))
 
 // Compile-time assertion for type equality.
 // StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
@@ -2382,20 +2205,26 @@ constexpr bool StaticAssertTypeEq() noexcept {
 //     EXPECT_EQ(a_.size(), 0);
 //     EXPECT_EQ(b_.size(), 1);
 //   }
-//
-// GOOGLETEST_CM0011 DO NOT DELETE
-#if !GTEST_DONT_DEFINE_TEST
-#define TEST_F(test_fixture, test_name)\
+#define GTEST_TEST_F(test_fixture, test_name)        \
   GTEST_TEST_(test_fixture, test_name, test_fixture, \
               ::testing::internal::GetTypeId<test_fixture>())
-#endif  // !GTEST_DONT_DEFINE_TEST
+#if !GTEST_DONT_DEFINE_TEST_F
+#define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
+#endif
 
-// Returns a path to temporary directory.
-// Tries to determine an appropriate directory for the platform.
+// Returns a path to a temporary directory, which should be writable. It is
+// implementation-dependent whether or not the path is terminated by the
+// directory-separator character.
 GTEST_API_ std::string TempDir();
 
+// Returns a path to a directory that contains ancillary data files that might
+// be used by tests. It is implementation dependent whether or not the path is
+// terminated by the directory-separator character. The directory and the files
+// in it should be considered read-only.
+GTEST_API_ std::string SrcDir();
+
 #ifdef _MSC_VER
-#  pragma warning(pop)
+#pragma warning(pop)
 #endif
 
 // Dynamically registers a test with the framework.
@@ -2449,6 +2278,7 @@ GTEST_API_ std::string TempDir();
 // }
 // ...
 // int main(int argc, char** argv) {
+//   ::testing::InitGoogleTest(&argc, argv);
 //   std::vector<int> values_to_test = LoadValuesFromConfig();
 //   RegisterMyTests(values_to_test);
 //   ...
@@ -2490,9 +2320,7 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
 // namespace and has an all-caps name.
 int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
 
-inline int RUN_ALL_TESTS() {
-  return ::testing::UnitTest::GetInstance()->Run();
-}
+inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); }
 
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 
diff --git a/googletest/googletest/include/gtest/gtest_pred_impl.h b/googletest/googletest/include/gtest/gtest_pred_impl.h
index 5029a9bb02ada740f9ee3eee6a5281d6e9593aed..47a24aa687af6ebfed8423bee7802192e73d97ac 100644
--- a/googletest/googletest/include/gtest/gtest_pred_impl.h
+++ b/googletest/googletest/include/gtest/gtest_pred_impl.h
@@ -26,17 +26,19 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
 //
 // Implements a family of generic predicate assertion macros.
-// GOOGLETEST_CM0001 DO NOT DELETE
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
 
-#include "gtest/gtest.h"
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
 
 namespace testing {
 
@@ -72,22 +74,18 @@ namespace testing {
 // GTEST_ASSERT_ is the basic statement to which all of the assertions
 // in this file reduce.  Don't use this in your code.
 
-#define GTEST_ASSERT_(expression, on_failure) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+#define GTEST_ASSERT_(expression, on_failure)                   \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                 \
   if (const ::testing::AssertionResult gtest_ar = (expression)) \
-    ; \
-  else \
+    ;                                                           \
+  else                                                          \
     on_failure(gtest_ar.failure_message())
 
-
 // Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
 // this in your code.
-template <typename Pred,
-          typename T1>
-AssertionResult AssertPred1Helper(const char* pred_text,
-                                  const char* e1,
-                                  Pred pred,
-                                  const T1& v1) {
+template <typename Pred, typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text, const char* e1,
+                                  Pred pred, const T1& v1) {
   if (pred(v1)) return AssertionSuccess();
 
   return AssertionFailure()
@@ -98,40 +96,27 @@ AssertionResult AssertPred1Helper(const char* pred_text,
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
 // Don't use this in your code.
-#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, v1), \
-                on_failure)
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \
+  GTEST_ASSERT_(pred_format(#v1, v1), on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
 // this in your code.
-#define GTEST_PRED1_(pred, v1, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
-                                             #v1, \
-                                             pred, \
-                                             v1), on_failure)
+#define GTEST_PRED1_(pred, v1, on_failure) \
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, #v1, pred, v1), on_failure)
 
 // Unary predicate assertion macros.
 #define EXPECT_PRED_FORMAT1(pred_format, v1) \
   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
-#define EXPECT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
 #define ASSERT_PRED_FORMAT1(pred_format, v1) \
   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
-#define ASSERT_PRED1(pred, v1) \
-  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
-
-
+#define ASSERT_PRED1(pred, v1) GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
 
 // Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
 // this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2>
-AssertionResult AssertPred2Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  Pred pred,
-                                  const T1& v1,
+template <typename Pred, typename T1, typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text, const char* e1,
+                                  const char* e2, Pred pred, const T1& v1,
                                   const T2& v2) {
   if (pred(v1, v2)) return AssertionSuccess();
 
@@ -145,19 +130,14 @@ AssertionResult AssertPred2Helper(const char* pred_text,
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
 // Don't use this in your code.
-#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
-                on_failure)
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
 // this in your code.
-#define GTEST_PRED2_(pred, v1, v2, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             pred, \
-                                             v1, \
-                                             v2), on_failure)
+#define GTEST_PRED2_(pred, v1, v2, on_failure)                               \
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, #v1, #v2, pred, v1, v2), \
+                on_failure)
 
 // Binary predicate assertion macros.
 #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
@@ -169,22 +149,12 @@ AssertionResult AssertPred2Helper(const char* pred_text,
 #define ASSERT_PRED2(pred, v1, v2) \
   GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
 
-
-
 // Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
 // this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3>
-AssertionResult AssertPred3Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3) {
+template <typename Pred, typename T1, typename T2, typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text, const char* e1,
+                                  const char* e2, const char* e3, Pred pred,
+                                  const T1& v1, const T2& v2, const T3& v3) {
   if (pred(v1, v2, v3)) return AssertionSuccess();
 
   return AssertionFailure()
@@ -198,21 +168,15 @@ AssertionResult AssertPred3Helper(const char* pred_text,
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
 // Don't use this in your code.
-#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
-                on_failure)
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure) \
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
 // this in your code.
-#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3), on_failure)
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)                          \
+  GTEST_ASSERT_(                                                            \
+      ::testing::AssertPred3Helper(#pred, #v1, #v2, #v3, pred, v1, v2, v3), \
+      on_failure)
 
 // Ternary predicate assertion macros.
 #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
@@ -224,25 +188,13 @@ AssertionResult AssertPred3Helper(const char* pred_text,
 #define ASSERT_PRED3(pred, v1, v2, v3) \
   GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
 
-
-
 // Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
 // this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4>
-AssertionResult AssertPred4Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4) {
+template <typename Pred, typename T1, typename T2, typename T3, typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text, const char* e1,
+                                  const char* e2, const char* e3,
+                                  const char* e4, Pred pred, const T1& v1,
+                                  const T2& v2, const T3& v3, const T4& v4) {
   if (pred(v1, v2, v3, v4)) return AssertionSuccess();
 
   return AssertionFailure()
@@ -257,23 +209,15 @@ AssertionResult AssertPred4Helper(const char* pred_text,
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
 // Don't use this in your code.
-#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
-                on_failure)
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure) \
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
 // this in your code.
-#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4), on_failure)
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)                        \
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, #v1, #v2, #v3, #v4, pred, \
+                                             v1, v2, v3, v4),                 \
+                on_failure)
 
 // 4-ary predicate assertion macros.
 #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
@@ -285,28 +229,15 @@ AssertionResult AssertPred4Helper(const char* pred_text,
 #define ASSERT_PRED4(pred, v1, v2, v3, v4) \
   GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
 
-
-
 // Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
 // this in your code.
-template <typename Pred,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
+template <typename Pred, typename T1, typename T2, typename T3, typename T4,
           typename T5>
-AssertionResult AssertPred5Helper(const char* pred_text,
-                                  const char* e1,
-                                  const char* e2,
-                                  const char* e3,
-                                  const char* e4,
-                                  const char* e5,
-                                  Pred pred,
-                                  const T1& v1,
-                                  const T2& v2,
-                                  const T3& v3,
-                                  const T4& v4,
-                                  const T5& v5) {
+AssertionResult AssertPred5Helper(const char* pred_text, const char* e1,
+                                  const char* e2, const char* e3,
+                                  const char* e4, const char* e5, Pred pred,
+                                  const T1& v1, const T2& v2, const T3& v3,
+                                  const T4& v4, const T5& v5) {
   if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
 
   return AssertionFailure()
@@ -322,25 +253,16 @@ AssertionResult AssertPred5Helper(const char* pred_text,
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
 // Don't use this in your code.
-#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)  \
   GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
                 on_failure)
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
 // this in your code.
-#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
-  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
-                                             #v1, \
-                                             #v2, \
-                                             #v3, \
-                                             #v4, \
-                                             #v5, \
-                                             pred, \
-                                             v1, \
-                                             v2, \
-                                             v3, \
-                                             v4, \
-                                             v5), on_failure)
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)                   \
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, #v1, #v2, #v3, #v4, #v5, \
+                                             pred, v1, v2, v3, v4, v5),      \
+                on_failure)
 
 // 5-ary predicate assertion macros.
 #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
@@ -352,8 +274,6 @@ AssertionResult AssertPred5Helper(const char* pred_text,
 #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
   GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
 
-
-
 }  // namespace testing
 
 #endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/googletest/googletest/include/gtest/gtest_prod.h b/googletest/googletest/include/gtest/gtest_prod.h
index 38b9d85a51efb747feb969a5cdcadb1c27b2f87e..1f37dc31c347228e21f2474e1dbf0aed6b988189 100644
--- a/googletest/googletest/include/gtest/gtest_prod.h
+++ b/googletest/googletest/include/gtest/gtest_prod.h
@@ -27,9 +27,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-//
-// Google C++ Testing and Mocking Framework definitions useful in production code.
-// GOOGLETEST_CM0003 DO NOT DELETE
+// Google C++ Testing and Mocking Framework definitions useful in production
+// code.
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
@@ -55,7 +54,7 @@
 // Note: The test class must be in the same namespace as the class being tested.
 // For example, putting MyClassTest in an anonymous namespace will not work.
 
-#define FRIEND_TEST(test_case_name, test_name)\
-friend class test_case_name##_##test_name##_Test
+#define FRIEND_TEST(test_case_name, test_name) \
+  friend class test_case_name##_##test_name##_Test
 
 #endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/googletest/googletest/include/gtest/hwext/gtest-multithread.h b/googletest/googletest/include/gtest/hwext/gtest-multithread.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7254e6595ad929049079fc7caa39833a36ba946
--- /dev/null
+++ b/googletest/googletest/include/gtest/hwext/gtest-multithread.h
@@ -0,0 +1,117 @@
+/*
+* Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.
+* Description:多线程测试框架(GTEST-MULTITHREAD)库接口声明
+* Author:
+* Create:2023/2/24
+*/
+
+#ifndef __MULTI_THREAD_TEST_H__
+#define __MULTI_THREAD_TEST_H__
+
+#include <vector>
+#include <string>
+#include <map>
+#include <thread>
+#include "gtest/gtest.h"
+
+using ::testing::TestPartResult;
+
+namespace testing{
+    namespace mt {
+        using PF = void(*)();
+        using uint = unsigned int;
+        const uint RANDOM_THREAD_ID = 0x3f3f3f3f; //线程ID常量
+        static uint g_thread_count = 10 ; //全局变量,默认线程数是10
+        inline void setThreadNum(uint num)
+        {
+            g_thread_count = num;
+        }
+        class TestTask {
+        public:
+            TestTask() = default;
+            TestTask(std::string ts, std::string tc, PF func) : m_testsuite(ts), m_testcase(tc), m_func(func){}
+            std::string m_testsuite;
+            std::string m_testcase;
+            PF m_func;
+        };
+        class ThreadTaskEntry {
+        public:
+            ThreadTaskEntry(std::vector<TestTask> v_task) : funcList(v_task) {}
+            std::thread *thread;
+            std::vector<TestTask> funcList; 
+        };
+        class MultiThreadTest {
+        private:
+            std::vector<std::vector<TestTask>> threadTasks;
+            std::vector<ThreadTaskEntry> threadTestEntryList;
+            std::map<std::string, std::vector<TestTask>> randomTasks;
+
+        public:
+            void doTest();
+            void run();
+            MultiThreadTest() {}
+            unsigned m_threadNum;
+            MultiThreadTest(unsigned int t_cnt) : m_threadNum(t_cnt) {}
+            uint runTask(unsigned thread_num, PF func, std::string testsuite, std::string testcase);
+            void appendTaskToList(unsigned thread_id, PF func, std::string testsuite, std::string testcase);
+        };
+
+        static MultiThreadTest testInstance;
+        static MultiThreadTest *getMTestSingleton() 
+        {
+            return &testInstance;
+        }
+
+        inline void getMTest()
+        {
+            auto ret = getMTestSingleton();
+            if (ret == nullptr) {
+                return;
+            }
+        }
+
+        class MultiThreadFailCaseListener : public EmptyTestEventListener {
+        private:
+            MultiThreadTest *testInstance;
+        public:
+            MultiThreadFailCaseListener(MultiThreadTest *ins)
+            { 
+                this->testInstance = ins; 
+            }
+        };
+
+        inline void addPostTest(unsigned thread_id, PF func, std::string testsuite = "NA", std::string testcase = "NA")
+        {
+            for (unsigned int i = 0; i < g_thread_count; i++) {
+                testInstance.appendTaskToList(thread_id, func, testsuite, testcase);
+            }
+        }
+
+        #define MTEST_ADD_TASK(thread_id, func) addPostTest(thread_id, func)
+
+        #define MTEST_POST_RUN()            \
+            do {                            \
+                getMTestSingleton()->run(); \
+            } while (0)
+
+        #define SET_THREAD_NUM(n) setThreadNum(n) 
+        #define MTEST_FUNC_NAME(x, y) TC_##x_##y
+        #define GTEST_RUN_TASK(hook) \
+        do { \
+            MultiThreadTest _test(g_thread_count);        \
+            _test.runTask(_test.m_threadNum, hook, this->test_info_->test_case_name(), this->test_info_->name()); \
+        } while (0)
+
+        #define MTEST_TYPE(x, y, z, n)                      \
+            void MTEST_FUNC_NAME(x, y)();                   \
+            z(x, y)                                         \
+            {                                               \
+                 SET_THREAD_NUM(n);                         \
+                 GTEST_RUN_TASK(MTEST_FUNC_NAME(x, y));     \
+            }                                               \
+            void MTEST_FUNC_NAME(x, y)()
+        #define HWMTEST(x, y, w, n) MTEST_TYPE(x, y, TEST, n)
+        #define HWMTEST_F(x, y, w, n) MTEST_TYPE(x, y, TEST_F, n)
+    }
+}
+#endif /* __MULTI_THREAD_TEST_H__ */
\ No newline at end of file
diff --git a/googletest/googletest/include/gtest/hwext/gtest-tag.h b/googletest/googletest/include/gtest/hwext/gtest-tag.h
index ad33a30c86940cbc340dfd99670666849e8b11fa..e9b9f4d68f9ac41484cda999701a6e6208925875 100644
--- a/googletest/googletest/include/gtest/hwext/gtest-tag.h
+++ b/googletest/googletest/include/gtest/hwext/gtest-tag.h
@@ -4,6 +4,7 @@
 #define GTEST_INCLUDE_GTEST_GTEST_TAG_H_
 
 #include <string.h>
+#include <string>
 #include <map>
 #include <vector>
 
diff --git a/googletest/googletest/include/gtest/internal/custom/README.md b/googletest/googletest/include/gtest/internal/custom/README.md
index ff391fb4e2b5765cac8c6943359b15bbd5f4f149..cb49e2c754c250ed975e371551267b938ebcdfa1 100644
--- a/googletest/googletest/include/gtest/internal/custom/README.md
+++ b/googletest/googletest/include/gtest/internal/custom/README.md
@@ -15,18 +15,6 @@ The custom directory is an injection point for custom user configurations.
 
 The following macros can be defined:
 
-### Flag related macros:
-
-*   `GTEST_FLAG(flag_name)`
-*   `GTEST_USE_OWN_FLAGFILE_FLAG_` - Define to 0 when the system provides its
-    own flagfile flag parsing.
-*   `GTEST_DECLARE_bool_(name)`
-*   `GTEST_DECLARE_int32_(name)`
-*   `GTEST_DECLARE_string_(name)`
-*   `GTEST_DEFINE_bool_(name, default_val, doc)`
-*   `GTEST_DEFINE_int32_(name, default_val, doc)`
-*   `GTEST_DEFINE_string_(name, default_val, doc)`
-
 ### Logging:
 
 *   `GTEST_LOG_(severity)`
diff --git a/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h b/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
index 490296dfad2d00c4811eb49126ab2656961c778d..4687dae2b46af65c80ea75dc93455037f50e6b6b 100644
--- a/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -26,27 +26,32 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines internal utilities needed for implementing
 // death tests.  They are subject to change without notice.
-// GOOGLETEST_CM0001 DO NOT DELETE
+
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
 
+#include <stdio.h>
+
+#include <memory>
+#include <string>
+
 #include "gtest/gtest-matchers.h"
 #include "gtest/internal/gtest-internal.h"
 
-#include <stdio.h>
-#include <memory>
+GTEST_DECLARE_string_(internal_run_death_test);
 
 namespace testing {
 namespace internal {
 
-GTEST_DECLARE_string_(internal_run_death_test);
-
 // Names of the flags (needed for parsing Google Test flags).
 const char kDeathTestStyleFlag[] = "death_test_style";
 const char kDeathTestUseFork[] = "death_test_use_fork";
@@ -83,17 +88,19 @@ class GTEST_API_ DeathTest {
   static bool Create(const char* statement, Matcher<const std::string&> matcher,
                      const char* file, int line, DeathTest** test);
   DeathTest();
-  virtual ~DeathTest() { }
+  virtual ~DeathTest() {}
 
   // A helper class that aborts a death test when it's deleted.
   class ReturnSentinel {
    public:
-    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    explicit ReturnSentinel(DeathTest* test) : test_(test) {}
     ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+
    private:
     DeathTest* const test_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
-  } GTEST_ATTRIBUTE_UNUSED_;
+    ReturnSentinel(const ReturnSentinel&) = delete;
+    ReturnSentinel& operator=(const ReturnSentinel&) = delete;
+  };
 
   // An enumeration of possible roles that may be taken when a death
   // test is encountered.  EXECUTE means that the death test logic should
@@ -137,7 +144,8 @@ class GTEST_API_ DeathTest {
   // A string containing a description of the outcome of the last death test.
   static std::string last_death_test_message_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+  DeathTest(const DeathTest&) = delete;
+  DeathTest& operator=(const DeathTest&) = delete;
 };
 
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
@@ -145,7 +153,7 @@ GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 // Factory interface for death tests.  May be mocked out for testing.
 class DeathTestFactory {
  public:
-  virtual ~DeathTestFactory() { }
+  virtual ~DeathTestFactory() {}
   virtual bool Create(const char* statement,
                       Matcher<const std::string&> matcher, const char* file,
                       int line, DeathTest** test) = 0;
@@ -186,28 +194,28 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
 
 // Traps C++ exceptions escaping statement and reports them as test
 // failures. Note that trapping SEH exceptions is not implemented here.
-# if GTEST_HAS_EXCEPTIONS
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
-  try { \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-  } catch (const ::std::exception& gtest_exception) { \
-    fprintf(\
-        stderr, \
-        "\n%s: Caught std::exception-derived exception escaping the " \
-        "death test statement. Exception message: %s\n", \
+#if GTEST_HAS_EXCEPTIONS
+#define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test)           \
+  try {                                                                      \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
+  } catch (const ::std::exception& gtest_exception) {                        \
+    fprintf(                                                                 \
+        stderr,                                                              \
+        "\n%s: Caught std::exception-derived exception escaping the "        \
+        "death test statement. Exception message: %s\n",                     \
         ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
-        gtest_exception.what()); \
-    fflush(stderr); \
+        gtest_exception.what());                                             \
+    fflush(stderr);                                                          \
     death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
-  } catch (...) { \
+  } catch (...) {                                                            \
     death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
   }
 
-# else
-#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+#else
+#define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
 
-# endif
+#endif
 
 // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
 // ASSERT_EXIT*, and EXPECT_EXIT*.
@@ -236,8 +244,6 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
           gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
           break;                                                               \
         }                                                                      \
-        default:                                                               \
-          break;                                                               \
       }                                                                        \
     }                                                                          \
   } else                                                                       \
@@ -265,16 +271,12 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
 // RUN_ALL_TESTS was called.
 class InternalRunDeathTestFlag {
  public:
-  InternalRunDeathTestFlag(const std::string& a_file,
-                           int a_line,
-                           int an_index,
+  InternalRunDeathTestFlag(const std::string& a_file, int a_line, int an_index,
                            int a_write_fd)
-      : file_(a_file), line_(a_line), index_(an_index),
-        write_fd_(a_write_fd) {}
+      : file_(a_file), line_(a_line), index_(an_index), write_fd_(a_write_fd) {}
 
   ~InternalRunDeathTestFlag() {
-    if (write_fd_ >= 0)
-      posix::Close(write_fd_);
+    if (write_fd_ >= 0) posix::Close(write_fd_);
   }
 
   const std::string& file() const { return file_; }
@@ -288,7 +290,8 @@ class InternalRunDeathTestFlag {
   int index_;
   int write_fd_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+  InternalRunDeathTestFlag(const InternalRunDeathTestFlag&) = delete;
+  InternalRunDeathTestFlag& operator=(const InternalRunDeathTestFlag&) = delete;
 };
 
 // Returns a newly created InternalRunDeathTestFlag object with fields
diff --git a/googletest/googletest/include/gtest/internal/gtest-filepath.h b/googletest/googletest/include/gtest/internal/gtest-filepath.h
index 0c033abc34e0036f39d582366ebe46cb66f2680c..5189c81dabfa6687f362e6bcafc2662e3dec3196 100644
--- a/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ b/googletest/googletest/include/gtest/internal/gtest-filepath.h
@@ -26,7 +26,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // Google Test filepath utilities
 //
 // This header file declares classes and functions used internally by
@@ -35,16 +35,23 @@
 // This file is #included in gtest/internal/gtest-internal.h.
 // Do not include this header file separately!
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
 
+#include <string>
+
+#include "gtest/internal/gtest-port.h"
 #include "gtest/internal/gtest-string.h"
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
 
+#if GTEST_HAS_FILE_SYSTEM
+
 namespace testing {
 namespace internal {
 
@@ -61,8 +68,8 @@ namespace internal {
 
 class GTEST_API_ FilePath {
  public:
-  FilePath() : pathname_("") { }
-  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+  FilePath() : pathname_("") {}
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
 
   explicit FilePath(const std::string& pathname) : pathname_(pathname) {
     Normalize();
@@ -73,9 +80,7 @@ class GTEST_API_ FilePath {
     return *this;
   }
 
-  void Set(const FilePath& rhs) {
-    pathname_ = rhs.pathname_;
-  }
+  void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }
 
   const std::string& string() const { return pathname_; }
   const char* c_str() const { return pathname_.c_str(); }
@@ -88,8 +93,7 @@ class GTEST_API_ FilePath {
   // than zero (e.g., 12), returns "dir/test_12.xml".
   // On Windows platform, uses \ as the separator rather than /.
   static FilePath MakeFileName(const FilePath& directory,
-                               const FilePath& base_name,
-                               int number,
+                               const FilePath& base_name, int number,
                                const char* extension);
 
   // Given directory = "dir", relative_path = "test.xml",
@@ -200,6 +204,16 @@ class GTEST_API_ FilePath {
   // separators. Returns NULL if no path separator was found.
   const char* FindLastPathSeparator() const;
 
+  // Returns the length of the path root, including the directory separator at
+  // the end of the prefix. Returns zero by definition if the path is relative.
+  // Examples:
+  // - [Windows] "..\Sibling" => 0
+  // - [Windows] "\Windows" => 1
+  // - [Windows] "C:/Windows\Notepad.exe" => 3
+  // - [Windows] "\\Host\Share\C$/Windows" => 13
+  // - [UNIX] "/bin" => 1
+  size_t CalculateRootLength() const;
+
   std::string pathname_;
 };  // class FilePath
 
@@ -208,4 +222,6 @@ class GTEST_API_ FilePath {
 
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 
+#endif  // GTEST_HAS_FILE_SYSTEM
+
 #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/googletest/googletest/include/gtest/internal/gtest-internal.h b/googletest/googletest/include/gtest/internal/gtest-internal.h
index f8cbdbd81d9a4c6be040c47fdd8dc8622df061cd..3121d428b398447602b495599b0c5f4a12a74d1d 100644
--- a/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ b/googletest/googletest/include/gtest/internal/gtest-internal.h
@@ -26,13 +26,15 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file declares functions and macros used internally by
 // Google Test.  They are subject to change without notice.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
@@ -40,26 +42,29 @@
 #include "gtest/internal/gtest-port.h"
 
 #if GTEST_OS_LINUX
-# include <stdlib.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
 #endif  // GTEST_OS_LINUX
 
 #if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
+#include <stdexcept>
 #endif
 
 #include <ctype.h>
 #include <float.h>
 #include <string.h>
+
 #include <cstdint>
+#include <functional>
 #include <iomanip>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "gtest/gtest-message.h"
@@ -76,7 +81,7 @@
 // the current line number.  For more details, see
 // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
-#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo##bar
 
 // Stringifies its argument.
 // Work around a bug in visual studio which doesn't accept code like this:
@@ -98,21 +103,21 @@ namespace testing {
 
 // Forward declarations.
 
-class AssertionResult;                 // Result of an assertion.
-class Message;                         // Represents a failure message.
-class Test;                            // Represents a test.
-class TestInfo;                        // Information about a test.
-class TestPartResult;                  // Result of a test part.
-class UnitTest;                        // A collection of test suites.
+class AssertionResult;  // Result of an assertion.
+class Message;          // Represents a failure message.
+class Test;             // Represents a test.
+class TestInfo;         // Information about a test.
+class TestPartResult;   // Result of a test part.
+class UnitTest;         // A collection of test suites.
 
 template <typename T>
 ::std::string PrintToString(const T& value);
 
 namespace internal {
 
-struct TraceInfo;                      // Information about a trace point.
-class TestInfoImpl;                    // Opaque implementation of TestInfo
-class UnitTestImpl;                    // Opaque implementation of UnitTest
+struct TraceInfo;    // Information about a trace point.
+class TestInfoImpl;  // Opaque implementation of TestInfo
+class UnitTestImpl;  // Opaque implementation of UnitTest
 
 // The text used in failure messages to indicate the start of the
 // stack trace.
@@ -121,6 +126,7 @@ GTEST_API_ extern const char kStackTraceMarker[];
 // An IgnoredValue object can be implicitly constructed from ANY value.
 class IgnoredValue {
   struct Sink {};
+
  public:
   // This constructor template allows any value to be implicitly
   // converted to IgnoredValue.  The object has no data member and
@@ -136,13 +142,13 @@ class IgnoredValue {
 };
 
 // Appends the user-supplied message to the Google-Test-generated message.
-GTEST_API_ std::string AppendUserMessage(
-    const std::string& gtest_msg, const Message& user_msg);
+GTEST_API_ std::string AppendUserMessage(const std::string& gtest_msg,
+                                         const Message& user_msg);
 
 #if GTEST_HAS_EXCEPTIONS
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
-/* an exported class was derived from a class that was not exported */)
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4275 /* an exported class was derived from a class that was not exported */)
 
 // This exception is thrown by (and only by) a failed Google Test
 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
@@ -181,14 +187,6 @@ GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
 
 }  // namespace edit_distance
 
-// Calculate the diff between 'left' and 'right' and return it in unified diff
-// format.
-// If not null, stores in 'total_line_count' the total number of lines found
-// in left + right.
-GTEST_API_ std::string DiffStrings(const std::string& left,
-                                   const std::string& right,
-                                   size_t* total_line_count);
-
 // Constructs and returns the message for an equality assertion
 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
 //
@@ -212,10 +210,8 @@ GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
 
 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
 GTEST_API_ std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value);
+    const AssertionResult& assertion_result, const char* expression_text,
+    const char* actual_predicate_value, const char* expected_predicate_value);
 
 // This template class represents an IEEE floating-point number
 // (either single-precision or double-precision, depending on the
@@ -256,11 +252,11 @@ class FloatingPoint {
   // Constants.
 
   // # of bits in a number.
-  static const size_t kBitCount = 8*sizeof(RawType);
+  static const size_t kBitCount = 8 * sizeof(RawType);
 
   // # of fraction bits in a number.
   static const size_t kFractionBitCount =
-    std::numeric_limits<RawType>::digits - 1;
+      std::numeric_limits<RawType>::digits - 1;
 
   // # of exponent bits in a number.
   static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
@@ -269,8 +265,8 @@ class FloatingPoint {
   static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
 
   // The mask for the fraction bits.
-  static const Bits kFractionBitMask =
-    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+  static const Bits kFractionBitMask = ~static_cast<Bits>(0) >>
+                                       (kExponentBitCount + 1);
 
   // The mask for the exponent bits.
   static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
@@ -309,9 +305,7 @@ class FloatingPoint {
   }
 
   // Returns the floating-point number that represent positive infinity.
-  static RawType Infinity() {
-    return ReinterpretBits(kExponentBitMask);
-  }
+  static RawType Infinity() { return ReinterpretBits(kExponentBitMask); }
 
   // Returns the maximum representable finite floating-point number.
   static RawType Max();
@@ -319,7 +313,7 @@ class FloatingPoint {
   // Non-static methods
 
   // Returns the bits that represents this number.
-  const Bits &bits() const { return u_.bits_; }
+  const Bits& bits() const { return u_.bits_; }
 
   // Returns the exponent bits of this number.
   Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
@@ -348,8 +342,8 @@ class FloatingPoint {
     // a NAN must return false.
     if (is_nan() || rhs.is_nan()) return false;
 
-    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
-        <= kMaxUlps;
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <=
+           kMaxUlps;
   }
 
  private:
@@ -374,7 +368,7 @@ class FloatingPoint {
   //
   // Read http://en.wikipedia.org/wiki/Signed_number_representations
   // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+  static Bits SignAndMagnitudeToBiased(const Bits& sam) {
     if (kSignBitMask & sam) {
       // sam represents a negative number.
       return ~sam + 1;
@@ -386,8 +380,8 @@ class FloatingPoint {
 
   // Given two numbers in the sign-and-magnitude representation,
   // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
-                                                     const Bits &sam2) {
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits& sam1,
+                                                     const Bits& sam2) {
     const Bits biased1 = SignAndMagnitudeToBiased(sam1);
     const Bits biased2 = SignAndMagnitudeToBiased(sam2);
     return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
@@ -399,9 +393,13 @@ class FloatingPoint {
 // We cannot use std::numeric_limits<T>::max() as it clashes with the max()
 // macro defined by <windows.h>.
 template <>
-inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+inline float FloatingPoint<float>::Max() {
+  return FLT_MAX;
+}
 template <>
-inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+inline double FloatingPoint<double>::Max() {
+  return DBL_MAX;
+}
 
 // Typedefs the instances of the FloatingPoint template class that we
 // care to use.
@@ -461,10 +459,11 @@ class TestFactoryBase {
   TestFactoryBase() {}
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+  TestFactoryBase(const TestFactoryBase&) = delete;
+  TestFactoryBase& operator=(const TestFactoryBase&) = delete;
 };
 
-// This class provides implementation of TeastFactoryBase interface.
+// This class provides implementation of TestFactoryBase interface.
 // It is used in TEST and TEST_F macros.
 template <class TestClass>
 class TestFactoryImpl : public TestFactoryBase {
@@ -510,11 +509,11 @@ inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
 
 template <typename T>
 //  Note that SuiteApiResolver inherits from T because
-//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
+//  SetUpTestSuite()/TearDownTestSuite() could be protected. This way
 //  SuiteApiResolver can access them.
 struct SuiteApiResolver : T {
   // testing::Test is only forward declared at this point. So we make it a
-  // dependend class for the compiler to be OK with it.
+  // dependent class for the compiler to be OK with it.
   using Test =
       typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
 
@@ -634,7 +633,7 @@ class GTEST_API_ TypedTestSuitePState {
                                         const char* registered_tests);
 
  private:
-  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+  typedef ::std::map<std::string, CodeLocation, std::less<>> RegisteredTestsMap;
 
   bool registered_;
   RegisteredTestsMap registered_tests_;
@@ -654,7 +653,8 @@ inline const char* SkipComma(const char* str) {
   if (comma == nullptr) {
     return nullptr;
   }
-  while (IsSpace(*(++comma))) {}
+  while (IsSpace(*(++comma))) {
+  }
   return comma;
 }
 
@@ -668,7 +668,7 @@ inline std::string GetPrefixUntilComma(const char* str) {
 // Splits a given string on a given delimiter, populating a given
 // vector with the fields.
 void SplitString(const ::std::string& str, char delimiter,
-                 ::std::vector< ::std::string>* dest);
+                 ::std::vector<::std::string>* dest);
 
 // The default argument to the template below for the case when the user does
 // not provide a name generator.
@@ -781,13 +781,13 @@ class TypeParameterizedTestSuite {
                        const std::vector<std::string>& type_names =
                            GenerateNames<DefaultNameGenerator, Types>()) {
     RegisterTypeParameterizedTestSuiteInstantiation(case_name);
-    std::string test_name = StripTrailingSpaces(
-        GetPrefixUntilComma(test_names));
+    std::string test_name =
+        StripTrailingSpaces(GetPrefixUntilComma(test_names));
     if (!state->TestExists(test_name)) {
       fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
               case_name, test_name.c_str(),
-              FormatFileLocation(code_location.file.c_str(),
-                                 code_location.line).c_str());
+              FormatFileLocation(code_location.file.c_str(), code_location.line)
+                  .c_str());
       fflush(stderr);
       posix::Abort();
     }
@@ -831,8 +831,7 @@ class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
 // For example, if Foo() calls Bar(), which in turn calls
 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
-    UnitTest* unit_test, int skip_count);
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(int skip_count);
 
 // Helpers for suppressing warnings on unreachable code or constant
 // condition.
@@ -881,7 +880,8 @@ class GTEST_API_ Random {
 
  private:
   uint32_t state_;
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+  Random(const Random&) = delete;
+  Random& operator=(const Random&) = delete;
 };
 
 // Turns const U&, U&, const U, and U all into U.
@@ -954,7 +954,9 @@ IsContainer IsContainerTest(int /* dummy */) {
 
 typedef char IsNotContainer;
 template <class C>
-IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+IsNotContainer IsContainerTest(long /* dummy */) {
+  return '\0';
+}
 
 // Trait to detect whether a type T is a hash table.
 // The heuristic used is that the type contains an inner type `hasher` and does
@@ -1017,11 +1019,13 @@ bool ArrayEq(const T* lhs, size_t size, const U* rhs);
 
 // This generic version is used when k is 0.
 template <typename T, typename U>
-inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+inline bool ArrayEq(const T& lhs, const U& rhs) {
+  return lhs == rhs;
+}
 
 // This overload is used when k >= 1.
 template <typename T, typename U, size_t N>
-inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+inline bool ArrayEq(const T (&lhs)[N], const U (&rhs)[N]) {
   return internal::ArrayEq(lhs, N, rhs);
 }
 
@@ -1031,8 +1035,7 @@ inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
 template <typename T, typename U>
 bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
   for (size_t i = 0; i != size; i++) {
-    if (!internal::ArrayEq(lhs[i], rhs[i]))
-      return false;
+    if (!internal::ArrayEq(lhs[i], rhs[i])) return false;
   }
   return true;
 }
@@ -1042,8 +1045,7 @@ bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
 template <typename Iter, typename Element>
 Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
   for (Iter it = begin; it != end; ++it) {
-    if (internal::ArrayEq(*it, elem))
-      return it;
+    if (internal::ArrayEq(*it, elem)) return it;
   }
   return end;
 }
@@ -1057,11 +1059,13 @@ void CopyArray(const T* from, size_t size, U* to);
 
 // This generic version is used when k is 0.
 template <typename T, typename U>
-inline void CopyArray(const T& from, U* to) { *to = from; }
+inline void CopyArray(const T& from, U* to) {
+  *to = from;
+}
 
 // This overload is used when k >= 1.
 template <typename T, typename U, size_t N>
-inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+inline void CopyArray(const T (&from)[N], U (*to)[N]) {
   internal::CopyArray(from, N, *to);
 }
 
@@ -1114,8 +1118,7 @@ class NativeArray {
   }
 
   ~NativeArray() {
-    if (clone_ != &NativeArray::InitRef)
-      delete[] array_;
+    if (clone_ != &NativeArray::InitRef) delete[] array_;
   }
 
   // STL-style container methods.
@@ -1123,8 +1126,7 @@ class NativeArray {
   const_iterator begin() const { return array_; }
   const_iterator end() const { return array_ + size_; }
   bool operator==(const NativeArray& rhs) const {
-    return size() == rhs.size() &&
-        ArrayEq(begin(), size(), rhs.begin());
+    return size() == rhs.size() && ArrayEq(begin(), size(), rhs.begin());
   }
 
  private:
@@ -1335,9 +1337,9 @@ struct tuple_size<testing::internal::FlatTuple<Ts...>>
 #endif
 }  // namespace std
 
-#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
-  ::testing::internal::AssertHelper(result_type, file, line, message) \
-    = ::testing::Message()
+#define GTEST_MESSAGE_AT_(file, line, message, result_type)             \
+  ::testing::internal::AssertHelper(result_type, file, line, message) = \
+      ::testing::Message()
 
 #define GTEST_MESSAGE_(message, result_type) \
   GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
@@ -1458,103 +1460,112 @@ class NeverThrown {
 
 #endif  // GTEST_HAS_EXCEPTIONS
 
-#define GTEST_TEST_NO_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::TrueWithString gtest_msg{}) { \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
-    catch (...) { \
-      gtest_msg.value = "it throws."; \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail(("Expected: " #statement " doesn't throw an exception.\n" \
-            "  Actual: " + gtest_msg.value).c_str())
-
-#define GTEST_TEST_ANY_THROW_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
-    bool gtest_caught_any = false; \
-    try { \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    } \
-    catch (...) { \
-      gtest_caught_any = true; \
-    } \
-    if (!gtest_caught_any) { \
+#define GTEST_TEST_NO_THROW_(statement, fail)                            \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                          \
+  if (::testing::internal::TrueWithString gtest_msg{}) {                 \
+    try {                                                                \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);         \
+    }                                                                    \
+    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                           \
+    catch (...) {                                                        \
+      gtest_msg.value = "it throws.";                                    \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__);      \
+    }                                                                    \
+  } else                                                                 \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__)              \
+        : fail(("Expected: " #statement " doesn't throw an exception.\n" \
+                "  Actual: " +                                           \
+                gtest_msg.value)                                         \
+                   .c_str())
+
+#define GTEST_TEST_ANY_THROW_(statement, fail)                       \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                      \
+  if (::testing::internal::AlwaysTrue()) {                           \
+    bool gtest_caught_any = false;                                   \
+    try {                                                            \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);     \
+    } catch (...) {                                                  \
+      gtest_caught_any = true;                                       \
+    }                                                                \
+    if (!gtest_caught_any) {                                         \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
-      fail("Expected: " #statement " throws an exception.\n" \
-           "  Actual: it doesn't.")
-
+    }                                                                \
+  } else                                                             \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__)         \
+        : fail("Expected: " #statement                               \
+               " throws an exception.\n"                             \
+               "  Actual: it doesn't.")
 
 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
 // either a boolean expression or an AssertionResult. text is a textual
 // representation of expression as it was passed into the EXPECT_TRUE.
 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (const ::testing::AssertionResult gtest_ar_ = \
-      ::testing::AssertionResult(expression)) \
-    ; \
-  else \
-    fail(::testing::internal::GetBoolAssertionFailureMessage(\
-        gtest_ar_, text, #actual, #expected).c_str())
-
-#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AlwaysTrue()) { \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                       \
+  if (const ::testing::AssertionResult gtest_ar_ =                    \
+          ::testing::AssertionResult(expression))                     \
+    ;                                                                 \
+  else                                                                \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(         \
+             gtest_ar_, text, #actual, #expected)                     \
+             .c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail)                          \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::internal::AlwaysTrue()) {                                     \
     ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
-    } \
-  } else \
-    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
-      fail("Expected: " #statement " doesn't generate new fatal " \
-           "failures in the current thread.\n" \
-           "  Actual: it does.")
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);                 \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) {                 \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__);            \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__)                    \
+        : fail("Expected: " #statement                                         \
+               " doesn't generate new fatal "                                  \
+               "failures in the current thread.\n"                             \
+               "  Actual: it does.")
 
 // Expands to the name of the class that implements the given test.
 #define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
   test_suite_name##_##test_name##_Test
 
 // Helper macro for defining tests.
-#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
-  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
-                "test_suite_name must not be empty");                         \
-  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
-                "test_name must not be empty");                               \
-  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
-      : public parent_class {                                                 \
-   public:                                                                    \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
-    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
-                                                           test_name));       \
-    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
-                                                           test_name));       \
-                                                                              \
-   private:                                                                   \
-    void TestBody() override;                                                 \
-    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
-  };                                                                          \
-                                                                              \
-  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
-                                                    test_name)::test_info_ =  \
-      ::testing::internal::MakeAndRegisterTestInfo(                           \
-          #test_suite_name, #test_name, nullptr, nullptr,                     \
-          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
-          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
-              test_suite_name, test_name)>);                                  \
+#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)       \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                 \
+                "test_suite_name must not be empty");                          \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                       \
+                "test_name must not be empty");                                \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
+      : public parent_class {                                                  \
+   public:                                                                     \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;            \
+    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default;  \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                         \
+    (const GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &) = delete;     \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=(            \
+        const GTEST_TEST_CLASS_NAME_(test_suite_name,                          \
+                                     test_name) &) = delete; /* NOLINT */      \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                         \
+    (GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &&) noexcept = delete; \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=(            \
+        GTEST_TEST_CLASS_NAME_(test_suite_name,                                \
+                               test_name) &&) noexcept = delete; /* NOLINT */  \
+                                                                               \
+   private:                                                                    \
+    void TestBody() override;                                                  \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;      \
+  };                                                                           \
+                                                                               \
+  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,           \
+                                                    test_name)::test_info_ =   \
+      ::testing::internal::MakeAndRegisterTestInfo(                            \
+          #test_suite_name, #test_name, nullptr, nullptr,                      \
+          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id),  \
+          ::testing::internal::SuiteApiResolver<                               \
+              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),          \
+          ::testing::internal::SuiteApiResolver<                               \
+              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),       \
+          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(     \
+              test_suite_name, test_name)>);                                   \
   void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
 
 #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
diff --git a/googletest/googletest/include/gtest/internal/gtest-param-util.h b/googletest/googletest/include/gtest/internal/gtest-param-util.h
index c2ef6e3124b05f4be2459b62d463b2b910e5c294..7092d10e677c7a47ffea46b064efd5d3b2e85352 100644
--- a/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ b/googletest/googletest/include/gtest/internal/gtest-param-util.h
@@ -27,10 +27,11 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Type and function utilities for implementing parameterized tests.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
@@ -39,26 +40,28 @@
 
 #include <cassert>
 #include <iterator>
+#include <map>
 #include <memory>
+#include <ostream>
 #include <set>
+#include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-port.h"
 #include "gtest/gtest-printers.h"
 #include "gtest/gtest-test-part.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
 
 namespace testing {
 // Input to a parameterized test name generator, describing a test parameter.
 // Consists of the parameter value and the integer parameter index.
 template <class ParamType>
 struct TestParamInfo {
-  TestParamInfo(const ParamType& a_param, size_t an_index) :
-    param(a_param),
-    index(an_index) {}
+  TestParamInfo(const ParamType& a_param, size_t an_index)
+      : param(a_param), index(an_index) {}
   ParamType param;
   size_t index;
 };
@@ -84,8 +87,10 @@ namespace internal {
 GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
                                            CodeLocation code_location);
 
-template <typename> class ParamGeneratorInterface;
-template <typename> class ParamGenerator;
+template <typename>
+class ParamGeneratorInterface;
+template <typename>
+class ParamGenerator;
 
 // Interface for iterating over elements provided by an implementation
 // of ParamGeneratorInterface<T>.
@@ -129,8 +134,7 @@ class ParamIterator {
   // ParamIterator assumes ownership of the impl_ pointer.
   ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
   ParamIterator& operator=(const ParamIterator& other) {
-    if (this != &other)
-      impl_.reset(other.impl_->Clone());
+    if (this != &other) impl_.reset(other.impl_->Clone());
     return *this;
   }
 
@@ -157,7 +161,7 @@ class ParamIterator {
  private:
   friend class ParamGenerator<T>;
   explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
-  std::unique_ptr<ParamIteratorInterface<T> > impl_;
+  std::unique_ptr<ParamIteratorInterface<T>> impl_;
 };
 
 // ParamGeneratorInterface<T> is the binary interface to access generators
@@ -179,7 +183,7 @@ class ParamGeneratorInterface {
 // This class implements copy initialization semantics and the contained
 // ParamGeneratorInterface<T> instance is shared among all copies
 // of the original object. This is possible because that instance is immutable.
-template<typename T>
+template <typename T>
 class ParamGenerator {
  public:
   typedef ParamIterator<T> iterator;
@@ -196,7 +200,7 @@ class ParamGenerator {
   iterator end() const { return iterator(impl_->End()); }
 
  private:
-  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
+  std::shared_ptr<const ParamGeneratorInterface<T>> impl_;
 };
 
 // Generates values from a range of two comparable values. Can be used to
@@ -207,8 +211,10 @@ template <typename T, typename IncrementT>
 class RangeGenerator : public ParamGeneratorInterface<T> {
  public:
   RangeGenerator(T begin, T end, IncrementT step)
-      : begin_(begin), end_(end),
-        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+      : begin_(begin),
+        end_(end),
+        step_(step),
+        end_index_(CalculateEndIndex(begin, end, step)) {}
   ~RangeGenerator() override {}
 
   ParamIteratorInterface<T>* Begin() const override {
@@ -251,7 +257,9 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
    private:
     Iterator(const Iterator& other)
         : ParamIteratorInterface<T>(),
-          base_(other.base_), value_(other.value_), index_(other.index_),
+          base_(other.base_),
+          value_(other.value_),
+          index_(other.index_),
           step_(other.step_) {}
 
     // No implementation - assignment is unsupported.
@@ -263,12 +271,10 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
     const IncrementT step_;
   };  // class RangeGenerator::Iterator
 
-  static int CalculateEndIndex(const T& begin,
-                               const T& end,
+  static int CalculateEndIndex(const T& begin, const T& end,
                                const IncrementT& step) {
     int end_index = 0;
-    for (T i = begin; i < end; i = static_cast<T>(i + step))
-      end_index++;
+    for (T i = begin; i < end; i = static_cast<T>(i + step)) end_index++;
     return end_index;
   }
 
@@ -283,7 +289,6 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
   const int end_index_;
 };  // class RangeGenerator
 
-
 // Generates values from a pair of STL-style iterators. Used in the
 // ValuesIn() function. The elements are copied from the source range
 // since the source can be located on the stack, and the generator
@@ -341,13 +346,13 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
           << "The program attempted to compare iterators "
           << "from different generators." << std::endl;
       return iterator_ ==
-          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+             CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
     }
 
    private:
     Iterator(const Iterator& other)
-          // The explicit constructor call suppresses a false warning
-          // emitted by gcc when supplied with the -Wextra option.
+        // The explicit constructor call suppresses a false warning
+        // emitted by gcc when supplied with the -Wextra option.
         : ParamIteratorInterface<T>(),
           base_(other.base_),
           iterator_(other.iterator_) {}
@@ -394,8 +399,8 @@ template <class TestClass>
 class ParameterizedTestFactory : public TestFactoryBase {
  public:
   typedef typename TestClass::ParamType ParamType;
-  explicit ParameterizedTestFactory(ParamType parameter) :
-      parameter_(parameter) {}
+  explicit ParameterizedTestFactory(ParamType parameter)
+      : parameter_(parameter) {}
   Test* CreateTest() override {
     TestClass::SetParam(&parameter_);
     return new TestClass();
@@ -404,7 +409,8 @@ class ParameterizedTestFactory : public TestFactoryBase {
  private:
   const ParamType parameter_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+  ParameterizedTestFactory(const ParameterizedTestFactory&) = delete;
+  ParameterizedTestFactory& operator=(const ParameterizedTestFactory&) = delete;
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
@@ -440,7 +446,8 @@ class TestMetaFactory
   }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+  TestMetaFactory(const TestMetaFactory&) = delete;
+  TestMetaFactory& operator=(const TestMetaFactory&) = delete;
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
@@ -471,7 +478,10 @@ class ParameterizedTestSuiteInfoBase {
   ParameterizedTestSuiteInfoBase() {}
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
+  ParameterizedTestSuiteInfoBase(const ParameterizedTestSuiteInfoBase&) =
+      delete;
+  ParameterizedTestSuiteInfoBase& operator=(
+      const ParameterizedTestSuiteInfoBase&) = delete;
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
@@ -547,8 +557,8 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
          test_it != tests_.end(); ++test_it) {
       std::shared_ptr<TestInfo> test_info = *test_it;
       for (typename InstantiationContainer::iterator gen_it =
-               instantiations_.begin(); gen_it != instantiations_.end();
-               ++gen_it) {
+               instantiations_.begin();
+           gen_it != instantiations_.end(); ++gen_it) {
         const std::string& instantiation_name = gen_it->name;
         ParamGenerator<ParamType> generator((*gen_it->generator)());
         ParamNameGeneratorFunc* name_func = gen_it->name_func;
@@ -556,7 +566,7 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
         int line = gen_it->line;
 
         std::string test_suite_name;
-        if ( !instantiation_name.empty() )
+        if (!instantiation_name.empty())
           test_suite_name = instantiation_name + "/";
         test_suite_name += test_info->test_suite_base_name;
 
@@ -569,17 +579,16 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
 
           Message test_name_stream;
 
-          std::string param_name = name_func(
-              TestParamInfo<ParamType>(*param_it, i));
+          std::string param_name =
+              name_func(TestParamInfo<ParamType>(*param_it, i));
 
           GTEST_CHECK_(IsValidParamName(param_name))
               << "Parameterized test name '" << param_name
-              << "' is invalid, in " << file
-              << " line " << line << std::endl;
+              << "' is invalid, in " << file << " line " << line << std::endl;
 
           GTEST_CHECK_(test_param_names.count(param_name) == 0)
-              << "Duplicate parameterized test name '" << param_name
-              << "', in " << file << " line " << line << std::endl;
+              << "Duplicate parameterized test name '" << param_name << "', in "
+              << file << " line " << line << std::endl;
 
           test_param_names.insert(param_name);
 
@@ -596,15 +605,15 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
               SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
               test_info->test_meta_factory->CreateTestFactory(*param_it));
         }  // for param_it
-      }  // for gen_it
-    }  // for test_it
+      }    // for gen_it
+    }      // for test_it
 
     if (!generated_instantiations) {
       // There are no generaotrs, or they all generate nothing ...
       InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
                               !tests_.empty());
     }
-  }    // RegisterTests
+  }  // RegisterTests
 
  private:
   // LocalTestInfo structure keeps information about a single test registered
@@ -620,42 +629,39 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
 
     const std::string test_suite_base_name;
     const std::string test_base_name;
-    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+    const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
     const CodeLocation code_location;
   };
-  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
+  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo>>;
   // Records data received from INSTANTIATE_TEST_SUITE_P macros:
   //  <Instantiation name, Sequence generator creation function,
   //     Name generator function, Source file, Source line>
   struct InstantiationInfo {
-      InstantiationInfo(const std::string &name_in,
-                        GeneratorCreationFunc* generator_in,
-                        ParamNameGeneratorFunc* name_func_in,
-                        const char* file_in,
-                        int line_in)
-          : name(name_in),
-            generator(generator_in),
-            name_func(name_func_in),
-            file(file_in),
-            line(line_in) {}
-
-      std::string name;
-      GeneratorCreationFunc* generator;
-      ParamNameGeneratorFunc* name_func;
-      const char* file;
-      int line;
+    InstantiationInfo(const std::string& name_in,
+                      GeneratorCreationFunc* generator_in,
+                      ParamNameGeneratorFunc* name_func_in, const char* file_in,
+                      int line_in)
+        : name(name_in),
+          generator(generator_in),
+          name_func(name_func_in),
+          file(file_in),
+          line(line_in) {}
+
+    std::string name;
+    GeneratorCreationFunc* generator;
+    ParamNameGeneratorFunc* name_func;
+    const char* file;
+    int line;
   };
   typedef ::std::vector<InstantiationInfo> InstantiationContainer;
 
   static bool IsValidParamName(const std::string& name) {
     // Check for empty string
-    if (name.empty())
-      return false;
+    if (name.empty()) return false;
 
     // Check for invalid characters
     for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!IsAlNum(name[index]) && name[index] != '_')
-        return false;
+      if (!IsAlNum(name[index]) && name[index] != '_') return false;
     }
 
     return true;
@@ -666,7 +672,9 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
   TestInfoContainer tests_;
   InstantiationContainer instantiations_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
+  ParameterizedTestSuiteInfo(const ParameterizedTestSuiteInfo&) = delete;
+  ParameterizedTestSuiteInfo& operator=(const ParameterizedTestSuiteInfo&) =
+      delete;
 };  // class ParameterizedTestSuiteInfo
 
 //  Legacy API is deprecated but still available
@@ -709,7 +717,7 @@ class ParameterizedTestSuiteRegistry {
           // type we are looking for, so we downcast it to that type
           // without further checks.
           typed_test_info = CheckedDowncastToActualType<
-              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
+              ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);
         }
         break;
       }
@@ -741,7 +749,10 @@ class ParameterizedTestSuiteRegistry {
 
   TestSuiteInfoContainer test_suite_infos_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
+  ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =
+      delete;
+  ParameterizedTestSuiteRegistry& operator=(
+      const ParameterizedTestSuiteRegistry&) = delete;
 };
 
 // Keep track of what type-parameterized test suite are defined and
@@ -836,7 +847,8 @@ class CartesianProductGenerator
       : public ParamIteratorInterface<ParamType> {
    public:
     IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
-             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
+                 const std::tuple<ParamGenerator<T>...>& generators,
+                 bool is_end)
         : base_(base),
           begin_(std::get<I>(generators).begin()...),
           end_(std::get<I>(generators).end()...),
@@ -941,6 +953,78 @@ class CartesianProductHolder {
   std::tuple<Gen...> generators_;
 };
 
+template <typename From, typename To>
+class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
+ public:
+  ParamGeneratorConverter(ParamGenerator<From> gen) // NOLINT
+      : generator_(std::move(gen)) {}
+
+  ParamIteratorInterface<To>* Begin() const override {
+    return new Iterator(this, generator_.begin(), generator_.end());
+  }
+  ParamIteratorInterface<To>* End() const override {
+    return new Iterator(this, generator_.end(), generator_.end());
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<To> {
+   public:
+    Iterator(const ParamGeneratorInterface<To>* base, ParamIterator<From> it,
+             ParamIterator<From> end)
+        : base_(base), it_(it), end_(end) {
+      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
+    }
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<To>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      ++it_;
+      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
+    }
+    ParamIteratorInterface<To>* Clone() const override {
+      return new Iterator(*this);
+    }
+    const To* Current() const override { return value_.get(); }
+    bool Equals(const ParamIteratorInterface<To>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const ParamIterator<From> other_it =
+          CheckedDowncastToActualType<const Iterator>(&other)->it_;
+      return it_ == other_it;
+    }
+
+   private:
+    Iterator(const Iterator& other) = default;
+
+    const ParamGeneratorInterface<To>* const base_;
+    ParamIterator<From> it_;
+    ParamIterator<From> end_;
+    std::shared_ptr<To> value_;
+  };  // class ParamGeneratorConverter::Iterator
+
+  ParamGenerator<From> generator_;
+};  // class ParamGeneratorConverter
+
+template <class Gen>
+class ParamConverterGenerator {
+ public:
+  ParamConverterGenerator(ParamGenerator<Gen> g)  // NOLINT
+      : generator_(std::move(g)) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {  // NOLINT
+    return ParamGenerator<T>(new ParamGeneratorConverter<Gen, T>(generator_));
+  }
+
+ private:
+  ParamGenerator<Gen> generator_;
+};
+
 }  // namespace internal
 }  // namespace testing
 
diff --git a/googletest/googletest/include/gtest/internal/gtest-port-arch.h b/googletest/googletest/include/gtest/internal/gtest-port-arch.h
index dd845915e3ca75abe421d828c35271927e1ca810..04064606f5d02bb8753535e4c7868a79f5efe2e5 100644
--- a/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@@ -26,7 +26,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines the GTEST_OS_* macro.
@@ -37,70 +37,72 @@
 
 // Determines the platform on which Google Test is compiled.
 #ifdef __CYGWIN__
-# define GTEST_OS_CYGWIN 1
-# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
-#  define GTEST_OS_WINDOWS_MINGW 1
-#  define GTEST_OS_WINDOWS 1
+#define GTEST_OS_CYGWIN 1
+#elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
+#define GTEST_OS_WINDOWS_MINGW 1
+#define GTEST_OS_WINDOWS 1
 #elif defined _WIN32
-# define GTEST_OS_WINDOWS 1
-# ifdef _WIN32_WCE
-#  define GTEST_OS_WINDOWS_MOBILE 1
-# elif defined(WINAPI_FAMILY)
-#  include <winapifamily.h>
-#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-#   define GTEST_OS_WINDOWS_RT 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#   define GTEST_OS_WINDOWS_TV_TITLE 1
-#  else
-    // WINAPI_FAMILY defined but no known partition matched.
-    // Default to desktop.
-#   define GTEST_OS_WINDOWS_DESKTOP 1
-#  endif
-# else
-#  define GTEST_OS_WINDOWS_DESKTOP 1
-# endif  // _WIN32_WCE
+#define GTEST_OS_WINDOWS 1
+#ifdef _WIN32_WCE
+#define GTEST_OS_WINDOWS_MOBILE 1
+#elif defined(WINAPI_FAMILY)
+#include <winapifamily.h>
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#define GTEST_OS_WINDOWS_DESKTOP 1
+#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#define GTEST_OS_WINDOWS_PHONE 1
+#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define GTEST_OS_WINDOWS_RT 1
+#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
+#define GTEST_OS_WINDOWS_PHONE 1
+#define GTEST_OS_WINDOWS_TV_TITLE 1
+#else
+// WINAPI_FAMILY defined but no known partition matched.
+// Default to desktop.
+#define GTEST_OS_WINDOWS_DESKTOP 1
+#endif
+#else
+#define GTEST_OS_WINDOWS_DESKTOP 1
+#endif  // _WIN32_WCE
 #elif defined __OS2__
-# define GTEST_OS_OS2 1
+#define GTEST_OS_OS2 1
 #elif defined __APPLE__
-# define GTEST_OS_MAC 1
-# include <TargetConditionals.h>
-# if TARGET_OS_IPHONE
-#  define GTEST_OS_IOS 1
-# endif
+#define GTEST_OS_MAC 1
+#include <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#define GTEST_OS_IOS 1
+#endif
 #elif defined __DragonFly__
-# define GTEST_OS_DRAGONFLY 1
+#define GTEST_OS_DRAGONFLY 1
 #elif defined __FreeBSD__
-# define GTEST_OS_FREEBSD 1
+#define GTEST_OS_FREEBSD 1
 #elif defined __Fuchsia__
-# define GTEST_OS_FUCHSIA 1
+#define GTEST_OS_FUCHSIA 1
+#elif defined(__GNU__)
+#define GTEST_OS_GNU_HURD 1
 #elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
-# define GTEST_OS_GNU_KFREEBSD 1
+#define GTEST_OS_GNU_KFREEBSD 1
 #elif defined __linux__
-# define GTEST_OS_LINUX 1
-# if defined __ANDROID__
-#  define GTEST_OS_LINUX_ANDROID 1
-# endif
+#define GTEST_OS_LINUX 1
+#if defined __ANDROID__
+#define GTEST_OS_LINUX_ANDROID 1
+#endif
 #elif defined __MVS__
-# define GTEST_OS_ZOS 1
+#define GTEST_OS_ZOS 1
 #elif defined(__sun) && defined(__SVR4)
-# define GTEST_OS_SOLARIS 1
+#define GTEST_OS_SOLARIS 1
 #elif defined(_AIX)
-# define GTEST_OS_AIX 1
+#define GTEST_OS_AIX 1
 #elif defined(__hpux)
-# define GTEST_OS_HPUX 1
+#define GTEST_OS_HPUX 1
 #elif defined __native_client__
-# define GTEST_OS_NACL 1
+#define GTEST_OS_NACL 1
 #elif defined __NetBSD__
-# define GTEST_OS_NETBSD 1
+#define GTEST_OS_NETBSD 1
 #elif defined __OpenBSD__
-# define GTEST_OS_OPENBSD 1
+#define GTEST_OS_OPENBSD 1
 #elif defined __QNX__
-# define GTEST_OS_QNX 1
+#define GTEST_OS_QNX 1
 #elif defined(__HAIKU__)
 #define GTEST_OS_HAIKU 1
 #elif defined ESP8266
@@ -109,6 +111,8 @@
 #define GTEST_OS_ESP32 1
 #elif defined(__XTENSA__)
 #define GTEST_OS_XTENSA 1
+#elif defined(__hexagon__)
+#define GTEST_OS_QURT 1
 #endif  // __CYGWIN__
 
 #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
diff --git a/googletest/googletest/include/gtest/internal/gtest-port.h b/googletest/googletest/include/gtest/internal/gtest-port.h
index 0953a781c05514dea7461a49dd6b6d52587e800f..6db191b7a069821eaf641c6e082993b44905684a 100644
--- a/googletest/googletest/include/gtest/internal/gtest-port.h
+++ b/googletest/googletest/include/gtest/internal/gtest-port.h
@@ -26,7 +26,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // Low-level types and utilities for porting Google Test to various
 // platforms.  All macros ending with _ and symbols defined in an
 // internal namespace are subject to change without notice.  Code
@@ -38,7 +38,9 @@
 // files are expected to #include this.  Therefore, it cannot #include
 // any other Google Test header.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
@@ -81,6 +83,8 @@
 //   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
 //                              std::wstring does/doesn't work (Google Test can
 //                              be used where std::wstring is unavailable).
+//   GTEST_HAS_FILE_SYSTEM    - Define it to 1/0 to indicate whether or not a
+//                              file system is/isn't available.
 //   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
 //                              compiler supports Microsoft's "Structured
 //                              Exception Handling".
@@ -116,6 +120,7 @@
 //   GTEST_OS_DRAGONFLY - DragonFlyBSD
 //   GTEST_OS_FREEBSD  - FreeBSD
 //   GTEST_OS_FUCHSIA  - Fuchsia
+//   GTEST_OS_GNU_HURD - GNU/Hurd
 //   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
 //   GTEST_OS_HAIKU    - Haiku
 //   GTEST_OS_HPUX     - HP-UX
@@ -167,7 +172,7 @@
 //   GTEST_HAS_TYPED_TEST   - typed tests
 //   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
 //   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
-//   GOOGLETEST_CM0007 DO NOT DELETE
+//   GTEST_USES_RE2         - the RE2 regular expression library is used
 //   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
 //                            GTEST_HAS_POSIX_RE (see above) which users can
 //                            define themselves.
@@ -190,10 +195,6 @@
 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
 //   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
 //                              variable don't have to be used.
-//   GTEST_DISALLOW_ASSIGN_   - disables copy operator=.
-//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
-//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=.
-//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
 //   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
 //                                        suppressed (constant conditional).
@@ -217,11 +218,13 @@
 //                            - synchronization primitives.
 //
 // Regular expressions:
-//   RE             - a simple regular expression class using the POSIX
-//                    Extended Regular Expression syntax on UNIX-like platforms
-//                    GOOGLETEST_CM0008 DO NOT DELETE
-//                    or a reduced regular exception syntax on other
-//                    platforms, including Windows.
+//   RE             - a simple regular expression class using
+//                     1) the RE2 syntax on all platforms when built with RE2
+//                        and Abseil as dependencies
+//                     2) the POSIX Extended Regular Expression syntax on
+//                        UNIX-like platforms,
+//                     3) A reduced regular exception syntax on other platforms,
+//                        including Windows.
 // Logging:
 //   GTEST_LOG_()   - logs messages at the specified severity level.
 //   LogToStderr()  - directs all log messages to stderr.
@@ -241,8 +244,6 @@
 //   BiggestInt     - the biggest signed integer type.
 //
 // Command-line utilities:
-//   GTEST_DECLARE_*()  - declares a flag.
-//   GTEST_DEFINE_*()   - defines a flag.
 //   GetInjectableArgvs() - returns the command line as a vector of strings.
 //
 // Environment variable utilities:
@@ -256,6 +257,19 @@
 //                                        deprecated; calling a marked function
 //                                        should generate a compiler warning
 
+// The definition of GTEST_INTERNAL_CPLUSPLUS_LANG comes first because it can
+// potentially be used as an #include guard.
+#if defined(_MSVC_LANG)
+#define GTEST_INTERNAL_CPLUSPLUS_LANG _MSVC_LANG
+#elif defined(__cplusplus)
+#define GTEST_INTERNAL_CPLUSPLUS_LANG __cplusplus
+#endif
+
+#if !defined(GTEST_INTERNAL_CPLUSPLUS_LANG) || \
+    GTEST_INTERNAL_CPLUSPLUS_LANG < 201402L
+#error C++ versions less than C++14 are not supported.
+#endif
+
 #include <ctype.h>   // for isspace, etc
 #include <stddef.h>  // for ptrdiff_t
 #include <stdio.h>
@@ -263,48 +277,56 @@
 #include <string.h>
 
 #include <cerrno>
+// #include <condition_variable>  // Guarded by GTEST_IS_THREADSAFE below
 #include <cstdint>
+#include <iostream>
 #include <limits>
+#include <locale>
+#include <memory>
+#include <ostream>
+#include <string>
+// #include <mutex>  // Guarded by GTEST_IS_THREADSAFE below
+#include <tuple>
 #include <type_traits>
+#include <vector>
 
 #ifndef _WIN32_WCE
-# include <sys/types.h>
-# include <sys/stat.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #endif  // !_WIN32_WCE
 
 #if defined __APPLE__
-# include <AvailabilityMacros.h>
-# include <TargetConditionals.h>
+#include <AvailabilityMacros.h>
+#include <TargetConditionals.h>
 #endif
 
-#include <iostream>  // NOLINT
-#include <locale>
-#include <memory>
-#include <string>  // NOLINT
-#include <tuple>
-#include <vector>  // NOLINT
-
 #include "gtest/internal/custom/gtest-port.h"
 #include "gtest/internal/gtest-port-arch.h"
 
+#if GTEST_HAS_ABSL
+#include "absl/flags/declare.h"
+#include "absl/flags/flag.h"
+#include "absl/flags/reflection.h"
+#endif
+
 #if !defined(GTEST_DEV_EMAIL_)
-# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
-# define GTEST_FLAG_PREFIX_ "gtest_"
-# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
-# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
-# define GTEST_NAME_ "Google Test"
-# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
+#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+#define GTEST_FLAG_PREFIX_ "gtest_"
+#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+#define GTEST_NAME_ "Google Test"
+#define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
 #endif  // !defined(GTEST_DEV_EMAIL_)
 
 #if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
-# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
 #endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
 
 // Determines the version of gcc that is used to compile this.
 #ifdef __GNUC__
 // 40302 means version 4.3.2.
-# define GTEST_GCC_VER_ \
-    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#define GTEST_GCC_VER_ \
+  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #endif  // __GNUC__
 
 // Macros for disabling Microsoft Visual C++ warnings.
@@ -313,41 +335,37 @@
 //   /* code that triggers warnings C4800 and C4385 */
 //   GTEST_DISABLE_MSC_WARNINGS_POP_()
 #if defined(_MSC_VER)
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
-    __pragma(warning(push))                        \
-    __pragma(warning(disable: warnings))
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
-    __pragma(warning(pop))
+#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+  __pragma(warning(push)) __pragma(warning(disable : warnings))
+#define GTEST_DISABLE_MSC_WARNINGS_POP_() __pragma(warning(pop))
 #else
 // Not all compilers are MSVC
-# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
-# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+#define GTEST_DISABLE_MSC_WARNINGS_POP_()
 #endif
 
 // Clang on Windows does not understand MSVC's pragma warning.
 // We need clang-specific way to disable function deprecation warning.
 #ifdef __clang__
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
-    _Pragma("clang diagnostic push")                                  \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
-#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    _Pragma("clang diagnostic pop")
+#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                            \
+  _Pragma("clang diagnostic push")                                      \
+      _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
+          _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() _Pragma("clang diagnostic pop")
 #else
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
 #endif
 
 // Brings in definitions for functions used in the testing::internal::posix
 // namespace (read, write, close, chdir, isatty, stat). We do not currently
 // use them on Windows Mobile.
 #if GTEST_OS_WINDOWS
-# if !GTEST_OS_WINDOWS_MOBILE
-#  include <direct.h>
-#  include <io.h>
-# endif
+#if !GTEST_OS_WINDOWS_MOBILE
+#include <direct.h>
+#include <io.h>
+#endif
 // In order to avoid having to include <windows.h>, use forward declaration
 #if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
 // MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
@@ -367,68 +385,56 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
 // is not the case, we need to include headers that provide the functions
 // mentioned above.
-# include <unistd.h>
-# include <strings.h>
+#include <strings.h>
+#include <unistd.h>
 #endif  // GTEST_OS_WINDOWS
 
 #if GTEST_OS_LINUX_ANDROID
 // Used to define __ANDROID_API__ matching the target NDK API level.
-#  include <android/api-level.h>  // NOLINT
+#include <android/api-level.h>  // NOLINT
 #endif
 
 // Defines this to true if and only if Google Test can use POSIX regular
 // expressions.
 #ifndef GTEST_HAS_POSIX_RE
-# if GTEST_OS_LINUX_ANDROID
+#if GTEST_OS_LINUX_ANDROID
 // On Android, <regex.h> is only available starting with Gingerbread.
-#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
-# else
-#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
-# endif
+#define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+#else
+#define GTEST_HAS_POSIX_RE \
+  !(GTEST_OS_WINDOWS || GTEST_OS_XTENSA || GTEST_OS_QURT)
+#endif
 #endif
 
-#if GTEST_USES_PCRE
-// The appropriate headers have already been included.
-
+// Select the regular expression implementation.
+#if GTEST_HAS_ABSL
+// When using Abseil, RE2 is required.
+#include "absl/strings/string_view.h"
+#include "re2/re2.h"
+#define GTEST_USES_RE2 1
 #elif GTEST_HAS_POSIX_RE
-
-// On some platforms, <regex.h> needs someone to define size_t, and
-// won't compile otherwise.  We can #include it here as we already
-// included <stdlib.h>, which is guaranteed to define size_t through
-// <stddef.h>.
-# include <regex.h>  // NOLINT
-
-# define GTEST_USES_POSIX_RE 1
-
-#elif GTEST_OS_WINDOWS
-
-// <regex.h> is not available on Windows.  Use our own simple regex
-// implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
+#include <regex.h>  // NOLINT
+#define GTEST_USES_POSIX_RE 1
 #else
-
-// <regex.h> may not be available on this platform.  Use our own
-// simple regex implementation instead.
-# define GTEST_USES_SIMPLE_RE 1
-
-#endif  // GTEST_USES_PCRE
+// Use our own simple regex implementation.
+#define GTEST_USES_SIMPLE_RE 1
+#endif
 
 #ifndef GTEST_HAS_EXCEPTIONS
 // The user didn't tell us whether exceptions are enabled, so we need
 // to figure it out.
-# if defined(_MSC_VER) && defined(_CPPUNWIND)
+#if defined(_MSC_VER) && defined(_CPPUNWIND)
 // MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__BORLANDC__)
+#define GTEST_HAS_EXCEPTIONS 1
+#elif defined(__BORLANDC__)
 // C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
 // macro to enable exceptions, so we'll do the same.
 // Assumes that exceptions are enabled by default.
-#  ifndef _HAS_EXCEPTIONS
-#   define _HAS_EXCEPTIONS 1
-#  endif  // _HAS_EXCEPTIONS
-#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
-# elif defined(__clang__)
+#ifndef _HAS_EXCEPTIONS
+#define _HAS_EXCEPTIONS 1
+#endif  // _HAS_EXCEPTIONS
+#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+#elif defined(__clang__)
 // clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
 // 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
 // there can be cleanups for ObjC exceptions which also need cleanups, even if
@@ -437,27 +443,27 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // cleanups prior to that. To reliably check for C++ exception availability with
 // clang, check for
 // __EXCEPTIONS && __has_feature(cxx_exceptions).
-#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
-# elif defined(__GNUC__) && __EXCEPTIONS
+#define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
+#elif defined(__GNUC__) && __EXCEPTIONS
 // gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__SUNPRO_CC)
+#define GTEST_HAS_EXCEPTIONS 1
+#elif defined(__SUNPRO_CC)
 // Sun Pro CC supports exceptions.  However, there is no compile-time way of
 // detecting whether they are enabled or not.  Therefore, we assume that
 // they are enabled unless the user tells us otherwise.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__IBMCPP__) && __EXCEPTIONS
+#define GTEST_HAS_EXCEPTIONS 1
+#elif defined(__IBMCPP__) && __EXCEPTIONS
 // xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__HP_aCC)
+#define GTEST_HAS_EXCEPTIONS 1
+#elif defined(__HP_aCC)
 // Exception handling is in effect by default in HP aCC compiler. It has to
 // be turned of by +noeh compiler option if desired.
-#  define GTEST_HAS_EXCEPTIONS 1
-# else
+#define GTEST_HAS_EXCEPTIONS 1
+#else
 // For other compilers, we assume exceptions are disabled to be
 // conservative.
-#  define GTEST_HAS_EXCEPTIONS 0
-# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#define GTEST_HAS_EXCEPTIONS 0
+#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
 #endif  // GTEST_HAS_EXCEPTIONS
 
 #ifndef GTEST_HAS_STD_WSTRING
@@ -468,72 +474,77 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // no support for it at least as recent as Froyo (2.2).
 #define GTEST_HAS_STD_WSTRING                                         \
   (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
-     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
+     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 ||          \
+     GTEST_OS_XTENSA || GTEST_OS_QURT))
 
 #endif  // GTEST_HAS_STD_WSTRING
 
+#ifndef GTEST_HAS_FILE_SYSTEM
+// Most platforms support a file system.
+#define GTEST_HAS_FILE_SYSTEM 1
+#endif  // GTEST_HAS_FILE_SYSTEM
+
 // Determines whether RTTI is available.
 #ifndef GTEST_HAS_RTTI
 // The user didn't tell us whether RTTI is enabled, so we need to
 // figure it out.
 
-# ifdef _MSC_VER
+#ifdef _MSC_VER
 
 #ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
+#define GTEST_HAS_RTTI 1
+#else
+#define GTEST_HAS_RTTI 0
+#endif
 
 // Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
 // enabled.
-# elif defined(__GNUC__)
+#elif defined(__GNUC__)
 
-#  ifdef __GXX_RTTI
+#ifdef __GXX_RTTI
 // When building against STLport with the Android NDK and with
 // -frtti -fno-exceptions, the build fails at link time with undefined
 // references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
 // so disable RTTI when detected.
-#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
-       !defined(__EXCEPTIONS)
-#    define GTEST_HAS_RTTI 0
-#   else
-#    define GTEST_HAS_RTTI 1
-#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif  // __GXX_RTTI
+#if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && !defined(__EXCEPTIONS)
+#define GTEST_HAS_RTTI 0
+#else
+#define GTEST_HAS_RTTI 1
+#endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#else
+#define GTEST_HAS_RTTI 0
+#endif  // __GXX_RTTI
 
 // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
 // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
 // first version with C++ support.
-# elif defined(__clang__)
+#elif defined(__clang__)
 
-#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+#define GTEST_HAS_RTTI __has_feature(cxx_rtti)
 
 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
 // both the typeid and dynamic_cast features are present.
-# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
 
-#  ifdef __RTTI_ALL__
-#   define GTEST_HAS_RTTI 1
-#  else
-#   define GTEST_HAS_RTTI 0
-#  endif
+#ifdef __RTTI_ALL__
+#define GTEST_HAS_RTTI 1
+#else
+#define GTEST_HAS_RTTI 0
+#endif
 
-# else
+#else
 
 // For all other compilers, we assume RTTI is enabled.
-#  define GTEST_HAS_RTTI 1
+#define GTEST_HAS_RTTI 1
 
-# endif  // _MSC_VER
+#endif  // _MSC_VER
 
 #endif  // GTEST_HAS_RTTI
 
 // It's this header's responsibility to #include <typeinfo> when RTTI
 // is enabled.
 #if GTEST_HAS_RTTI
-# include <typeinfo>
+#include <typeinfo>
 #endif
 
 // Determines whether Google Test can use the pthreads library.
@@ -547,16 +558,16 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
   (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
    GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
    GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
-   GTEST_OS_HAIKU)
+   GTEST_OS_HAIKU || GTEST_OS_GNU_HURD)
 #endif  // GTEST_HAS_PTHREAD
 
 #if GTEST_HAS_PTHREAD
 // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
 // true.
-# include <pthread.h>  // NOLINT
+#include <pthread.h>  // NOLINT
 
 // For timespec and nanosleep, used below.
-# include <time.h>  // NOLINT
+#include <time.h>  // NOLINT
 #endif
 
 // Determines whether clone(2) is supported.
@@ -566,24 +577,23 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_HAS_CLONE
 // The user didn't tell us, so we need to figure it out.
 
-# if GTEST_OS_LINUX && !defined(__ia64__)
-#  if GTEST_OS_LINUX_ANDROID
+#if GTEST_OS_LINUX && !defined(__ia64__)
+#if GTEST_OS_LINUX_ANDROID
 // On Android, clone() became available at different API levels for each 32-bit
 // architecture.
-#    if defined(__LP64__) || \
-        (defined(__arm__) && __ANDROID_API__ >= 9) || \
-        (defined(__mips__) && __ANDROID_API__ >= 12) || \
-        (defined(__i386__) && __ANDROID_API__ >= 17)
-#     define GTEST_HAS_CLONE 1
-#    else
-#     define GTEST_HAS_CLONE 0
-#    endif
-#  else
-#   define GTEST_HAS_CLONE 1
-#  endif
-# else
-#  define GTEST_HAS_CLONE 0
-# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+#if defined(__LP64__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \
+    (defined(__mips__) && __ANDROID_API__ >= 12) ||                    \
+    (defined(__i386__) && __ANDROID_API__ >= 17)
+#define GTEST_HAS_CLONE 1
+#else
+#define GTEST_HAS_CLONE 0
+#endif
+#else
+#define GTEST_HAS_CLONE 1
+#endif
+#else
+#define GTEST_HAS_CLONE 0
+#endif  // GTEST_OS_LINUX && !defined(__ia64__)
 
 #endif  // GTEST_HAS_CLONE
 
@@ -591,13 +601,15 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // output correctness and to implement death tests.
 #ifndef GTEST_HAS_STREAM_REDIRECTION
 // By default, we assume that stream redirection is supported on all
-// platforms except known mobile ones.
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
-    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
-#  define GTEST_HAS_STREAM_REDIRECTION 0
-# else
-#  define GTEST_HAS_STREAM_REDIRECTION 1
-# endif  // !GTEST_OS_WINDOWS_MOBILE
+// platforms except known mobile / embedded ones. Also, if the port doesn't have
+// a file system, stream redirection is not supported.
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||          \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \
+    GTEST_OS_QURT || !GTEST_HAS_FILE_SYSTEM
+#define GTEST_HAS_STREAM_REDIRECTION 0
+#else
+#define GTEST_HAS_STREAM_REDIRECTION 1
+#endif  // !GTEST_OS_WINDOWS_MOBILE
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
 // Determines whether to support death tests.
@@ -607,8 +619,12 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
      GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
      GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
-     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
-# define GTEST_HAS_DEATH_TEST 1
+     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU ||     \
+     GTEST_OS_GNU_HURD)
+// Death tests require a file system to work properly.
+#if GTEST_HAS_FILE_SYSTEM
+#define GTEST_HAS_DEATH_TEST 1
+#endif  // GTEST_HAS_FILE_SYSTEM
 #endif
 
 // Determines whether to support type-driven tests.
@@ -617,8 +633,8 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Sun Pro CC, IBM Visual Age, and HP aCC support.
 #if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
     defined(__IBMCPP__) || defined(__HP_aCC)
-# define GTEST_HAS_TYPED_TEST 1
-# define GTEST_HAS_TYPED_TEST_P 1
+#define GTEST_HAS_TYPED_TEST 1
+#define GTEST_HAS_TYPED_TEST_P 1
 #endif
 
 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
@@ -627,8 +643,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 // Determines whether test results can be streamed to a socket.
 #if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
-    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
-# define GTEST_CAN_STREAM_RESULTS_ 1
+    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD ||       \
+    GTEST_OS_GNU_HURD
+#define GTEST_CAN_STREAM_RESULTS_ 1
 #endif
 
 // Defines some utility macros.
@@ -642,83 +659,75 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 //
 // The "switch (0) case 0:" idiom is used to suppress this.
 #ifdef __INTEL_COMPILER
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
 #else
-# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  switch (0)                          \
+  case 0:                             \
+  default:  // NOLINT
 #endif
 
-// Use this annotation at the end of a struct/class definition to
-// prevent the compiler from optimizing away instances that are never
-// used.  This is useful when all interesting logic happens inside the
-// c'tor and / or d'tor.  Example:
+// GTEST_HAVE_ATTRIBUTE_
 //
-//   struct Foo {
-//     Foo() { ... }
-//   } GTEST_ATTRIBUTE_UNUSED_;
+// A function-like feature checking macro that is a wrapper around
+// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+// nonzero constant integer if the attribute is supported or 0 if not.
 //
-// Also use it after a variable or parameter declaration to tell the
-// compiler the variable/parameter does not have to be used.
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-#elif defined(__clang__)
-# if __has_attribute(unused)
-#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
-# endif
+// It evaluates to zero if `__has_attribute` is not defined by the compiler.
+//
+// GCC: https://gcc.gnu.org/gcc-5/changes.html
+// Clang: https://clang.llvm.org/docs/LanguageExtensions.html
+#ifdef __has_attribute
+#define GTEST_HAVE_ATTRIBUTE_(x) __has_attribute(x)
+#else
+#define GTEST_HAVE_ATTRIBUTE_(x) 0
+#endif
+
+// GTEST_HAVE_FEATURE_
+//
+// A function-like feature checking macro that is a wrapper around
+// `__has_feature`.
+#ifdef __has_feature
+#define GTEST_HAVE_FEATURE_(x) __has_feature(x)
+#else
+#define GTEST_HAVE_FEATURE_(x) 0
 #endif
-#ifndef GTEST_ATTRIBUTE_UNUSED_
-# define GTEST_ATTRIBUTE_UNUSED_
+
+// Use this annotation after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+// Example:
+//
+//   GTEST_ATTRIBUTE_UNUSED_ int foo = bar();
+#if GTEST_HAVE_ATTRIBUTE_(unused)
+#define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused))
+#else
+#define GTEST_ATTRIBUTE_UNUSED_
 #endif
 
 // Use this annotation before a function that takes a printf format string.
-#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
-# if defined(__MINGW_PRINTF_FORMAT)
+#if GTEST_HAVE_ATTRIBUTE_(format) && defined(__MINGW_PRINTF_FORMAT)
 // MinGW has two different printf implementations. Ensure the format macro
 // matches the selected implementation. See
 // https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
-                                 first_to_check)))
-# else
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__printf__, string_index, first_to_check)))
-# endif
+#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+  __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, first_to_check)))
+#elif GTEST_HAVE_ATTRIBUTE_(format)
+#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)   \
+  __attribute__((format(printf, string_index, first_to_check)))
 #else
-# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
+#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
 #endif
 
-
-// A macro to disallow copy operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_ASSIGN_(type) \
-  type& operator=(type const &) = delete
-
-// A macro to disallow copy constructor and operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
-  type(type const&) = delete;                 \
-  type& operator=(type const&) = delete
-
-// A macro to disallow move operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
-  type& operator=(type &&) noexcept = delete
-
-// A macro to disallow move constructor and operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
-  type(type&&) noexcept = delete;             \
-  type& operator=(type&&) noexcept = delete
-
 // Tell the compiler to warn about unused return values for functions declared
 // with this macro.  The macro should be used on function declarations
 // following the argument list:
 //
 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
-# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#if GTEST_HAVE_ATTRIBUTE_(warn_unused_result)
+#define GTEST_MUST_USE_RESULT_ __attribute__((warn_unused_result))
 #else
-# define GTEST_MUST_USE_RESULT_
-#endif  // __GNUC__ && !COMPILER_ICC
+#define GTEST_MUST_USE_RESULT_
+#endif
 
 // MS C++ compiler emits warning when a conditional expression is compile time
 // constant. In some contexts this warning is false positive and needs to be
@@ -728,10 +737,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // while (true) {
 // GTEST_INTENTIONAL_CONST_COND_POP_()
 // }
-# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
-# define GTEST_INTENTIONAL_CONST_COND_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+#define GTEST_INTENTIONAL_CONST_COND_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
 
 // Determine whether the compiler supports Microsoft's Structured Exception
 // Handling.  This is supported by several Windows compilers but generally
@@ -739,13 +747,13 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_HAS_SEH
 // The user didn't tell us, so we need to figure it out.
 
-# if defined(_MSC_VER) || defined(__BORLANDC__)
+#if defined(_MSC_VER) || defined(__BORLANDC__)
 // These two compilers are known to support SEH.
-#  define GTEST_HAS_SEH 1
-# else
+#define GTEST_HAS_SEH 1
+#else
 // Assume no SEH.
-#  define GTEST_HAS_SEH 0
-# endif
+#define GTEST_HAS_SEH 0
+#endif
 
 #endif  // GTEST_HAS_SEH
 
@@ -758,95 +766,95 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 #endif  // GTEST_IS_THREADSAFE
 
+#if GTEST_IS_THREADSAFE
+// Some platforms don't support including these threading related headers.
+#include <condition_variable>  // NOLINT
+#include <mutex>               // NOLINT
+#endif                         // GTEST_IS_THREADSAFE
+
 // GTEST_API_ qualifies all symbols that must be exported. The definitions below
 // are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
 // gtest/internal/custom/gtest-port.h
 #ifndef GTEST_API_
 
 #ifdef _MSC_VER
-# if GTEST_LINKED_AS_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllimport)
-# elif GTEST_CREATE_SHARED_LIBRARY
-#  define GTEST_API_ __declspec(dllexport)
-# endif
-#elif __GNUC__ >= 4 || defined(__clang__)
-# define GTEST_API_ __attribute__((visibility ("default")))
+#if GTEST_LINKED_AS_SHARED_LIBRARY
+#define GTEST_API_ __declspec(dllimport)
+#elif GTEST_CREATE_SHARED_LIBRARY
+#define GTEST_API_ __declspec(dllexport)
+#endif
+#elif GTEST_HAVE_ATTRIBUTE_(visibility)
+#define GTEST_API_ __attribute__((visibility("default")))
 #endif  // _MSC_VER
 
 #endif  // GTEST_API_
 
 #ifndef GTEST_API_
-# define GTEST_API_
+#define GTEST_API_
 #endif  // GTEST_API_
 
 #ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
-# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
+#define GTEST_DEFAULT_DEATH_TEST_STYLE "fast"
 #endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
 
-#ifdef __GNUC__
+#if GTEST_HAVE_ATTRIBUTE_(noinline)
 // Ask the compiler to never inline a given function.
-# define GTEST_NO_INLINE_ __attribute__((noinline))
+#define GTEST_NO_INLINE_ __attribute__((noinline))
 #else
-# define GTEST_NO_INLINE_
+#define GTEST_NO_INLINE_
+#endif
+
+#if GTEST_HAVE_ATTRIBUTE_(disable_tail_calls)
+// Ask the compiler not to perform tail call optimization inside
+// the marked function.
+#define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls))
+#elif __GNUC__
+#define GTEST_NO_TAIL_CALL_ \
+  __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+#define GTEST_NO_TAIL_CALL_
 #endif
 
 // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
 #if !defined(GTEST_HAS_CXXABI_H_)
-# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
-#  define GTEST_HAS_CXXABI_H_ 1
-# else
-#  define GTEST_HAS_CXXABI_H_ 0
-# endif
+#if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
+#define GTEST_HAS_CXXABI_H_ 1
+#else
+#define GTEST_HAS_CXXABI_H_ 0
+#endif
 #endif
 
 // A function level attribute to disable checking for use of uninitialized
 // memory when built with MemorySanitizer.
-#if defined(__clang__)
-# if __has_feature(memory_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
-       __attribute__((no_sanitize_memory))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-# endif  // __has_feature(memory_sanitizer)
+#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_memory)
+#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ __attribute__((no_sanitize_memory))
 #else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-#endif  // __clang__
+#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif
 
 // A function level attribute to disable AddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(address_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
-       __attribute__((no_sanitize_address))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-# endif  // __has_feature(address_sanitizer)
+#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_address)
+#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+  __attribute__((no_sanitize_address))
 #else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-#endif  // __clang__
+#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif
 
 // A function level attribute to disable HWAddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(hwaddress_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
-       __attribute__((no_sanitize("hwaddress")))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-# endif  // __has_feature(hwaddress_sanitizer)
+#if GTEST_HAVE_FEATURE_(hwaddress_sanitizer) && \
+    GTEST_HAVE_ATTRIBUTE_(no_sanitize)
+#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
+  __attribute__((no_sanitize("hwaddress")))
 #else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-#endif  // __clang__
+#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+#endif
 
 // A function level attribute to disable ThreadSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(thread_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
-       __attribute__((no_sanitize_thread))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-# endif  // __has_feature(thread_sanitizer)
+#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_thread)
+#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ __attribute((no_sanitize_thread))
 #else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-#endif  // __clang__
+#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif
 
 namespace testing {
 
@@ -867,25 +875,37 @@ namespace internal {
 // Secret object, which is what we want.
 class Secret;
 
-// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
-// time expression is true (in new code, use static_assert instead). For
-// example, you could use it to verify the size of a static array:
-//
-//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
-//                         names_incorrect_size);
-//
-// The second argument to the macro must be a valid C++ identifier. If the
-// expression is false, compiler will issue an error containing this identifier.
-#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
-
 // A helper for suppressing warnings on constant condition.  It just
 // returns 'condition'.
 GTEST_API_ bool IsTrue(bool condition);
 
 // Defines RE.
 
-#if GTEST_USES_PCRE
-// if used, PCRE is injected by custom/gtest-port.h
+#if GTEST_USES_RE2
+
+// This is almost `using RE = ::RE2`, except it is copy-constructible, and it
+// needs to disambiguate the `std::string`, `absl::string_view`, and `const
+// char*` constructors.
+class GTEST_API_ RE {
+ public:
+  RE(absl::string_view regex) : regex_(regex) {}                  // NOLINT
+  RE(const char* regex) : RE(absl::string_view(regex)) {}         // NOLINT
+  RE(const std::string& regex) : RE(absl::string_view(regex)) {}  // NOLINT
+  RE(const RE& other) : RE(other.pattern()) {}
+
+  const std::string& pattern() const { return regex_.pattern(); }
+
+  static bool FullMatch(absl::string_view str, const RE& re) {
+    return RE2::FullMatch(str, re.regex_);
+  }
+  static bool PartialMatch(absl::string_view str, const RE& re) {
+    return RE2::PartialMatch(str, re.regex_);
+  }
+
+ private:
+  RE2 regex_;
+};
+
 #elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
 
 // A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
@@ -924,19 +944,19 @@ class GTEST_API_ RE {
   const char* pattern_;
   bool is_valid_;
 
-# if GTEST_USES_POSIX_RE
+#if GTEST_USES_POSIX_RE
 
   regex_t full_regex_;     // For FullMatch().
   regex_t partial_regex_;  // For PartialMatch().
 
-# else  // GTEST_USES_SIMPLE_RE
+#else  // GTEST_USES_SIMPLE_RE
 
   const char* full_pattern_;  // For FullMatch();
 
-# endif
+#endif
 };
 
-#endif  // GTEST_USES_PCRE
+#endif  // ::testing::internal::RE implementation
 
 // Formats a source file path and a line number as they would appear
 // in an error message from the compiler used to compile this code.
@@ -954,12 +974,7 @@ GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
 //   LogToStderr()  - directs all log messages to stderr.
 //   FlushInfoLog() - flushes informational log messages.
 
-enum GTestLogSeverity {
-  GTEST_INFO,
-  GTEST_WARNING,
-  GTEST_ERROR,
-  GTEST_FATAL
-};
+enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL };
 
 // Formats log entry severity, provides a stream object for streaming the
 // log message, and terminates the message with a newline when going out of
@@ -976,14 +991,16 @@ class GTEST_API_ GTestLog {
  private:
   const GTestLogSeverity severity_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+  GTestLog(const GTestLog&) = delete;
+  GTestLog& operator=(const GTestLog&) = delete;
 };
 
 #if !defined(GTEST_LOG_)
 
-# define GTEST_LOG_(severity) \
-    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
-                                  __FILE__, __LINE__).GetStream()
+#define GTEST_LOG_(severity)                                           \
+  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                __FILE__, __LINE__)                    \
+      .GetStream()
 
 inline void LogToStderr() {}
 inline void FlushInfoLog() { fflush(nullptr); }
@@ -995,7 +1012,7 @@ inline void FlushInfoLog() { fflush(nullptr); }
 //
 // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
 // is not satisfied.
-//  Synopsys:
+//  Synopsis:
 //    GTEST_CHECK_(boolean_condition);
 //     or
 //    GTEST_CHECK_(boolean_condition) << "Additional message";
@@ -1005,12 +1022,12 @@ inline void FlushInfoLog() { fflush(nullptr); }
 //    condition itself, plus additional message streamed into it, if any,
 //    and then it aborts the program. It aborts the program irrespective of
 //    whether it is built in the debug mode or not.
-# define GTEST_CHECK_(condition) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::IsTrue(condition)) \
-      ; \
-    else \
-      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#define GTEST_CHECK_(condition)               \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \
+  if (::testing::internal::IsTrue(condition)) \
+    ;                                         \
+  else                                        \
+    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
 #endif  // !defined(GTEST_CHECK_)
 
 // An all-mode assert to verify that the given POSIX-style function
@@ -1019,9 +1036,8 @@ inline void FlushInfoLog() { fflush(nullptr); }
 // in {} if you need to use it as the only statement in an 'if'
 // branch.
 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
-  if (const int gtest_error = (posix_call)) \
-    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
-                      << gtest_error
+  if (const int gtest_error = (posix_call))    \
+  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
 
 // Transforms "T" into "const T&" according to standard reference collapsing
 // rules (this is only needed as a backport for C++98 compilers that do not
@@ -1035,9 +1051,13 @@ inline void FlushInfoLog() { fflush(nullptr); }
 // Note that the non-const reference will not have "const" added. This is
 // standard, and necessary so that "T" can always bind to "const T&".
 template <typename T>
-struct ConstRef { typedef const T& type; };
+struct ConstRef {
+  typedef const T& type;
+};
 template <typename T>
-struct ConstRef<T&> { typedef T& type; };
+struct ConstRef<T&> {
+  typedef T& type;
+};
 
 // The argument T must depend on some template parameters.
 #define GTEST_REFERENCE_TO_CONST_(T) \
@@ -1050,7 +1070,7 @@ struct ConstRef<T&> { typedef T& type; };
 // const Foo*).  When you use ImplicitCast_, the compiler checks that
 // the cast is safe.  Such explicit ImplicitCast_s are necessary in
 // surprisingly many situations where C++ demands an exact type match
-// instead of an argument type convertable to a target type.
+// instead of an argument type convertible to a target type.
 //
 // The syntax for using ImplicitCast_ is the same as for static_cast:
 //
@@ -1063,8 +1083,10 @@ struct ConstRef<T&> { typedef T& type; };
 // This relatively ugly name is intentional. It prevents clashes with
 // similar functions users may have (e.g., implicit_cast). The internal
 // namespace alone is not enough because the function can be found by ADL.
-template<typename To>
-inline To ImplicitCast_(To x) { return x; }
+template <typename To>
+inline To ImplicitCast_(To x) {
+  return x;
+}
 
 // When you upcast (that is, cast a pointer from type Foo to type
 // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
@@ -1087,17 +1109,17 @@ inline To ImplicitCast_(To x) { return x; }
 // This relatively ugly name is intentional. It prevents clashes with
 // similar functions users may have (e.g., down_cast). The internal
 // namespace alone is not enough because the function can be found by ADL.
-template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
-inline To DownCast_(From* f) {  // so we only accept pointers
+template <typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {         // so we only accept pointers
   // Ensures that To is a sub-type of From *.  This test is here only
   // for compile-time type checking, and has no overhead in an
   // optimized build at run-time, as it will be optimized away
   // completely.
   GTEST_INTENTIONAL_CONST_COND_PUSH_()
   if (false) {
-  GTEST_INTENTIONAL_CONST_COND_POP_()
-  const To to = nullptr;
-  ::testing::internal::ImplicitCast_<From*>(to);
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+    const To to = nullptr;
+    ::testing::internal::ImplicitCast_<From*>(to);
   }
 
 #if GTEST_HAS_RTTI
@@ -1162,71 +1184,8 @@ void ClearInjectableArgvs();
 
 // Defines synchronization primitives.
 #if GTEST_IS_THREADSAFE
-# if GTEST_HAS_PTHREAD
-// Sleeps for (roughly) n milliseconds.  This function is only for testing
-// Google Test's own constructs.  Don't use it in user tests, either
-// directly or indirectly.
-inline void SleepMilliseconds(int n) {
-  const timespec time = {
-    0,                  // 0 seconds.
-    n * 1000L * 1000L,  // And n ms.
-  };
-  nanosleep(&time, nullptr);
-}
-# endif  // GTEST_HAS_PTHREAD
-
-# if GTEST_HAS_NOTIFICATION_
-// Notification has already been imported into the namespace.
-// Nothing to do here.
-
-# elif GTEST_HAS_PTHREAD
-// Allows a controller thread to pause execution of newly created
-// threads until notified.  Instances of this class must be created
-// and destroyed in the controller thread.
-//
-// This class is only for testing Google Test's own constructs. Do not
-// use it in user tests, either directly or indirectly.
-class Notification {
- public:
-  Notification() : notified_(false) {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
-  }
-  ~Notification() {
-    pthread_mutex_destroy(&mutex_);
-  }
-
-  // Notifies all threads created with this notification to start. Must
-  // be called from the controller thread.
-  void Notify() {
-    pthread_mutex_lock(&mutex_);
-    notified_ = true;
-    pthread_mutex_unlock(&mutex_);
-  }
-
-  // Blocks until the controller thread notifies. Must be called from a test
-  // thread.
-  void WaitForNotification() {
-    for (;;) {
-      pthread_mutex_lock(&mutex_);
-      const bool notified = notified_;
-      pthread_mutex_unlock(&mutex_);
-      if (notified)
-        break;
-      SleepMilliseconds(10);
-    }
-  }
-
- private:
-  pthread_mutex_t mutex_;
-  bool notified_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
-};
-
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
-
-GTEST_API_ void SleepMilliseconds(int n);
 
+#if GTEST_OS_WINDOWS
 // Provides leak-safe Windows kernel handle ownership.
 // Used in death tests and in threading support.
 class GTEST_API_ AutoHandle {
@@ -1253,8 +1212,18 @@ class GTEST_API_ AutoHandle {
 
   Handle handle_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+  AutoHandle(const AutoHandle&) = delete;
+  AutoHandle& operator=(const AutoHandle&) = delete;
 };
+#endif
+
+#if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+#else
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
 
 // Allows a controller thread to pause execution of newly created
 // threads until notified.  Instances of this class must be created
@@ -1262,23 +1231,40 @@ class GTEST_API_ AutoHandle {
 //
 // This class is only for testing Google Test's own constructs. Do not
 // use it in user tests, either directly or indirectly.
+// TODO(b/203539622): Replace unconditionally with absl::Notification.
 class GTEST_API_ Notification {
  public:
-  Notification();
-  void Notify();
-  void WaitForNotification();
+  Notification() : notified_(false) {}
+  Notification(const Notification&) = delete;
+  Notification& operator=(const Notification&) = delete;
 
- private:
-  AutoHandle event_;
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    std::lock_guard<std::mutex> lock(mu_);
+    notified_ = true;
+    cv_.notify_all();
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    std::unique_lock<std::mutex> lock(mu_);
+    cv_.wait(lock, [this]() { return notified_; });
+  }
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+ private:
+  std::mutex mu_;
+  std::condition_variable cv_;
+  bool notified_;
 };
-# endif  // GTEST_HAS_NOTIFICATION_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4251
+#endif  // GTEST_HAS_NOTIFICATION_
 
 // On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
 // defined, but we don't want to use MinGW's pthreads implementation, which
 // has conformance problems with some versions of the POSIX standard.
-# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+#if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
 
 // As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
 // Consequently, it cannot select a correct instantiation of ThreadWithParam
@@ -1354,16 +1340,17 @@ class ThreadWithParam : public ThreadWithParamBase {
                    // finished.
   pthread_t thread_;  // The native thread object.
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+  ThreadWithParam(const ThreadWithParam&) = delete;
+  ThreadWithParam& operator=(const ThreadWithParam&) = delete;
 };
-# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
-         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+#endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+        // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
 
-# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+#if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
 // Mutex and ThreadLocal have already been imported into the namespace.
 // Nothing to do here.
 
-# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+#elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
 
 // Mutex implements mutex on Windows platforms.  It is used in conjunction
 // with class MutexLock:
@@ -1417,14 +1404,15 @@ class GTEST_API_ Mutex {
   long critical_section_init_phase_;  // NOLINT
   GTEST_CRITICAL_SECTION* critical_section_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+  Mutex(const Mutex&) = delete;
+  Mutex& operator=(const Mutex&) = delete;
 };
 
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-    extern ::testing::internal::Mutex mutex
+#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
 
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+  ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
 
 // We cannot name this class MutexLock because the ctor declaration would
 // conflict with a macro named MutexLock, which is defined on some
@@ -1433,15 +1421,15 @@ class GTEST_API_ Mutex {
 // "MutexLock l(&mu)".  Hence the typedef trick below.
 class GTestMutexLock {
  public:
-  explicit GTestMutexLock(Mutex* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
+  explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }
 
   ~GTestMutexLock() { mutex_->Unlock(); }
 
  private:
   Mutex* const mutex_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+  GTestMutexLock(const GTestMutexLock&) = delete;
+  GTestMutexLock& operator=(const GTestMutexLock&) = delete;
 };
 
 typedef GTestMutexLock MutexLock;
@@ -1468,7 +1456,8 @@ class ThreadLocalBase {
   virtual ~ThreadLocalBase() {}
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+  ThreadLocalBase(const ThreadLocalBase&) = delete;
+  ThreadLocalBase& operator=(const ThreadLocalBase&) = delete;
 };
 
 // Maps a thread to a set of ThreadLocals that have values instantiated on that
@@ -1497,7 +1486,7 @@ class GTEST_API_ ThreadWithParamBase {
     virtual void Run() = 0;
   };
 
-  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  ThreadWithParamBase(Runnable* runnable, Notification* thread_can_start);
   virtual ~ThreadWithParamBase();
 
  private:
@@ -1511,30 +1500,26 @@ class ThreadWithParam : public ThreadWithParamBase {
   typedef void UserThreadFunc(T);
 
   ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
-      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
-  }
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {}
   virtual ~ThreadWithParam() {}
 
  private:
   class RunnableImpl : public Runnable {
    public:
-    RunnableImpl(UserThreadFunc* func, T param)
-        : func_(func),
-          param_(param) {
-    }
+    RunnableImpl(UserThreadFunc* func, T param) : func_(func), param_(param) {}
     virtual ~RunnableImpl() {}
-    virtual void Run() {
-      func_(param_);
-    }
+    virtual void Run() { func_(param_); }
 
    private:
     UserThreadFunc* const func_;
     const T param_;
 
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+    RunnableImpl(const RunnableImpl&) = delete;
+    RunnableImpl& operator=(const RunnableImpl&) = delete;
   };
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+  ThreadWithParam(const ThreadWithParam&) = delete;
+  ThreadWithParam& operator=(const ThreadWithParam&) = delete;
 };
 
 // Implements thread-local storage on Windows systems.
@@ -1571,7 +1556,7 @@ class ThreadLocal : public ThreadLocalBase {
   explicit ThreadLocal(const T& value)
       : default_factory_(new InstanceValueHolderFactory(value)) {}
 
-  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+  ~ThreadLocal() override { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
 
   T* pointer() { return GetOrCreateValue(); }
   const T* pointer() const { return GetOrCreateValue(); }
@@ -1590,16 +1575,17 @@ class ThreadLocal : public ThreadLocalBase {
 
    private:
     T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+    ValueHolder(const ValueHolder&) = delete;
+    ValueHolder& operator=(const ValueHolder&) = delete;
   };
 
-
   T* GetOrCreateValue() const {
     return static_cast<ValueHolder*>(
-        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+               ThreadLocalRegistry::GetValueOnCurrentThread(this))
+        ->pointer();
   }
 
-  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+  ThreadLocalValueHolderBase* NewValueForCurrentThread() const override {
     return default_factory_->MakeNewHolder();
   }
 
@@ -1610,7 +1596,8 @@ class ThreadLocal : public ThreadLocalBase {
     virtual ValueHolder* MakeNewHolder() const = 0;
 
    private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+    ValueHolderFactory(const ValueHolderFactory&) = delete;
+    ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;
   };
 
   class DefaultValueHolderFactory : public ValueHolderFactory {
@@ -1619,7 +1606,9 @@ class ThreadLocal : public ThreadLocalBase {
     ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
 
    private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+    DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;
+    DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =
+        delete;
   };
 
   class InstanceValueHolderFactory : public ValueHolderFactory {
@@ -1632,15 +1621,18 @@ class ThreadLocal : public ThreadLocalBase {
    private:
     const T value_;  // The value for each thread.
 
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+    InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;
+    InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =
+        delete;
   };
 
   std::unique_ptr<ValueHolderFactory> default_factory_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+  ThreadLocal(const ThreadLocal&) = delete;
+  ThreadLocal& operator=(const ThreadLocal&) = delete;
 };
 
-# elif GTEST_HAS_PTHREAD
+#elif GTEST_HAS_PTHREAD
 
 // MutexBase and Mutex implement mutex on pthreads-based platforms.
 class MutexBase {
@@ -1687,8 +1679,8 @@ class MutexBase {
 };
 
 // Forward-declares a static mutex.
-#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
-     extern ::testing::internal::MutexBase mutex
+#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::MutexBase mutex
 
 // Defines and statically (i.e. at link time) initializes a static mutex.
 // The initialization list here does not explicitly initialize each field,
@@ -1707,12 +1699,11 @@ class Mutex : public MutexBase {
     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
     has_owner_ = false;
   }
-  ~Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
-  }
+  ~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); }
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+  Mutex(const Mutex&) = delete;
+  Mutex& operator=(const Mutex&) = delete;
 };
 
 // We cannot name this class MutexLock because the ctor declaration would
@@ -1722,15 +1713,15 @@ class Mutex : public MutexBase {
 // "MutexLock l(&mu)".  Hence the typedef trick below.
 class GTestMutexLock {
  public:
-  explicit GTestMutexLock(MutexBase* mutex)
-      : mutex_(mutex) { mutex_->Lock(); }
+  explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }
 
   ~GTestMutexLock() { mutex_->Unlock(); }
 
  private:
   MutexBase* const mutex_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+  GTestMutexLock(const GTestMutexLock&) = delete;
+  GTestMutexLock& operator=(const GTestMutexLock&) = delete;
 };
 
 typedef GTestMutexLock MutexLock;
@@ -1741,7 +1732,7 @@ typedef GTestMutexLock MutexLock;
 // C-linkage.  Therefore it cannot be templatized to access
 // ThreadLocal<T>.  Hence the need for class
 // ThreadLocalValueHolderBase.
-class ThreadLocalValueHolderBase {
+class GTEST_API_ ThreadLocalValueHolderBase {
  public:
   virtual ~ThreadLocalValueHolderBase() {}
 };
@@ -1787,7 +1778,8 @@ class GTEST_API_ ThreadLocal {
 
    private:
     T value_;
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+    ValueHolder(const ValueHolder&) = delete;
+    ValueHolder& operator=(const ValueHolder&) = delete;
   };
 
   static pthread_key_t CreateKey() {
@@ -1819,7 +1811,8 @@ class GTEST_API_ ThreadLocal {
     virtual ValueHolder* MakeNewHolder() const = 0;
 
    private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+    ValueHolderFactory(const ValueHolderFactory&) = delete;
+    ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;
   };
 
   class DefaultValueHolderFactory : public ValueHolderFactory {
@@ -1828,7 +1821,9 @@ class GTEST_API_ ThreadLocal {
     ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
 
    private:
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+    DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;
+    DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =
+        delete;
   };
 
   class InstanceValueHolderFactory : public ValueHolderFactory {
@@ -1841,17 +1836,20 @@ class GTEST_API_ ThreadLocal {
    private:
     const T value_;  // The value for each thread.
 
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+    InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;
+    InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =
+        delete;
   };
 
   // A key pthreads uses for looking up per-thread values.
   const pthread_key_t key_;
   std::unique_ptr<ValueHolderFactory> default_factory_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+  ThreadLocal(const ThreadLocal&) = delete;
+  ThreadLocal& operator=(const ThreadLocal&) = delete;
 };
 
-# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+#endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
 
 #else  // GTEST_IS_THREADSAFE
 
@@ -1868,10 +1866,10 @@ class Mutex {
   void AssertHeld() const {}
 };
 
-# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
   extern ::testing::internal::Mutex mutex
 
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
 
 // We cannot name this class MutexLock because the ctor declaration would
 // conflict with a macro named MutexLock, which is defined on some
@@ -1894,6 +1892,7 @@ class GTEST_API_ ThreadLocal {
   const T* pointer() const { return &value_; }
   const T& get() const { return value_; }
   void set(const T& value) { value_ = value; }
+
  private:
   T value_;
 };
@@ -1905,11 +1904,11 @@ class GTEST_API_ ThreadLocal {
 GTEST_API_ size_t GetThreadCount();
 
 #if GTEST_OS_WINDOWS
-# define GTEST_PATH_SEP_ "\\"
-# define GTEST_HAS_ALT_PATH_SEP_ 1
+#define GTEST_PATH_SEP_ "\\"
+#define GTEST_HAS_ALT_PATH_SEP_ 1
 #else
-# define GTEST_PATH_SEP_ "/"
-# define GTEST_HAS_ALT_PATH_SEP_ 0
+#define GTEST_PATH_SEP_ "/"
+#define GTEST_HAS_ALT_PATH_SEP_ 0
 #endif  // GTEST_OS_WINDOWS
 
 // Utilities for char.
@@ -1967,8 +1966,7 @@ inline char ToUpper(char ch) {
 
 inline std::string StripTrailingSpaces(std::string str) {
   std::string::iterator it = str.end();
-  while (it != str.begin() && IsSpace(*--it))
-    it = str.erase(it);
+  while (it != str.begin() && IsSpace(*--it)) it = str.erase(it);
   return str;
 }
 
@@ -1980,56 +1978,31 @@ inline std::string StripTrailingSpaces(std::string str) {
 
 namespace posix {
 
-// Functions with a different name on Windows.
-
+// File system porting.
+#if GTEST_HAS_FILE_SYSTEM
 #if GTEST_OS_WINDOWS
 
 typedef struct _stat StatStruct;
 
-# ifdef __BORLANDC__
-inline int DoIsATTY(int fd) { return isatty(fd); }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-# else  // !__BORLANDC__
-#  if GTEST_OS_WINDOWS_MOBILE
-inline int DoIsATTY(int /* fd */) { return 0; }
-#  else
-inline int DoIsATTY(int fd) { return _isatty(fd); }
-#  endif  // GTEST_OS_WINDOWS_MOBILE
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return _strdup(src); }
-# endif  // __BORLANDC__
-
-# if GTEST_OS_WINDOWS_MOBILE
+#if GTEST_OS_WINDOWS_MOBILE
 inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
 // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
 // time and thus not defined there.
-# else
+#else
 inline int FileNo(FILE* file) { return _fileno(file); }
 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
 inline int RmDir(const char* dir) { return _rmdir(dir); }
-inline bool IsDir(const StatStruct& st) {
-  return (_S_IFDIR & st.st_mode) != 0;
-}
-# endif  // GTEST_OS_WINDOWS_MOBILE
+inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; }
+#endif  // GTEST_OS_WINDOWS_MOBILE
 
 #elif GTEST_OS_ESP8266
 typedef struct stat StatStruct;
 
 inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
 inline int Stat(const char* path, StatStruct* buf) {
   // stat function not implemented on ESP8266
   return 0;
 }
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return strcasecmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
 inline int RmDir(const char* dir) { return rmdir(dir); }
 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 
@@ -2038,14 +2011,56 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 typedef struct stat StatStruct;
 
 inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+#if GTEST_OS_QURT
+// QuRT doesn't support any directory functions, including rmdir
+inline int RmDir(const char*) { return 0; }
+#else
+inline int RmDir(const char* dir) { return rmdir(dir); }
+#endif
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_HAS_FILE_SYSTEM
+
+// Other functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+#ifdef __BORLANDC__
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+#else  // !__BORLANDC__
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
+inline int DoIsATTY(int /* fd */) { return 0; }
+#else
+inline int DoIsATTY(int fd) { return _isatty(fd); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+#endif  // __BORLANDC__
+
+#elif GTEST_OS_ESP8266
+
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+
+#else
+
+inline int DoIsATTY(int fd) { return isatty(fd); }
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return strcasecmp(s1, s2);
 }
 inline char* StrDup(const char* src) { return strdup(src); }
-inline int RmDir(const char* dir) { return rmdir(dir); }
-inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 
 #endif  // GTEST_OS_WINDOWS
 
@@ -2067,9 +2082,10 @@ GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
 // StrError() aren't needed on Windows CE at this time and thus not
 // defined there.
-
-#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
-    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
+#if GTEST_HAS_FILE_SYSTEM
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE &&           \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA && \
+    !GTEST_OS_QURT
 inline int ChDir(const char* dir) { return chdir(dir); }
 #endif
 inline FILE* FOpen(const char* path, const char* mode) {
@@ -2079,18 +2095,18 @@ inline FILE* FOpen(const char* path, const char* mode) {
   std::wstring wide_path = converter.from_bytes(path);
   std::wstring wide_mode = converter.from_bytes(mode);
   return _wfopen(wide_path.c_str(), wide_mode.c_str());
-#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+#else   // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
   return fopen(path, mode);
 #endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
 }
-#if !GTEST_OS_WINDOWS_MOBILE
-inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
+inline FILE* FReopen(const char* path, const char* mode, FILE* stream) {
   return freopen(path, mode, stream);
 }
 inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
-#endif
+#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
 inline int FClose(FILE* fp) { return fclose(fp); }
-#if !GTEST_OS_WINDOWS_MOBILE
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
 inline int Read(int fd, void* buf, unsigned int count) {
   return static_cast<int>(read(fd, buf, count));
 }
@@ -2098,11 +2114,17 @@ inline int Write(int fd, const void* buf, unsigned int count) {
   return static_cast<int>(write(fd, buf, count));
 }
 inline int Close(int fd) { return close(fd); }
+#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
+#endif  // GTEST_HAS_FILE_SYSTEM
+
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
 inline const char* StrError(int errnum) { return strerror(errnum); }
-#endif
+#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
+
 inline const char* GetEnv(const char* name) {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
-    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||          \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \
+    GTEST_OS_QURT
   // We are on an embedded platform, which has no environment variables.
   static_cast<void>(name);  // To prevent 'unused argument' warning.
   return nullptr;
@@ -2134,15 +2156,15 @@ GTEST_DISABLE_MSC_DEPRECATED_POP_()
 // MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
 // function in order to achieve that.  We use macro definition here because
 // snprintf is a variadic function.
-#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
+#if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
 // MSVC 2005 and above support variadic macros.
-# define GTEST_SNPRINTF_(buffer, size, format, ...) \
-     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#define GTEST_SNPRINTF_(buffer, size, format, ...) \
+  _snprintf_s(buffer, size, size, format, __VA_ARGS__)
 #elif defined(_MSC_VER)
 // Windows CE does not define _snprintf_s
-# define GTEST_SNPRINTF_ _snprintf
+#define GTEST_SNPRINTF_ _snprintf
 #else
-# define GTEST_SNPRINTF_ snprintf
+#define GTEST_SNPRINTF_ snprintf
 #endif
 
 // The biggest signed integer type the compiler supports.
@@ -2202,37 +2224,84 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 
 // Macro for referencing flags.
 #if !defined(GTEST_FLAG)
-# define GTEST_FLAG(name) FLAGS_gtest_##name
+#define GTEST_FLAG_NAME_(name) gtest_##name
+#define GTEST_FLAG(name) FLAGS_gtest_##name
 #endif  // !defined(GTEST_FLAG)
 
-#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
-# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
-#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+// Pick a command line flags implementation.
+#if GTEST_HAS_ABSL
 
-#if !defined(GTEST_DECLARE_bool_)
-# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+// Macros for defining flags.
+#define GTEST_DEFINE_bool_(name, default_val, doc) \
+  ABSL_FLAG(bool, GTEST_FLAG_NAME_(name), default_val, doc)
+#define GTEST_DEFINE_int32_(name, default_val, doc) \
+  ABSL_FLAG(int32_t, GTEST_FLAG_NAME_(name), default_val, doc)
+#define GTEST_DEFINE_string_(name, default_val, doc) \
+  ABSL_FLAG(std::string, GTEST_FLAG_NAME_(name), default_val, doc)
 
 // Macros for declaring flags.
-# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
-# define GTEST_DECLARE_int32_(name) \
-    GTEST_API_ extern std::int32_t GTEST_FLAG(name)
-# define GTEST_DECLARE_string_(name) \
-    GTEST_API_ extern ::std::string GTEST_FLAG(name)
+#define GTEST_DECLARE_bool_(name) \
+  ABSL_DECLARE_FLAG(bool, GTEST_FLAG_NAME_(name))
+#define GTEST_DECLARE_int32_(name) \
+  ABSL_DECLARE_FLAG(int32_t, GTEST_FLAG_NAME_(name))
+#define GTEST_DECLARE_string_(name) \
+  ABSL_DECLARE_FLAG(std::string, GTEST_FLAG_NAME_(name))
+
+#define GTEST_FLAG_SAVER_ ::absl::FlagSaver
+
+#define GTEST_FLAG_GET(name) ::absl::GetFlag(GTEST_FLAG(name))
+#define GTEST_FLAG_SET(name, value) \
+  (void)(::absl::SetFlag(&GTEST_FLAG(name), value))
+#define GTEST_USE_OWN_FLAGFILE_FLAG_ 0
+
+#else  // GTEST_HAS_ABSL
 
 // Macros for defining flags.
-# define GTEST_DEFINE_bool_(name, default_val, doc) \
-    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_string_(name, default_val, doc) \
-    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
+#define GTEST_DEFINE_bool_(name, default_val, doc)  \
+  namespace testing {                               \
+  GTEST_API_ bool GTEST_FLAG(name) = (default_val); \
+  }                                                 \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DEFINE_int32_(name, default_val, doc)         \
+  namespace testing {                                       \
+  GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val); \
+  }                                                         \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DEFINE_string_(name, default_val, doc)         \
+  namespace testing {                                        \
+  GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val); \
+  }                                                          \
+  static_assert(true, "no-op to require trailing semicolon")
 
-#endif  // !defined(GTEST_DECLARE_bool_)
+// Macros for declaring flags.
+#define GTEST_DECLARE_bool_(name)          \
+  namespace testing {                      \
+  GTEST_API_ extern bool GTEST_FLAG(name); \
+  }                                        \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DECLARE_int32_(name)                 \
+  namespace testing {                              \
+  GTEST_API_ extern std::int32_t GTEST_FLAG(name); \
+  }                                                \
+  static_assert(true, "no-op to require trailing semicolon")
+#define GTEST_DECLARE_string_(name)                 \
+  namespace testing {                               \
+  GTEST_API_ extern ::std::string GTEST_FLAG(name); \
+  }                                                 \
+  static_assert(true, "no-op to require trailing semicolon")
+
+#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
+#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
+#define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+
+#endif  // GTEST_HAS_ABSL
 
 // Thread annotations
 #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
-# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
-# define GTEST_LOCK_EXCLUDED_(locks)
+#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+#define GTEST_LOCK_EXCLUDED_(locks)
 #endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
 
 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
@@ -2308,6 +2377,7 @@ namespace testing {
 namespace internal {
 template <typename T>
 using Optional = ::absl::optional<T>;
+inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
 }  // namespace internal
 }  // namespace testing
 #else
@@ -2321,6 +2391,7 @@ namespace testing {
 namespace internal {
 template <typename T>
 using Optional = ::std::optional<T>;
+inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
 }  // namespace internal
 }  // namespace testing
 // The case where absl is configured NOT to alias std::optional is not
@@ -2332,7 +2403,7 @@ using Optional = ::std::optional<T>;
 #if GTEST_HAS_ABSL
 // Always use absl::string_view for Matcher<> specializations if googletest
 // is built with absl support.
-# define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#define GTEST_INTERNAL_HAS_STRING_VIEW 1
 #include "absl/strings/string_view.h"
 namespace testing {
 namespace internal {
@@ -2340,11 +2411,11 @@ using StringView = ::absl::string_view;
 }  // namespace internal
 }  // namespace testing
 #else
-# ifdef __has_include
-#   if __has_include(<string_view>) && __cplusplus >= 201703L
+#ifdef __has_include
+#if __has_include(<string_view>) && __cplusplus >= 201703L
 // Otherwise for C++17 and higher use std::string_view for Matcher<>
 // specializations.
-#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#define GTEST_INTERNAL_HAS_STRING_VIEW 1
 #include <string_view>
 namespace testing {
 namespace internal {
@@ -2353,8 +2424,8 @@ using StringView = ::std::string_view;
 }  // namespace testing
 // The case where absl is configured NOT to alias std::string_view is not
 // supported.
-#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
-# endif  // __has_include
+#endif  // __has_include(<string_view>) && __cplusplus >= 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL
 
 #if GTEST_HAS_ABSL
diff --git a/googletest/googletest/include/gtest/internal/gtest-string.h b/googletest/googletest/include/gtest/internal/gtest-string.h
index 10f774f96606e5b9b87ba34ec7c52ba475ad85c5..cc0dd7529c165447c9171561092c3ce15d403390 100644
--- a/googletest/googletest/include/gtest/internal/gtest-string.h
+++ b/googletest/googletest/include/gtest/internal/gtest-string.h
@@ -26,7 +26,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file declares the String class and functions used internally by
@@ -36,18 +36,22 @@
 // This header file is #included by gtest-internal.h.
 // It should not be #included by other files.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
 
 #ifdef __BORLANDC__
 // string.h is not guaranteed to provide strcpy on C++ Builder.
-# include <mem.h>
+#include <mem.h>
 #endif
 
 #include <string.h>
+
 #include <cstdint>
+#include <sstream>
 #include <string>
 
 #include "gtest/internal/gtest-port.h"
@@ -123,8 +127,7 @@ class GTEST_API_ String {
   // Unlike strcasecmp(), this function can handle NULL argument(s).
   // A NULL C string is considered different to any non-NULL C string,
   // including the empty string.
-  static bool CaseInsensitiveCStringEquals(const char* lhs,
-                                           const char* rhs);
+  static bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs);
 
   // Compares two wide C strings, ignoring case.  Returns true if and only if
   // they have the same content.
@@ -143,8 +146,8 @@ class GTEST_API_ String {
 
   // Returns true if and only if the given string ends with the given suffix,
   // ignoring case. Any string is considered to end with an empty suffix.
-  static bool EndsWithCaseInsensitive(
-      const std::string& str, const std::string& suffix);
+  static bool EndsWithCaseInsensitive(const std::string& str,
+                                      const std::string& suffix);
 
   // Formats an int value as "%02d".
   static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
@@ -163,7 +166,7 @@ class GTEST_API_ String {
 
  private:
   String();  // Not meant to be instantiated.
-};  // class String
+};           // class String
 
 // Gets the content of the stringstream's buffer as an std::string.  Each '\0'
 // character in the buffer is replaced with "\\0".
diff --git a/googletest/googletest/include/gtest/internal/gtest-type-util.h b/googletest/googletest/include/gtest/internal/gtest-type-util.h
index b87a2e2cace33b8cf1d42a2b3bdb44cbb90dc267..17a470b62658a4e2742d268ed2d61353294b1c09 100644
--- a/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ b/googletest/googletest/include/gtest/internal/gtest-type-util.h
@@ -30,20 +30,26 @@
 // Type utilities needed for implementing typed and type-parameterized
 // tests.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
+// IWYU pragma: private, include "gtest/gtest.h"
+// IWYU pragma: friend gtest/.*
+// IWYU pragma: friend gmock/.*
 
 #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
 
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
 #include "gtest/internal/gtest-port.h"
 
 // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
 // libstdc++ (which is where cxxabi.h comes from).
-# if GTEST_HAS_CXXABI_H_
-#  include <cxxabi.h>
-# elif defined(__HP_aCC)
-#  include <acxx_demangle.h>
-# endif  // GTEST_HASH_CXXABI_H_
+#if GTEST_HAS_CXXABI_H_
+#include <cxxabi.h>
+#elif defined(__HP_aCC)
+#include <acxx_demangle.h>
+#endif  // GTEST_HASH_CXXABI_H_
 
 namespace testing {
 namespace internal {
@@ -101,7 +107,9 @@ std::string GetTypeName() {
 // A unique type indicating an empty node
 struct None {};
 
-# define GTEST_TEMPLATE_ template <typename T> class
+#define GTEST_TEMPLATE_ \
+  template <typename T> \
+  class
 
 // The template "selector" struct TemplateSel<Tmpl> is used to
 // represent Tmpl, which must be a class template with one type
@@ -119,8 +127,7 @@ struct TemplateSel {
   };
 };
 
-# define GTEST_BIND_(TmplSel, T) \
-  TmplSel::template Bind<T>::type
+#define GTEST_BIND_(TmplSel, T) TmplSel::template Bind<T>::type
 
 template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
 struct Templates {
diff --git a/googletest/googletest/samples/prime_tables.h b/googletest/googletest/samples/prime_tables.h
index 3a10352baae5ba71acb607e671d9bf15d16e79ad..7c0286e1aee89c85360d5067961e34477a5eca78 100644
--- a/googletest/googletest/samples/prime_tables.h
+++ b/googletest/googletest/samples/prime_tables.h
@@ -27,8 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
-
 // This provides interface PrimeTable that determines whether a number is a
 // prime and determines a next prime number. This interface is used
 // in Google Test samples demonstrating use of parameterized tests.
@@ -57,7 +55,7 @@ class OnTheFlyPrimeTable : public PrimeTable {
   bool IsPrime(int n) const override {
     if (n <= 1) return false;
 
-    for (int i = 2; i*i <= n; i++) {
+    for (int i = 2; i * i <= n; i++) {
       // n is divisible by an integer other than 1 and itself.
       if ((n % i) == 0) return false;
     }
@@ -104,13 +102,13 @@ class PreCalculatedPrimeTable : public PrimeTable {
 
     // Checks every candidate for prime number (we know that 2 is the only even
     // prime).
-    for (int i = 2; i*i <= max; i += i%2+1) {
+    for (int i = 2; i * i <= max; i += i % 2 + 1) {
       if (!is_prime_[i]) continue;
 
       // Marks all multiples of i (except i itself) as non-prime.
       // We are starting here from i-th multiplier, because all smaller
       // complex numbers were already marked.
-      for (int j = i*i; j <= max; j += i) {
+      for (int j = i * i; j <= max; j += i) {
         is_prime_[j] = false;
       }
     }
diff --git a/googletest/googletest/samples/sample1.cc b/googletest/googletest/samples/sample1.cc
index 1d4275979ff61101bf1ae9c3205f41f40830c336..80b69f415c806c0923c831176ef066b350552aa3 100644
--- a/googletest/googletest/samples/sample1.cc
+++ b/googletest/googletest/samples/sample1.cc
@@ -52,9 +52,9 @@ bool IsPrime(int n) {
   // Now, we have that n is odd and n >= 3.
 
   // Try to divide n by every odd number i, starting from 3
-  for (int i = 3; ; i += 2) {
+  for (int i = 3;; i += 2) {
     // We only have to try i up to the square root of n
-    if (i > n/i) break;
+    if (i > n / i) break;
 
     // Now, we have i <= n/i < n.
     // If n is divisible by i, n is not prime.
diff --git a/googletest/googletest/samples/sample10_unittest.cc b/googletest/googletest/samples/sample10_unittest.cc
index 36cdac2279aeea702e0d3520c77258e9273726a5..95b4811b87d1192f8e545533e18066d3a9b84b90 100644
--- a/googletest/googletest/samples/sample10_unittest.cc
+++ b/googletest/googletest/samples/sample10_unittest.cc
@@ -26,7 +26,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample shows how to use Google Test listener API to implement
 // a primitive leak checker.
 
@@ -104,14 +103,15 @@ TEST(ListenersTest, LeaksWater) {
 }
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   InitGoogleTest(&argc, argv);
 
   bool check_for_leaks = false;
-  if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0 )
+  if (argc > 1 && strcmp(argv[1], "--check_for_leaks") == 0)
     check_for_leaks = true;
   else
-    printf("%s\n", "Run this program with --check_for_leaks to enable "
+    printf("%s\n",
+           "Run this program with --check_for_leaks to enable "
            "custom leak checking in the tests.");
 
   // If we are given the --check_for_leaks command line flag, installs the
diff --git a/googletest/googletest/samples/sample1_unittest.cc b/googletest/googletest/samples/sample1_unittest.cc
index cb08b61a59a9e16b3657861f1c9609001d2096b2..60f2770ca0e7a3983d87c04b6fe502390df5c551 100644
--- a/googletest/googletest/samples/sample1_unittest.cc
+++ b/googletest/googletest/samples/sample1_unittest.cc
@@ -34,14 +34,15 @@
 //
 // Writing a unit test using Google C++ testing framework is easy as 1-2-3:
 
-
 // Step 1. Include necessary header files such that the stuff your
 // test logic needs is declared.
 //
 // Don't forget gtest.h, which declares the testing framework.
 
-#include <limits.h>
 #include "sample1.h"
+
+#include <limits.h>
+
 #include "gtest/gtest.h"
 namespace {
 
@@ -69,7 +70,6 @@ namespace {
 //
 // </TechnicalDetails>
 
-
 // Tests Factorial().
 
 // Tests factorial of negative numbers.
@@ -97,9 +97,7 @@ TEST(FactorialTest, Negative) {
 }
 
 // Tests factorial of 0.
-TEST(FactorialTest, Zero) {
-  EXPECT_EQ(1, Factorial(0));
-}
+TEST(FactorialTest, Zero) { EXPECT_EQ(1, Factorial(0)); }
 
 // Tests factorial of positive numbers.
 TEST(FactorialTest, Positive) {
@@ -109,7 +107,6 @@ TEST(FactorialTest, Positive) {
   EXPECT_EQ(40320, Factorial(8));
 }
 
-
 // Tests IsPrime()
 
 // Tests negative input.
diff --git a/googletest/googletest/samples/sample2.cc b/googletest/googletest/samples/sample2.cc
index d8e8723965a1dc01ea7f656619b71fb5069849da..be7c4c9949f8ac975a25f303287994b4a5be5aef 100644
--- a/googletest/googletest/samples/sample2.cc
+++ b/googletest/googletest/samples/sample2.cc
@@ -38,7 +38,7 @@ const char* MyString::CloneCString(const char* a_c_string) {
   if (a_c_string == nullptr) return nullptr;
 
   const size_t len = strlen(a_c_string);
-  char* const clone = new char[ len + 1 ];
+  char* const clone = new char[len + 1];
   memcpy(clone, a_c_string, len + 1);
 
   return clone;
diff --git a/googletest/googletest/samples/sample2.h b/googletest/googletest/samples/sample2.h
index 0f9868959d215760f4567fe6165e077739947432..15a1ce7781a95fdd991c74c13cd934184aeab3b4 100644
--- a/googletest/googletest/samples/sample2.h
+++ b/googletest/googletest/samples/sample2.h
@@ -34,7 +34,6 @@
 
 #include <string.h>
 
-
 // A simple string class.
 class MyString {
  private:
diff --git a/googletest/googletest/samples/sample2_unittest.cc b/googletest/googletest/samples/sample2_unittest.cc
index 41e31c1767dee55cc5d5c0bea2df267c5d81176d..cd734f943a08726ddde2eb0266e82b5d6eca046e 100644
--- a/googletest/googletest/samples/sample2_unittest.cc
+++ b/googletest/googletest/samples/sample2_unittest.cc
@@ -38,6 +38,7 @@
 // needed.
 
 #include "sample2.h"
+
 #include "gtest/gtest.h"
 namespace {
 // In this example, we test the MyString class (a simple string).
@@ -77,8 +78,7 @@ const char kHelloString[] = "Hello, world!";
 TEST(MyString, ConstructorFromCString) {
   const MyString s(kHelloString);
   EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-  EXPECT_EQ(sizeof(kHelloString)/sizeof(kHelloString[0]) - 1,
-            s.Length());
+  EXPECT_EQ(sizeof(kHelloString) / sizeof(kHelloString[0]) - 1, s.Length());
 }
 
 // Tests the copy c'tor.
diff --git a/googletest/googletest/samples/sample3-inl.h b/googletest/googletest/samples/sample3-inl.h
index 659e0f0bb5df62905bb35f9ab038f2c38d3c0e66..bc3ffb9c409348298c2ee3dc0ff58d8912f7019b 100644
--- a/googletest/googletest/samples/sample3-inl.h
+++ b/googletest/googletest/samples/sample3-inl.h
@@ -34,7 +34,6 @@
 
 #include <stddef.h>
 
-
 // Queue is a simple queue implemented as a singled-linked list.
 //
 // The element type must support copy constructor.
@@ -62,7 +61,7 @@ class QueueNode {
       : element_(an_element), next_(nullptr) {}
 
   // We disable the default assignment operator and copy c'tor.
-  const QueueNode& operator = (const QueueNode&);
+  const QueueNode& operator=(const QueueNode&);
   QueueNode(const QueueNode&);
 
   E element_;
@@ -84,7 +83,7 @@ class Queue {
       // 1. Deletes every node.
       QueueNode<E>* node = head_;
       QueueNode<E>* next = node->next();
-      for (; ;) {
+      for (;;) {
         delete node;
         node = next;
         if (node == nullptr) break;
@@ -162,11 +161,11 @@ class Queue {
  private:
   QueueNode<E>* head_;  // The first node of the queue.
   QueueNode<E>* last_;  // The last node of the queue.
-  size_t size_;  // The number of elements in the queue.
+  size_t size_;         // The number of elements in the queue.
 
   // We disallow copying a queue.
   Queue(const Queue&);
-  const Queue& operator = (const Queue&);
+  const Queue& operator=(const Queue&);
 };
 
 #endif  // GOOGLETEST_SAMPLES_SAMPLE3_INL_H_
diff --git a/googletest/googletest/samples/sample3_unittest.cc b/googletest/googletest/samples/sample3_unittest.cc
index b19416d53c95f084efe51bf8ef23cc693f3c5d40..71609c6a09864bdf735de55f431290afda03e28d 100644
--- a/googletest/googletest/samples/sample3_unittest.cc
+++ b/googletest/googletest/samples/sample3_unittest.cc
@@ -67,7 +67,6 @@ namespace {
 class QueueTestSmpl3 : public testing::Test {
  protected:  // You should make the members protected s.t. they can be
              // accessed from sub-classes.
-
   // virtual void SetUp() will be called before each test is run.  You
   // should define it if you need to initialize the variables.
   // Otherwise, this can be skipped.
@@ -85,15 +84,13 @@ class QueueTestSmpl3 : public testing::Test {
   // }
 
   // A helper function that some test uses.
-  static int Double(int n) {
-    return 2*n;
-  }
+  static int Double(int n) { return 2 * n; }
 
   // A helper function for testing Queue::Map().
-  void MapTester(const Queue<int> * q) {
+  void MapTester(const Queue<int>* q) {
     // Creates a new queue, where each element is twice as big as the
     // corresponding one in q.
-    const Queue<int> * const new_q = q->Map(Double);
+    const Queue<int>* const new_q = q->Map(Double);
 
     // Verifies that the new queue has the same size as q.
     ASSERT_EQ(q->Size(), new_q->Size());
@@ -124,7 +121,7 @@ TEST_F(QueueTestSmpl3, DefaultConstructor) {
 
 // Tests Dequeue().
 TEST_F(QueueTestSmpl3, Dequeue) {
-  int * n = q0_.Dequeue();
+  int* n = q0_.Dequeue();
   EXPECT_TRUE(n == nullptr);
 
   n = q1_.Dequeue();
diff --git a/googletest/googletest/samples/sample4.cc b/googletest/googletest/samples/sample4.cc
index b0ee6093b4a250cf11936ccc8208a612291b8140..489c89b0d34bbfaaac30761e871a0c2f8d7e4e65 100644
--- a/googletest/googletest/samples/sample4.cc
+++ b/googletest/googletest/samples/sample4.cc
@@ -29,26 +29,22 @@
 
 // A sample program demonstrating using Google C++ testing framework.
 
-#include <stdio.h>
-
 #include "sample4.h"
 
+#include <stdio.h>
+
 // Returns the current counter value, and increments it.
-int Counter::Increment() {
-  return counter_++;
-}
+int Counter::Increment() { return counter_++; }
 
 // Returns the current counter value, and decrements it.
 // counter can not be less than 0, return 0 in this case
 int Counter::Decrement() {
   if (counter_ == 0) {
     return counter_;
-  } else  {
+  } else {
     return counter_--;
   }
 }
 
 // Prints the current counter value to STDOUT.
-void Counter::Print() const {
-  printf("%d", counter_);
-}
+void Counter::Print() const { printf("%d", counter_); }
diff --git a/googletest/googletest/samples/sample4_unittest.cc b/googletest/googletest/samples/sample4_unittest.cc
index d5144c0d00f5c7600693ea025802c0d7d5250d2e..fb9973fe666e5e9a3719b49214b71e650d5b71a5 100644
--- a/googletest/googletest/samples/sample4_unittest.cc
+++ b/googletest/googletest/samples/sample4_unittest.cc
@@ -27,8 +27,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "sample4.h"
+
 #include "gtest/gtest.h"
 
 namespace {
diff --git a/googletest/googletest/samples/sample5_unittest.cc b/googletest/googletest/samples/sample5_unittest.cc
index 0a21dd2157707fb32c459248b0c5341609ec0614..cc8c0f012e96eb9edac6401451b2a9cfed27f0aa 100644
--- a/googletest/googletest/samples/sample5_unittest.cc
+++ b/googletest/googletest/samples/sample5_unittest.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample teaches how to reuse a test fixture in multiple test
 // cases by deriving sub-fixtures from it.
 //
@@ -45,9 +44,10 @@
 
 #include <limits.h>
 #include <time.h>
-#include "gtest/gtest.h"
+
 #include "sample1.h"
 #include "sample3-inl.h"
+#include "gtest/gtest.h"
 namespace {
 // In this sample, we want to ensure that every test finishes within
 // ~5 seconds.  If a test takes longer to run, we consider it a
@@ -81,7 +81,6 @@ class QuickTest : public testing::Test {
   time_t start_time_;
 };
 
-
 // We derive a fixture named IntegerFunctionTest from the QuickTest
 // fixture.  All tests using this fixture will be automatically
 // required to be quick.
@@ -90,7 +89,6 @@ class IntegerFunctionTest : public QuickTest {
   // Therefore the body is empty.
 };
 
-
 // Now we can write tests in the IntegerFunctionTest test case.
 
 // Tests Factorial()
@@ -110,7 +108,6 @@ TEST_F(IntegerFunctionTest, Factorial) {
   EXPECT_EQ(40320, Factorial(8));
 }
 
-
 // Tests IsPrime()
 TEST_F(IntegerFunctionTest, IsPrime) {
   // Tests negative input.
@@ -131,7 +128,6 @@ TEST_F(IntegerFunctionTest, IsPrime) {
   EXPECT_TRUE(IsPrime(23));
 }
 
-
 // The next test case (named "QueueTest") also needs to be quick, so
 // we derive another fixture from QuickTest.
 //
@@ -163,13 +159,10 @@ class QueueTest : public QuickTest {
   Queue<int> q2_;
 };
 
-
 // Now, let's write tests using the QueueTest fixture.
 
 // Tests the default constructor.
-TEST_F(QueueTest, DefaultConstructor) {
-  EXPECT_EQ(0u, q0_.Size());
-}
+TEST_F(QueueTest, DefaultConstructor) { EXPECT_EQ(0u, q0_.Size()); }
 
 // Tests Dequeue().
 TEST_F(QueueTest, Dequeue) {
diff --git a/googletest/googletest/samples/sample6_unittest.cc b/googletest/googletest/samples/sample6_unittest.cc
index da317eed5a0d258605c89e0d88fc43c17c1eb290..cf576f0a5354fb80367825858f4e7e618399af30 100644
--- a/googletest/googletest/samples/sample6_unittest.cc
+++ b/googletest/googletest/samples/sample6_unittest.cc
@@ -27,13 +27,11 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample shows how to test common properties of multiple
 // implementations of the same interface (aka interface tests).
 
 // The interface and its implementations are in this header.
 #include "prime_tables.h"
-
 #include "gtest/gtest.h"
 namespace {
 // First, we define some factory functions for creating instances of
@@ -151,8 +149,7 @@ using testing::Types;
 // the PrimeTableTest fixture defined earlier:
 
 template <class T>
-class PrimeTableTest2 : public PrimeTableTest<T> {
-};
+class PrimeTableTest2 : public PrimeTableTest<T> {};
 
 // Then, declare the test case.  The argument is the name of the test
 // fixture, and also the name of the test case (as usual).  The _P
diff --git a/googletest/googletest/samples/sample7_unittest.cc b/googletest/googletest/samples/sample7_unittest.cc
index e0efc29e4a2a977e1a50a45bb375243c968547d7..3ad22cab8d12414408d0cc936a07b68e398575dc 100644
--- a/googletest/googletest/samples/sample7_unittest.cc
+++ b/googletest/googletest/samples/sample7_unittest.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample shows how to test common properties of multiple
 // implementations of an interface (aka interface tests) using
 // value-parameterized tests. Each test in the test case has
@@ -36,7 +35,6 @@
 
 // The interface and its implementations are in this header.
 #include "prime_tables.h"
-
 #include "gtest/gtest.h"
 namespace {
 
@@ -50,9 +48,7 @@ using ::testing::Values;
 // SetUp() method and delete them in TearDown() method.
 typedef PrimeTable* CreatePrimeTableFunc();
 
-PrimeTable* CreateOnTheFlyPrimeTable() {
-  return new OnTheFlyPrimeTable();
-}
+PrimeTable* CreateOnTheFlyPrimeTable() { return new OnTheFlyPrimeTable(); }
 
 template <size_t max_precalculated>
 PrimeTable* CreatePreCalculatedPrimeTable() {
diff --git a/googletest/googletest/samples/sample8_unittest.cc b/googletest/googletest/samples/sample8_unittest.cc
index 10488b0ea4509a6591f06b05ac5ae14433b652ee..9717e28608e66c3c902f5cdcb083292576342d36 100644
--- a/googletest/googletest/samples/sample8_unittest.cc
+++ b/googletest/googletest/samples/sample8_unittest.cc
@@ -27,14 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample shows how to test code relying on some global flag variables.
 // Combine() helps with generating all possible combinations of such flags,
 // and each test is given one combination as a parameter.
 
 // Use class definitions to test from this header.
 #include "prime_tables.h"
-
 #include "gtest/gtest.h"
 namespace {
 
@@ -79,10 +77,10 @@ class HybridPrimeTable : public PrimeTable {
   int max_precalculated_;
 };
 
-using ::testing::TestWithParam;
 using ::testing::Bool;
-using ::testing::Values;
 using ::testing::Combine;
+using ::testing::TestWithParam;
+using ::testing::Values;
 
 // To test all code paths for HybridPrimeTable we must test it with numbers
 // both within and outside PreCalculatedPrimeTable's capacity and also with
diff --git a/googletest/googletest/samples/sample9_unittest.cc b/googletest/googletest/samples/sample9_unittest.cc
index e502d08d73e7d70bede86cbd711754cd09de841c..d627ea7d5776e4a360d56e9b67329af5426b663e 100644
--- a/googletest/googletest/samples/sample9_unittest.cc
+++ b/googletest/googletest/samples/sample9_unittest.cc
@@ -26,10 +26,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This sample shows how to use Google Test listener API to implement
 // an alternative console output and how to use the UnitTest reflection API
-// to enumerate test cases and tests and to inspect their results.
+// to enumerate test suites and tests and to inspect their results.
 
 #include <stdio.h>
 
@@ -38,10 +37,10 @@
 using ::testing::EmptyTestEventListener;
 using ::testing::InitGoogleTest;
 using ::testing::Test;
-using ::testing::TestCase;
 using ::testing::TestEventListeners;
 using ::testing::TestInfo;
 using ::testing::TestPartResult;
+using ::testing::TestSuite;
 using ::testing::UnitTest;
 namespace {
 // Provides alternative output mode which produces minimal amount of
@@ -59,29 +58,23 @@ class TersePrinter : public EmptyTestEventListener {
 
   // Called before a test starts.
   void OnTestStart(const TestInfo& test_info) override {
-    fprintf(stdout,
-            "*** Test %s.%s starting.\n",
-            test_info.test_case_name(),
+    fprintf(stdout, "*** Test %s.%s starting.\n", test_info.test_suite_name(),
             test_info.name());
     fflush(stdout);
   }
 
   // Called after a failed assertion or a SUCCEED() invocation.
   void OnTestPartResult(const TestPartResult& test_part_result) override {
-    fprintf(stdout,
-            "%s in %s:%d\n%s\n",
+    fprintf(stdout, "%s in %s:%d\n%s\n",
             test_part_result.failed() ? "*** Failure" : "Success",
-            test_part_result.file_name(),
-            test_part_result.line_number(),
+            test_part_result.file_name(), test_part_result.line_number(),
             test_part_result.summary());
     fflush(stdout);
   }
 
   // Called after a test ends.
   void OnTestEnd(const TestInfo& test_info) override {
-    fprintf(stdout,
-            "*** Test %s.%s ending.\n",
-            test_info.test_case_name(),
+    fprintf(stdout, "*** Test %s.%s ending.\n", test_info.test_suite_name(),
             test_info.name());
     fflush(stdout);
   }
@@ -101,14 +94,15 @@ TEST(CustomOutputTest, Fails) {
 }
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   InitGoogleTest(&argc, argv);
 
   bool terse_output = false;
-  if (argc > 1 && strcmp(argv[1], "--terse_output") == 0 )
+  if (argc > 1 && strcmp(argv[1], "--terse_output") == 0)
     terse_output = true;
   else
-    printf("%s\n", "Run this program with --terse_output to change the way "
+    printf("%s\n",
+           "Run this program with --terse_output to change the way "
            "it prints its output.");
 
   UnitTest& unit_test = *UnitTest::GetInstance();
@@ -149,8 +143,7 @@ int main(int argc, char **argv) {
   }
 
   // Test that were meant to fail should not affect the test program outcome.
-  if (unexpectedly_failed_tests == 0)
-    ret_val = 0;
+  if (unexpectedly_failed_tests == 0) ret_val = 0;
 
   return ret_val;
 }
diff --git a/googletest/googletest/src/gtest-all.cc b/googletest/googletest/src/gtest-all.cc
index b6cdc0e80efc703b62b4d7c7d672e7a2474b2957..daa568f99b3aa64949dfa57799de90df557a31aa 100644
--- a/googletest/googletest/src/gtest-all.cc
+++ b/googletest/googletest/src/gtest-all.cc
@@ -42,7 +42,7 @@
 #include "gtest/gtest.h"
 
 // The following lines pull in the real gtest *.cc files.
-#include "src/gtest.cc"
+#include "src/gtest-assertion-result.cc"
 #include "src/gtest-death-test.cc"
 #include "src/gtest-filepath.cc"
 #include "src/gtest-matchers.cc"
@@ -50,8 +50,9 @@
 #include "src/gtest-printers.cc"
 #include "src/gtest-test-part.cc"
 #include "src/gtest-typed-test.cc"
+#include "src/gtest.cc"
 
 #include "src/hwext/gtest-tag.cc"
 #include "src/hwext/gtest-ext.cc"
 #include "src/hwext/gtest-filter.cc"
-#include "src/hwext/gtest-utils.cc"
+#include "src/hwext/gtest-utils.cc"
\ No newline at end of file
diff --git a/googletest/googletest/src/gtest-assertion-result.cc b/googletest/googletest/src/gtest-assertion-result.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f1c0b10dc9e50124bfdb999f7778b6ad8791141c
--- /dev/null
+++ b/googletest/googletest/src/gtest-assertion-result.cc
@@ -0,0 +1,77 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file defines the AssertionResult type.
+
+#include "gtest/gtest-assertion-result.h"
+
+#include <string>
+#include <utility>
+
+#include "gtest/gtest-message.h"
+
+namespace testing {
+
+// AssertionResult constructors.
+// Used in EXPECT_TRUE/FALSE(assertion_result).
+AssertionResult::AssertionResult(const AssertionResult& other)
+    : success_(other.success_),
+      message_(other.message_.get() != nullptr
+                   ? new ::std::string(*other.message_)
+                   : static_cast< ::std::string*>(nullptr)) {}
+
+// Swaps two AssertionResults.
+void AssertionResult::swap(AssertionResult& other) {
+  using std::swap;
+  swap(success_, other.success_);
+  swap(message_, other.message_);
+}
+
+// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+AssertionResult AssertionResult::operator!() const {
+  AssertionResult negation(!success_);
+  if (message_.get() != nullptr) negation << *message_;
+  return negation;
+}
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() { return AssertionResult(true); }
+
+// Makes a failed assertion result.
+AssertionResult AssertionFailure() { return AssertionResult(false); }
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionFailure() << message;
+}
+
+}  // namespace testing
diff --git a/googletest/googletest/src/gtest-death-test.cc b/googletest/googletest/src/gtest-death-test.cc
index bf4f6331dac129b49d5f5ae2f23c33dd8b6adbd6..b6968a9c949db5f96bb2010e82881e68efa6abe6 100644
--- a/googletest/googletest/src/gtest-death-test.cc
+++ b/googletest/googletest/src/gtest-death-test.cc
@@ -35,49 +35,49 @@
 #include <functional>
 #include <utility>
 
-#include "gtest/internal/gtest-port.h"
 #include "gtest/internal/custom/gtest.h"
+#include "gtest/internal/gtest-port.h"
 
 #if GTEST_HAS_DEATH_TEST
 
-# if GTEST_OS_MAC
-#  include <crt_externs.h>
-# endif  // GTEST_OS_MAC
-
-# include <errno.h>
-# include <fcntl.h>
-# include <limits.h>
-
-# if GTEST_OS_LINUX
-#  include <signal.h>
-# endif  // GTEST_OS_LINUX
-
-# include <stdarg.h>
-
-# if GTEST_OS_WINDOWS
-#  include <windows.h>
-# else
-#  include <sys/mman.h>
-#  include <sys/wait.h>
-# endif  // GTEST_OS_WINDOWS
-
-# if GTEST_OS_QNX
-#  include <spawn.h>
-# endif  // GTEST_OS_QNX
-
-# if GTEST_OS_FUCHSIA
-#  include <lib/fdio/fd.h>
-#  include <lib/fdio/io.h>
-#  include <lib/fdio/spawn.h>
-#  include <lib/zx/channel.h>
-#  include <lib/zx/port.h>
-#  include <lib/zx/process.h>
-#  include <lib/zx/socket.h>
-#  include <zircon/processargs.h>
-#  include <zircon/syscalls.h>
-#  include <zircon/syscalls/policy.h>
-#  include <zircon/syscalls/port.h>
-# endif  // GTEST_OS_FUCHSIA
+#if GTEST_OS_MAC
+#include <crt_externs.h>
+#endif  // GTEST_OS_MAC
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#if GTEST_OS_LINUX
+#include <signal.h>
+#endif  // GTEST_OS_LINUX
+
+#include <stdarg.h>
+
+#if GTEST_OS_WINDOWS
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#include <sys/wait.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_QNX
+#include <spawn.h>
+#endif  // GTEST_OS_QNX
+
+#if GTEST_OS_FUCHSIA
+#include <lib/fdio/fd.h>
+#include <lib/fdio/io.h>
+#include <lib/fdio/spawn.h>
+#include <lib/zx/channel.h>
+#include <lib/zx/port.h>
+#include <lib/zx/process.h>
+#include <lib/zx/socket.h>
+#include <zircon/processargs.h>
+#include <zircon/syscalls.h>
+#include <zircon/syscalls/policy.h>
+#include <zircon/syscalls/port.h>
+#endif  // GTEST_OS_FUCHSIA
 
 #endif  // GTEST_HAS_DEATH_TEST
 
@@ -96,9 +96,12 @@ namespace testing {
 // used internally at Google, is "threadsafe".
 static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;
 
+}  // namespace testing
+
 GTEST_DEFINE_string_(
     death_test_style,
-    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    testing::internal::StringFromGTestEnv("death_test_style",
+                                          testing::kDefaultDeathTestStyle),
     "Indicates how to run a death test in a forked child process: "
     "\"threadsafe\" (child process re-executes the test binary "
     "from the beginning, running only the specific death test) or "
@@ -107,7 +110,7 @@ GTEST_DEFINE_string_(
 
 GTEST_DEFINE_bool_(
     death_test_use_fork,
-    internal::BoolFromGTestEnv("death_test_use_fork", false),
+    testing::internal::BoolFromGTestEnv("death_test_use_fork", false),
     "Instructs to use fork()/_exit() instead of clone() in death tests. "
     "Ignored and always uses fork() on POSIX systems where clone() is not "
     "implemented. Useful when running under valgrind or similar tools if "
@@ -117,7 +120,6 @@ GTEST_DEFINE_bool_(
     "work in 99% of the cases. Once valgrind is fixed, this flag will "
     "most likely be removed.");
 
-namespace internal {
 GTEST_DEFINE_string_(
     internal_run_death_test, "",
     "Indicates the file, line number, temporal index of "
@@ -126,7 +128,8 @@ GTEST_DEFINE_string_(
     "the '|' characters.  This flag is specified if and only if the "
     "current process is a sub-process launched for running a thread-safe "
     "death test.  FOR INTERNAL USE ONLY.");
-}  // namespace internal
+
+namespace testing {
 
 #if GTEST_HAS_DEATH_TEST
 
@@ -134,9 +137,9 @@ namespace internal {
 
 // Valid only for fast death tests. Indicates the code is running in the
 // child process of a fast style death test.
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 static bool g_in_fast_death_test_child = false;
-# endif
+#endif
 
 // Returns a Boolean value indicating whether the caller is currently
 // executing in the context of the death test child process.  Tools such as
@@ -144,16 +147,16 @@ static bool g_in_fast_death_test_child = false;
 // tests.  IMPORTANT: This is an internal utility.  Using it may break the
 // implementation of death tests.  User code MUST NOT use it.
 bool InDeathTestChild() {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
   // On Windows and Fuchsia, death tests are thread-safe regardless of the value
   // of the death_test_style flag.
-  return !GTEST_FLAG(internal_run_death_test).empty();
+  return !GTEST_FLAG_GET(internal_run_death_test).empty();
 
-# else
+#else
 
-  if (GTEST_FLAG(death_test_style) == "threadsafe")
-    return !GTEST_FLAG(internal_run_death_test).empty();
+  if (GTEST_FLAG_GET(death_test_style) == "threadsafe")
+    return !GTEST_FLAG_GET(internal_run_death_test).empty();
   else
     return g_in_fast_death_test_child;
 #endif
@@ -162,40 +165,38 @@ bool InDeathTestChild() {
 }  // namespace internal
 
 // ExitedWithCode constructor.
-ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
-}
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {}
 
 // ExitedWithCode function-call operator.
 bool ExitedWithCode::operator()(int exit_status) const {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
   return exit_status == exit_code_;
 
-# else
+#else
 
   return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
 
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 }
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 // KilledBySignal constructor.
-KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
-}
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {}
 
 // KilledBySignal function-call operator.
 bool KilledBySignal::operator()(int exit_status) const {
-#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+#if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
   {
     bool result;
     if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
       return result;
     }
   }
-#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+#endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
   return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
 }
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 
 namespace internal {
 
@@ -206,23 +207,23 @@ namespace internal {
 static std::string ExitSummary(int exit_code) {
   Message m;
 
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
   m << "Exited with exit status " << exit_code;
 
-# else
+#else
 
   if (WIFEXITED(exit_code)) {
     m << "Exited with exit status " << WEXITSTATUS(exit_code);
   } else if (WIFSIGNALED(exit_code)) {
     m << "Terminated by signal " << WTERMSIG(exit_code);
   }
-#  ifdef WCOREDUMP
+#ifdef WCOREDUMP
   if (WCOREDUMP(exit_code)) {
     m << " (core dumped)";
   }
-#  endif
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#endif
+#endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
   return m.GetString();
 }
@@ -233,7 +234,7 @@ bool ExitedUnsuccessfully(int exit_status) {
   return !ExitedWithCode(0)(exit_status);
 }
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 // Generates a textual failure message when a death test finds more than
 // one thread running, or cannot determine the number of threads, prior
 // to executing the given statement.  It is the responsibility of the
@@ -248,13 +249,13 @@ static std::string DeathTestThreadWarning(size_t thread_count) {
     msg << "detected " << thread_count << " threads.";
   }
   msg << " See "
-         "https://github.com/google/googletest/blob/master/docs/"
+         "https://github.com/google/googletest/blob/main/docs/"
          "advanced.md#death-tests-and-threads"
       << " for more explanation and suggested solutions, especially if"
       << " this is the last message you see before your test times out.";
   return msg.GetString();
 }
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
 
 // Flag characters for reporting a death test that did not die.
 static const char kDeathTestLived = 'L';
@@ -283,7 +284,7 @@ enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
 // message is propagated back to the parent process.  Otherwise, the
 // message is simply printed to stderr.  In either case, the program
 // then exits with status 1.
-static void DeathTestAbort(const std::string& message) {
+[[noreturn]] static void DeathTestAbort(const std::string& message) {
   // On a POSIX system, this function may be called from a threadsafe-style
   // death test child process, which operates on a very small stack.  Use
   // the heap for any additional non-minuscule memory requirements.
@@ -304,14 +305,14 @@ static void DeathTestAbort(const std::string& message) {
 
 // A replacement for CHECK that calls DeathTestAbort if the assertion
 // fails.
-# define GTEST_DEATH_TEST_CHECK_(expression) \
-  do { \
-    if (!::testing::internal::IsTrue(expression)) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression); \
-    } \
+#define GTEST_DEATH_TEST_CHECK_(expression)                              \
+  do {                                                                   \
+    if (!::testing::internal::IsTrue(expression)) {                      \
+      DeathTestAbort(::std::string("CHECK failed: File ") + __FILE__ +   \
+                     ", line " +                                         \
+                     ::testing::internal::StreamableToString(__LINE__) + \
+                     ": " + #expression);                                \
+    }                                                                    \
   } while (::testing::internal::AlwaysFalse())
 
 // This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
@@ -321,23 +322,23 @@ static void DeathTestAbort(const std::string& message) {
 // evaluates the expression as long as it evaluates to -1 and sets
 // errno to EINTR.  If the expression evaluates to -1 but errno is
 // something other than EINTR, DeathTestAbort is called.
-# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
-  do { \
-    int gtest_retval; \
-    do { \
-      gtest_retval = (expression); \
-    } while (gtest_retval == -1 && errno == EINTR); \
-    if (gtest_retval == -1) { \
-      DeathTestAbort( \
-          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
-          + ::testing::internal::StreamableToString(__LINE__) + ": " \
-          + #expression + " != -1"); \
-    } \
+#define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression)                      \
+  do {                                                                   \
+    int gtest_retval;                                                    \
+    do {                                                                 \
+      gtest_retval = (expression);                                       \
+    } while (gtest_retval == -1 && errno == EINTR);                      \
+    if (gtest_retval == -1) {                                            \
+      DeathTestAbort(::std::string("CHECK failed: File ") + __FILE__ +   \
+                     ", line " +                                         \
+                     ::testing::internal::StreamableToString(__LINE__) + \
+                     ": " + #expression + " != -1");                     \
+    }                                                                    \
   } while (::testing::internal::AlwaysFalse())
 
 // Returns the message describing the last system error in errno.
 std::string GetLastErrnoDescription() {
-    return errno == 0 ? "" : posix::StrError(errno);
+  return errno == 0 ? "" : posix::StrError(errno);
 }
 
 // This is called from a death test parent process to read a failure
@@ -370,8 +371,9 @@ static void FailFromInternalError(int fd) {
 DeathTest::DeathTest() {
   TestInfo* const info = GetUnitTestImpl()->current_test_info();
   if (info == nullptr) {
-    DeathTestAbort("Cannot run a death test outside of a TEST or "
-                   "TEST_F construct");
+    DeathTestAbort(
+        "Cannot run a death test outside of a TEST or "
+        "TEST_F construct");
   }
 }
 
@@ -500,9 +502,7 @@ void DeathTestImpl::ReadAndInterpretStatusByte() {
   set_read_fd(-1);
 }
 
-std::string DeathTestImpl::GetErrorLogs() {
-  return GetCapturedStderr();
-}
+std::string DeathTestImpl::GetErrorLogs() { return GetCapturedStderr(); }
 
 // Signals that the death test code which should have exited, didn't.
 // Should be called only in a death test child process.
@@ -512,9 +512,9 @@ void DeathTestImpl::Abort(AbortReason reason) {
   // The parent process considers the death test to be a failure if
   // it finds any data in our pipe.  So, here we write a single flag byte
   // to the pipe, then exit.
-  const char status_ch =
-      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
-      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
+  const char status_ch = reason == TEST_DID_NOT_DIE       ? kDeathTestLived
+                         : reason == TEST_THREW_EXCEPTION ? kDeathTestThrew
+                                                          : kDeathTestReturned;
 
   GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
   // We are leaking the descriptor here because on some platforms (i.e.,
@@ -533,7 +533,7 @@ void DeathTestImpl::Abort(AbortReason reason) {
 // much easier.
 static ::std::string FormatDeathTestOutput(const ::std::string& output) {
   ::std::string ret;
-  for (size_t at = 0; ; ) {
+  for (size_t at = 0;;) {
     const size_t line_end = output.find('\n', at);
     ret += "[  DEATH   ] ";
     if (line_end == ::std::string::npos) {
@@ -568,8 +568,7 @@ static ::std::string FormatDeathTestOutput(const ::std::string& output) {
 // the first failing condition, in the order given above, is the one that is
 // reported. Also sets the last death test message string.
 bool DeathTestImpl::Passed(bool status_ok) {
-  if (!spawned())
-    return false;
+  if (!spawned()) return false;
 
   const std::string error_message = GetErrorLogs();
 
@@ -580,15 +579,18 @@ bool DeathTestImpl::Passed(bool status_ok) {
   switch (outcome()) {
     case LIVED:
       buffer << "    Result: failed to die.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+             << " Error msg:\n"
+             << FormatDeathTestOutput(error_message);
       break;
     case THREW:
       buffer << "    Result: threw an exception.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+             << " Error msg:\n"
+             << FormatDeathTestOutput(error_message);
       break;
     case RETURNED:
       buffer << "    Result: illegal return in test statement.\n"
-             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+             << " Error msg:\n"
+             << FormatDeathTestOutput(error_message);
       break;
     case DIED:
       if (status_ok) {
@@ -605,7 +607,8 @@ bool DeathTestImpl::Passed(bool status_ok) {
       } else {
         buffer << "    Result: died but not with expected exit code:\n"
                << "            " << ExitSummary(status()) << "\n"
-               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+               << "Actual msg:\n"
+               << FormatDeathTestOutput(error_message);
       }
       break;
     case IN_PROGRESS:
@@ -618,7 +621,7 @@ bool DeathTestImpl::Passed(bool status_ok) {
   return success;
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 // WindowsDeathTest implements death tests on Windows. Due to the
 // specifics of starting new processes on Windows, death tests there are
 // always threadsafe, and Google Test considers the
@@ -679,14 +682,12 @@ class WindowsDeathTest : public DeathTestImpl {
 // status, or 0 if no child process exists.  As a side effect, sets the
 // outcome data member.
 int WindowsDeathTest::Wait() {
-  if (!spawned())
-    return 0;
+  if (!spawned()) return 0;
 
   // Wait until the child either signals that it has acquired the write end
   // of the pipe or it dies.
-  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
-  switch (::WaitForMultipleObjects(2,
-                                   wait_handles,
+  const HANDLE wait_handles[2] = {child_handle_.Get(), event_handle_.Get()};
+  switch (::WaitForMultipleObjects(2, wait_handles,
                                    FALSE,  // Waits for any of the handles.
                                    INFINITE)) {
     case WAIT_OBJECT_0:
@@ -707,9 +708,8 @@ int WindowsDeathTest::Wait() {
   // returns immediately if the child has already exited, regardless of
   // whether previous calls to WaitForMultipleObjects synchronized on this
   // handle or not.
-  GTEST_DEATH_TEST_CHECK_(
-      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
-                                             INFINITE));
+  GTEST_DEATH_TEST_CHECK_(WAIT_OBJECT_0 ==
+                          ::WaitForSingleObject(child_handle_.Get(), INFINITE));
   DWORD status_code;
   GTEST_DEATH_TEST_CHECK_(
       ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
@@ -742,12 +742,12 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
                                                  nullptr, TRUE};
   HANDLE read_handle, write_handle;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
-                   0)  // Default buffer size.
-      != FALSE);
-  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
-                                O_RDONLY));
+  GTEST_DEATH_TEST_CHECK_(::CreatePipe(&read_handle, &write_handle,
+                                       &handles_are_inheritable,
+                                       0)  // Default buffer size.
+                          != FALSE);
+  set_read_fd(
+      ::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), O_RDONLY));
   write_handle_.Reset(write_handle);
   event_handle_.Reset(::CreateEvent(
       &handles_are_inheritable,
@@ -756,27 +756,26 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
       nullptr));  // The even is unnamed.
   GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
   const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
+                                  "filter=" + info->test_suite_name() + "." +
+                                  info->name();
   const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
-      "=" + file_ + "|" + StreamableToString(line_) + "|" +
-      StreamableToString(death_test_index) + "|" +
+      std::string("--") + GTEST_FLAG_PREFIX_ +
+      "internal_run_death_test=" + file_ + "|" + StreamableToString(line_) +
+      "|" + StreamableToString(death_test_index) + "|" +
       StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
       // size_t has the same width as pointers on both 32-bit and 64-bit
       // Windows platforms.
       // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
-      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
-      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + "|" +
+      StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
 
   char executable_path[_MAX_PATH + 1];  // NOLINT
   GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
                                                                 executable_path,
                                                                 _MAX_PATH));
 
-  std::string command_line =
-      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
-      internal_flag + "\"";
+  std::string command_line = std::string(::GetCommandLineA()) + " " +
+                             filter_flag + " \"" + internal_flag + "\"";
 
   DeathTest::set_last_death_test_message("");
 
@@ -796,8 +795,8 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   GTEST_DEATH_TEST_CHECK_(
       ::CreateProcessA(
           executable_path, const_cast<char*>(command_line.c_str()),
-          nullptr,  // Retuned process handle is not inheritable.
-          nullptr,  // Retuned thread handle is not inheritable.
+          nullptr,  // Returned process handle is not inheritable.
+          nullptr,  // Returned thread handle is not inheritable.
           TRUE,  // Child inherits all inheritable handles (for write_handle_).
           0x0,   // Default creation flags.
           nullptr,  // Inherit the parent's environment.
@@ -809,7 +808,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   return OVERSEE_TEST;
 }
 
-# elif GTEST_OS_FUCHSIA
+#elif GTEST_OS_FUCHSIA
 
 class FuchsiaDeathTest : public DeathTestImpl {
  public:
@@ -855,18 +854,13 @@ class Arguments {
   template <typename Str>
   void AddArguments(const ::std::vector<Str>& arguments) {
     for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
+         i != arguments.end(); ++i) {
       args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
     }
   }
-  char* const* Argv() {
-    return &args_[0];
-  }
+  char* const* Argv() { return &args_[0]; }
 
-  int size() {
-    return static_cast<int>(args_.size()) - 1;
-  }
+  int size() { return static_cast<int>(args_.size()) - 1; }
 
  private:
   std::vector<char*> args_;
@@ -880,8 +874,7 @@ int FuchsiaDeathTest::Wait() {
   const int kSocketKey = 1;
   const int kExceptionKey = 2;
 
-  if (!spawned())
-    return 0;
+  if (!spawned()) return 0;
 
   // Create a port to wait for socket/task/exception events.
   zx_status_t status_zx;
@@ -890,8 +883,8 @@ int FuchsiaDeathTest::Wait() {
   GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
 
   // Register to wait for the child process to terminate.
-  status_zx = child_process_.wait_async(
-      port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
+  status_zx =
+      child_process_.wait_async(port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
   GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
 
   // Register to wait for the socket to be readable or closed.
@@ -900,8 +893,8 @@ int FuchsiaDeathTest::Wait() {
   GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
 
   // Register to wait for an exception.
-  status_zx = exception_channel_.wait_async(
-      port, kExceptionKey, ZX_CHANNEL_READABLE, 0);
+  status_zx = exception_channel_.wait_async(port, kExceptionKey,
+                                            ZX_CHANNEL_READABLE, 0);
   GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
 
   bool process_terminated = false;
@@ -931,9 +924,9 @@ int FuchsiaDeathTest::Wait() {
           size_t old_length = captured_stderr_.length();
           size_t bytes_read = 0;
           captured_stderr_.resize(old_length + kBufferSize);
-          status_zx = stderr_socket_.read(
-              0, &captured_stderr_.front() + old_length, kBufferSize,
-              &bytes_read);
+          status_zx =
+              stderr_socket_.read(0, &captured_stderr_.front() + old_length,
+                                  kBufferSize, &bytes_read);
           captured_stderr_.resize(old_length + bytes_read);
         } while (status_zx == ZX_OK);
         if (status_zx == ZX_ERR_PEER_CLOSED) {
@@ -987,13 +980,12 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
 
   // Build the child process command line.
   const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|"
-      + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index);
+                                  "filter=" + info->test_suite_name() + "." +
+                                  info->name();
+  const std::string internal_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                    kInternalRunDeathTestFlag + "=" + file_ +
+                                    "|" + StreamableToString(line_) + "|" +
+                                    StreamableToString(death_test_index);
   Arguments args;
   args.AddArguments(GetInjectableArgvs());
   args.AddArgument(filter_flag.c_str());
@@ -1016,8 +1008,7 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
 
   // Create a socket pair will be used to receive the child process' stderr.
   zx::socket stderr_producer_socket;
-  status =
-      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
+  status = zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
   GTEST_DEATH_TEST_CHECK_(status >= 0);
   int stderr_producer_fd = -1;
   status =
@@ -1034,35 +1025,32 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
 
   // Create a child job.
   zx_handle_t child_job = ZX_HANDLE_INVALID;
-  status = zx_job_create(zx_job_default(), 0, & child_job);
+  status = zx_job_create(zx_job_default(), 0, &child_job);
   GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
   zx_policy_basic_t policy;
   policy.condition = ZX_POL_NEW_ANY;
   policy.policy = ZX_POL_ACTION_ALLOW;
-  status = zx_job_set_policy(
-      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
+  status = zx_job_set_policy(child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC,
+                             &policy, 1);
   GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
 
   // Create an exception channel attached to the |child_job|, to allow
   // us to suppress the system default exception handler from firing.
-  status =
-      zx_task_create_exception_channel(
-          child_job, 0, exception_channel_.reset_and_get_address());
+  status = zx_task_create_exception_channel(
+      child_job, 0, exception_channel_.reset_and_get_address());
   GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
 
   // Spawn the child process.
-  status = fdio_spawn_etc(
-      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
-      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
+  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0],
+                          args.Argv(), nullptr, 2, spawn_actions,
+                          child_process_.reset_and_get_address(), nullptr);
   GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
 
   set_spawned(true);
   return OVERSEE_TEST;
 }
 
-std::string FuchsiaDeathTest::GetErrorLogs() {
-  return captured_stderr_;
-}
+std::string FuchsiaDeathTest::GetErrorLogs() { return captured_stderr_; }
 
 #else  // We are neither on Windows, nor on Fuchsia.
 
@@ -1093,8 +1081,7 @@ ForkingDeathTest::ForkingDeathTest(const char* a_statement,
 // status, or 0 if no child process exists.  As a side effect, sets the
 // outcome data member.
 int ForkingDeathTest::Wait() {
-  if (!spawned())
-    return 0;
+  if (!spawned()) return 0;
 
   ReadAndInterpretStatusByte();
 
@@ -1173,11 +1160,11 @@ class ExecDeathTest : public ForkingDeathTest {
  private:
   static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
     ::std::vector<std::string> args = GetInjectableArgvs();
-#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+#if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
     ::std::vector<std::string> extra_args =
         GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
     args.insert(args.end(), extra_args.begin(), extra_args.end());
-#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+#endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
     return args;
   }
   // The name of the file in which the death test is located.
@@ -1204,14 +1191,11 @@ class Arguments {
   template <typename Str>
   void AddArguments(const ::std::vector<Str>& arguments) {
     for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
+         i != arguments.end(); ++i) {
       args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
     }
   }
-  char* const* Argv() {
-    return &args_[0];
-  }
+  char* const* Argv() { return &args_[0]; }
 
  private:
   std::vector<char*> args_;
@@ -1224,9 +1208,9 @@ struct ExecDeathTestArgs {
   int close_fd;       // File descriptor to close; the read end of a pipe
 };
 
-#  if GTEST_OS_QNX
+#if GTEST_OS_QNX
 extern "C" char** environ;
-#  else  // GTEST_OS_QNX
+#else   // GTEST_OS_QNX
 // The main function for a threadsafe-style death test child process.
 // This function is called in a clone()-ed process and thus must avoid
 // any potentially unsafe operations like malloc or libc functions.
@@ -1241,8 +1225,8 @@ static int ExecDeathTestChildMain(void* child_arg) {
       UnitTest::GetInstance()->original_working_dir();
   // We can safely call chdir() as it's a direct system call.
   if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
+    DeathTestAbort(std::string("chdir(\"") + original_dir +
+                   "\") failed: " + GetLastErrnoDescription());
     return EXIT_FAILURE;
   }
 
@@ -1253,13 +1237,12 @@ static int ExecDeathTestChildMain(void* child_arg) {
   // one path separator.
   execv(args->argv[0], args->argv);
   DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
-                 original_dir + " failed: " +
-                 GetLastErrnoDescription());
+                 original_dir + " failed: " + GetLastErrnoDescription());
   return EXIT_FAILURE;
 }
-#  endif  // GTEST_OS_QNX
+#endif  // GTEST_OS_QNX
 
-#  if GTEST_HAS_CLONE
+#if GTEST_HAS_CLONE
 // Two utility routines that together determine the direction the stack
 // grows.
 // This could be accomplished more elegantly by a single recursive
@@ -1293,7 +1276,7 @@ static bool StackGrowsDown() {
   StackLowerThanAddress(&dummy, &result);
   return result;
 }
-#  endif  // GTEST_HAS_CLONE
+#endif  // GTEST_HAS_CLONE
 
 // Spawns a child process with the same executable as the current process in
 // a thread-safe manner and instructs it to run the death test.  The
@@ -1303,10 +1286,10 @@ static bool StackGrowsDown() {
 // spawn(2) there instead.  The function dies with an error message if
 // anything goes wrong.
 static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
-  ExecDeathTestArgs args = { argv, close_fd };
+  ExecDeathTestArgs args = {argv, close_fd};
   pid_t child_pid = -1;
 
-#  if GTEST_OS_QNX
+#if GTEST_OS_QNX
   // Obtains the current directory and sets it to be closed in the child
   // process.
   const int cwd_fd = open(".", O_RDONLY);
@@ -1319,16 +1302,16 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
       UnitTest::GetInstance()->original_working_dir();
   // We can safely call chdir() as it's a direct system call.
   if (chdir(original_dir) != 0) {
-    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
-                   GetLastErrnoDescription());
+    DeathTestAbort(std::string("chdir(\"") + original_dir +
+                   "\") failed: " + GetLastErrnoDescription());
     return EXIT_FAILURE;
   }
 
   int fd_flags;
   // Set close_fd to be closed after spawn.
   GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
-                                        fd_flags | FD_CLOEXEC));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      fcntl(close_fd, F_SETFD, fd_flags | FD_CLOEXEC));
   struct inheritance inherit = {0};
   // spawn is a system call.
   child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
@@ -1336,8 +1319,8 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
   GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
   GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
 
-#  else   // GTEST_OS_QNX
-#   if GTEST_OS_LINUX
+#else  // GTEST_OS_QNX
+#if GTEST_OS_LINUX
   // When a SIGPROF signal is received while fork() or clone() are executing,
   // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
   // it after the call to fork()/clone() is complete.
@@ -1346,12 +1329,12 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
   memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
   sigemptyset(&ignore_sigprof_action.sa_mask);
   ignore_sigprof_action.sa_handler = SIG_IGN;
-  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
-      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
-#   endif  // GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#endif  // GTEST_OS_LINUX
 
-#   if GTEST_HAS_CLONE
-  const bool use_fork = GTEST_FLAG(death_test_use_fork);
+#if GTEST_HAS_CLONE
+  const bool use_fork = GTEST_FLAG_GET(death_test_use_fork);
 
   if (!use_fork) {
     static const bool stack_grows_down = StackGrowsDown();
@@ -1370,7 +1353,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
     const size_t kMaxStackAlignment = 64;
     void* const stack_top =
         static_cast<char*>(stack) +
-            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+        (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
     GTEST_DEATH_TEST_CHECK_(
         static_cast<size_t>(stack_size) > kMaxStackAlignment &&
         reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
@@ -1379,19 +1362,19 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 
     GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
   }
-#   else
+#else
   const bool use_fork = true;
-#   endif  // GTEST_HAS_CLONE
+#endif  // GTEST_HAS_CLONE
 
   if (use_fork && (child_pid = fork()) == 0) {
-      ExecDeathTestChildMain(&args);
-      _exit(0);
+    ExecDeathTestChildMain(&args);
+    _exit(0);
   }
-#  endif  // GTEST_OS_QNX
-#  if GTEST_OS_LINUX
+#endif  // GTEST_OS_QNX
+#if GTEST_OS_LINUX
   GTEST_DEATH_TEST_CHECK_SYSCALL_(
       sigaction(SIGPROF, &saved_sigprof_action, nullptr));
-#  endif  // GTEST_OS_LINUX
+#endif  // GTEST_OS_LINUX
 
   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
   return child_pid;
@@ -1420,13 +1403,13 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
   GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
 
   const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|" + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index) + "|"
-      + StreamableToString(pipe_fd[1]);
+                                  "filter=" + info->test_suite_name() + "." +
+                                  info->name();
+  const std::string internal_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                    "internal_run_death_test=" + file_ + "|" +
+                                    StreamableToString(line_) + "|" +
+                                    StreamableToString(death_test_index) + "|" +
+                                    StreamableToString(pipe_fd[1]);
   Arguments args;
   args.AddArguments(GetArgvsForDeathTestChildProcess());
   args.AddArgument(filter_flag.c_str());
@@ -1447,7 +1430,7 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
   return OVERSEE_TEST;
 }
 
-# endif  // !GTEST_OS_WINDOWS
+#endif  // !GTEST_OS_WINDOWS
 
 // Creates a concrete DeathTest-derived class that depends on the
 // --gtest_death_test_style flag, and sets the pointer pointed to
@@ -1461,15 +1444,15 @@ bool DefaultDeathTestFactory::Create(const char* statement,
   UnitTestImpl* const impl = GetUnitTestImpl();
   const InternalRunDeathTestFlag* const flag =
       impl->internal_run_death_test_flag();
-  const int death_test_index = impl->current_test_info()
-      ->increment_death_test_count();
+  const int death_test_index =
+      impl->current_test_info()->increment_death_test_count();
 
   if (flag != nullptr) {
     if (death_test_index > flag->index()) {
       DeathTest::set_last_death_test_message(
-          "Death test count (" + StreamableToString(death_test_index)
-          + ") somehow exceeded expected maximum ("
-          + StreamableToString(flag->index()) + ")");
+          "Death test count (" + StreamableToString(death_test_index) +
+          ") somehow exceeded expected maximum (" +
+          StreamableToString(flag->index()) + ")");
       return false;
     }
 
@@ -1480,50 +1463,50 @@ bool DefaultDeathTestFactory::Create(const char* statement,
     }
   }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
+  if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
+      GTEST_FLAG_GET(death_test_style) == "fast") {
     *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
   }
 
-# elif GTEST_OS_FUCHSIA
+#elif GTEST_OS_FUCHSIA
 
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
+  if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
+      GTEST_FLAG_GET(death_test_style) == "fast") {
     *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
   }
 
-# else
+#else
 
-  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+  if (GTEST_FLAG_GET(death_test_style) == "threadsafe") {
     *test = new ExecDeathTest(statement, std::move(matcher), file, line);
-  } else if (GTEST_FLAG(death_test_style) == "fast") {
+  } else if (GTEST_FLAG_GET(death_test_style) == "fast") {
     *test = new NoExecDeathTest(statement, std::move(matcher));
   }
 
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
   else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
-    DeathTest::set_last_death_test_message(
-        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
-        + "\" encountered");
+    DeathTest::set_last_death_test_message("Unknown death test style \"" +
+                                           GTEST_FLAG_GET(death_test_style) +
+                                           "\" encountered");
     return false;
   }
 
   return true;
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 // Recreates the pipe and event handles from the provided parameters,
 // signals the event, and returns a file descriptor wrapped around the pipe
 // handle. This function is called in the child process only.
 static int GetStatusFileDescriptor(unsigned int parent_process_id,
-                            size_t write_handle_as_size_t,
-                            size_t event_handle_as_size_t) {
+                                   size_t write_handle_as_size_t,
+                                   size_t event_handle_as_size_t) {
   AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
-                                                   FALSE,  // Non-inheritable.
-                                                   parent_process_id));
+                                                 FALSE,  // Non-inheritable.
+                                                 parent_process_id));
   if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
     DeathTestAbort("Unable to open parent process " +
                    StreamableToString(parent_process_id));
@@ -1531,8 +1514,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
 
   GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
 
-  const HANDLE write_handle =
-      reinterpret_cast<HANDLE>(write_handle_as_size_t);
+  const HANDLE write_handle = reinterpret_cast<HANDLE>(write_handle_as_size_t);
   HANDLE dup_write_handle;
 
   // The newly initialized handle is accessible only in the parent
@@ -1554,9 +1536,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
   HANDLE dup_event_handle;
 
   if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
-                         ::GetCurrentProcess(), &dup_event_handle,
-                         0x0,
-                         FALSE,
+                         ::GetCurrentProcess(), &dup_event_handle, 0x0, FALSE,
                          DUPLICATE_SAME_ACCESS)) {
     DeathTestAbort("Unable to duplicate the event handle " +
                    StreamableToString(event_handle_as_size_t) +
@@ -1578,61 +1558,57 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
 
   return write_fd;
 }
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 // Returns a newly created InternalRunDeathTestFlag object with fields
 // initialized from the GTEST_FLAG(internal_run_death_test) flag if
 // the flag is specified; otherwise returns NULL.
 InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
-  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
+  if (GTEST_FLAG_GET(internal_run_death_test) == "") return nullptr;
 
   // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
   // can use it here.
   int line = -1;
   int index = -1;
   ::std::vector< ::std::string> fields;
-  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
+  SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
   int write_fd = -1;
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
   unsigned int parent_process_id = 0;
   size_t write_handle_as_size_t = 0;
   size_t event_handle_as_size_t = 0;
 
-  if (fields.size() != 6
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &parent_process_id)
-      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
-      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
+  if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) ||
+      !ParseNaturalNumber(fields[2], &index) ||
+      !ParseNaturalNumber(fields[3], &parent_process_id) ||
+      !ParseNaturalNumber(fields[4], &write_handle_as_size_t) ||
+      !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
     DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
-                   GTEST_FLAG(internal_run_death_test));
+                   GTEST_FLAG_GET(internal_run_death_test));
   }
-  write_fd = GetStatusFileDescriptor(parent_process_id,
-                                     write_handle_as_size_t,
+  write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
                                      event_handle_as_size_t);
 
-# elif GTEST_OS_FUCHSIA
+#elif GTEST_OS_FUCHSIA
 
-  if (fields.size() != 3
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
+  if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
+      !ParseNaturalNumber(fields[2], &index)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG_GET(internal_run_death_test));
   }
 
-# else
+#else
 
-  if (fields.size() != 4
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)
-      || !ParseNaturalNumber(fields[3], &write_fd)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
+  if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) ||
+      !ParseNaturalNumber(fields[2], &index) ||
+      !ParseNaturalNumber(fields[3], &write_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG_GET(internal_run_death_test));
   }
 
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
   return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
 }
diff --git a/googletest/googletest/src/gtest-filepath.cc b/googletest/googletest/src/gtest-filepath.cc
index 0b5629401b5a87c894fa1e2b95554c08874ace87..9d79ea49d8ae66ae8beecfc4c9ab761f6276650d 100644
--- a/googletest/googletest/src/gtest-filepath.cc
+++ b/googletest/googletest/src/gtest-filepath.cc
@@ -30,31 +30,35 @@
 #include "gtest/internal/gtest-filepath.h"
 
 #include <stdlib.h>
-#include "gtest/internal/gtest-port.h"
+
 #include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-port.h"
 
 #if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
+#include <windows.h>
 #elif GTEST_OS_WINDOWS
-# include <direct.h>
-# include <io.h>
+#include <direct.h>
+#include <io.h>
 #else
-# include <limits.h>
-# include <climits>  // Some Linux distributions define PATH_MAX here.
-#endif  // GTEST_OS_WINDOWS_MOBILE
+#include <limits.h>
+
+#include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif              // GTEST_OS_WINDOWS_MOBILE
 
 #include "gtest/internal/gtest-string.h"
 
 #if GTEST_OS_WINDOWS
-# define GTEST_PATH_MAX_ _MAX_PATH
+#define GTEST_PATH_MAX_ _MAX_PATH
 #elif defined(PATH_MAX)
-# define GTEST_PATH_MAX_ PATH_MAX
+#define GTEST_PATH_MAX_ PATH_MAX
 #elif defined(_XOPEN_PATH_MAX)
-# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
 #else
-# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#define GTEST_PATH_MAX_ _POSIX_PATH_MAX
 #endif  // GTEST_OS_WINDOWS
 
+#if GTEST_HAS_FILE_SYSTEM
+
 namespace testing {
 namespace internal {
 
@@ -66,16 +70,16 @@ namespace internal {
 const char kPathSeparator = '\\';
 const char kAlternatePathSeparator = '/';
 const char kAlternatePathSeparatorString[] = "/";
-# if GTEST_OS_WINDOWS_MOBILE
+#if GTEST_OS_WINDOWS_MOBILE
 // Windows CE doesn't have a current directory. You should not use
 // the current directory in tests on Windows CE, but this at least
 // provides a reasonable fallback.
 const char kCurrentDirectoryString[] = "\\";
 // Windows CE doesn't define INVALID_FILE_ATTRIBUTES
 const DWORD kInvalidFileAttributes = 0xffffffff;
-# else
+#else
 const char kCurrentDirectoryString[] = ".\\";
-# endif  // GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_OS_WINDOWS_MOBILE
 #else
 const char kPathSeparator = '/';
 const char kCurrentDirectoryString[] = "./";
@@ -94,22 +98,22 @@ static bool IsPathSeparator(char c) {
 FilePath FilePath::GetCurrentDir() {
 #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
     GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
-    GTEST_OS_XTENSA
+    GTEST_OS_XTENSA || GTEST_OS_QURT
   // These platforms do not have a current directory, so we just return
   // something reasonable.
   return FilePath(kCurrentDirectoryString);
 #elif GTEST_OS_WINDOWS
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
   return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
 #else
-  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
   char* result = getcwd(cwd, sizeof(cwd));
-# if GTEST_OS_NACL
+#if GTEST_OS_NACL
   // getcwd will likely fail in NaCl due to the sandbox, so return something
   // reasonable. The user may have provided a shim implementation for getcwd,
   // however, so fallback only when failure is detected.
   return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
-# endif  // GTEST_OS_NACL
+#endif  // GTEST_OS_NACL
   return FilePath(result == nullptr ? "" : cwd);
 #endif  // GTEST_OS_WINDOWS_MOBILE
 }
@@ -121,8 +125,8 @@ FilePath FilePath::GetCurrentDir() {
 FilePath FilePath::RemoveExtension(const char* extension) const {
   const std::string dot_extension = std::string(".") + extension;
   if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
-    return FilePath(pathname_.substr(
-        0, pathname_.length() - dot_extension.length()));
+    return FilePath(
+        pathname_.substr(0, pathname_.length() - dot_extension.length()));
   }
   return *this;
 }
@@ -143,6 +147,45 @@ const char* FilePath::FindLastPathSeparator() const {
   return last_sep;
 }
 
+size_t FilePath::CalculateRootLength() const {
+  const auto &path = pathname_;
+  auto s = path.begin();
+  auto end = path.end();
+#if GTEST_OS_WINDOWS
+  if (end - s >= 2 && s[1] == ':' &&
+      (end - s == 2 || IsPathSeparator(s[2])) &&
+      (('A' <= s[0] && s[0] <= 'Z') || ('a' <= s[0] && s[0] <= 'z'))) {
+    // A typical absolute path like "C:\Windows" or "D:"
+    s += 2;
+    if (s != end) {
+      ++s;
+    }
+  } else if (end - s >= 3 && IsPathSeparator(*s) && IsPathSeparator(*(s + 1))
+             && !IsPathSeparator(*(s + 2))) {
+    // Move past the "\\" prefix in a UNC path like "\\Server\Share\Folder"
+    s += 2;
+    // Skip 2 components and their following separators ("Server\" and "Share\")
+    for (int i = 0; i < 2; ++i) {
+      while (s != end) {
+        bool stop = IsPathSeparator(*s);
+        ++s;
+        if (stop) {
+          break;
+        }
+      }
+    }
+  } else if (s != end && IsPathSeparator(*s)) {
+    // A drive-rooted path like "\Windows"
+    ++s;
+  }
+#else
+  if (s != end && IsPathSeparator(*s)) {
+    ++s;
+  }
+#endif
+  return static_cast<size_t>(s - path.begin());
+}
+
 // Returns a copy of the FilePath with the directory part removed.
 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
@@ -178,15 +221,14 @@ FilePath FilePath::RemoveFileName() const {
 // than zero (e.g., 12), returns "dir/test_12.xml".
 // On Windows platform, uses \ as the separator rather than /.
 FilePath FilePath::MakeFileName(const FilePath& directory,
-                                const FilePath& base_name,
-                                int number,
+                                const FilePath& base_name, int number,
                                 const char* extension) {
   std::string file;
   if (number == 0) {
     file = base_name.string() + "." + extension;
   } else {
-    file = base_name.string() + "_" + StreamableToString(number)
-        + "." + extension;
+    file =
+        base_name.string() + "_" + StreamableToString(number) + "." + extension;
   }
   return ConcatPaths(directory, FilePath(file));
 }
@@ -195,8 +237,7 @@ FilePath FilePath::MakeFileName(const FilePath& directory,
 // On Windows, uses \ as the separator rather than /.
 FilePath FilePath::ConcatPaths(const FilePath& directory,
                                const FilePath& relative_path) {
-  if (directory.IsEmpty())
-    return relative_path;
+  if (directory.IsEmpty()) return relative_path;
   const FilePath dir(directory.RemoveTrailingPathSeparator());
   return FilePath(dir.string() + kPathSeparator + relative_path.string());
 }
@@ -207,7 +248,7 @@ bool FilePath::FileOrDirectoryExists() const {
 #if GTEST_OS_WINDOWS_MOBILE
   LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
   const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
+  delete[] unicode;
   return attributes != kInvalidFileAttributes;
 #else
   posix::StatStruct file_stat{};
@@ -222,8 +263,8 @@ bool FilePath::DirectoryExists() const {
 #if GTEST_OS_WINDOWS
   // Don't strip off trailing separator if path is a root directory on
   // Windows (like "C:\\").
-  const FilePath& path(IsRootDirectory() ? *this :
-                                           RemoveTrailingPathSeparator());
+  const FilePath& path(IsRootDirectory() ? *this
+                                         : RemoveTrailingPathSeparator());
 #else
   const FilePath& path(*this);
 #endif
@@ -231,42 +272,31 @@ bool FilePath::DirectoryExists() const {
 #if GTEST_OS_WINDOWS_MOBILE
   LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
   const DWORD attributes = GetFileAttributes(unicode);
-  delete [] unicode;
+  delete[] unicode;
   if ((attributes != kInvalidFileAttributes) &&
       (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
     result = true;
   }
 #else
   posix::StatStruct file_stat{};
-  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
-      posix::IsDir(file_stat);
+  result =
+      posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat);
 #endif  // GTEST_OS_WINDOWS_MOBILE
 
   return result;
 }
 
 // Returns true if pathname describes a root directory. (Windows has one
-// root directory per disk drive.)
+// root directory per disk drive. UNC share roots are also included.)
 bool FilePath::IsRootDirectory() const {
-#if GTEST_OS_WINDOWS
-  return pathname_.length() == 3 && IsAbsolutePath();
-#else
-  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
-#endif
+  size_t root_length = CalculateRootLength();
+  return root_length > 0 && root_length == pathname_.size() &&
+         IsPathSeparator(pathname_[root_length - 1]);
 }
 
 // Returns true if pathname describes an absolute path.
 bool FilePath::IsAbsolutePath() const {
-  const char* const name = pathname_.c_str();
-#if GTEST_OS_WINDOWS
-  return pathname_.length() >= 3 &&
-     ((name[0] >= 'a' && name[0] <= 'z') ||
-      (name[0] >= 'A' && name[0] <= 'Z')) &&
-     name[1] == ':' &&
-     IsPathSeparator(name[2]);
-#else
-  return IsPathSeparator(name[0]);
-#endif
+  return CalculateRootLength() > 0;
 }
 
 // Returns a pathname for a file that does not currently exist. The pathname
@@ -321,10 +351,10 @@ bool FilePath::CreateFolder() const {
   FilePath removed_sep(this->RemoveTrailingPathSeparator());
   LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
   int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
-  delete [] unicode;
+  delete[] unicode;
 #elif GTEST_OS_WINDOWS
   int result = _mkdir(pathname_.c_str());
-#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA || GTEST_OS_QURT
   // do nothing
   int result = 0;
 #else
@@ -341,25 +371,34 @@ bool FilePath::CreateFolder() const {
 // name, otherwise return the name string unmodified.
 // On Windows platform, uses \ as the separator, other platforms use /.
 FilePath FilePath::RemoveTrailingPathSeparator() const {
-  return IsDirectory()
-      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
-      : *this;
+  return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1))
+                       : *this;
 }
 
 // Removes any redundant separators that might be in the pathname.
 // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
 // redundancies that might be in a pathname involving "." or "..".
+// Note that "\\Host\Share" does not contain a redundancy on Windows!
 void FilePath::Normalize() {
   auto out = pathname_.begin();
 
-  for (const char character : pathname_) {
+  auto i = pathname_.cbegin();
+#if GTEST_OS_WINDOWS
+  // UNC paths are treated specially
+  if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
+      IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
+    *(out++) = kPathSeparator;
+    *(out++) = kPathSeparator;
+  }
+#endif
+  while (i != pathname_.end()) {
+    const char character = *i;
     if (!IsPathSeparator(character)) {
       *(out++) = character;
     } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
       *(out++) = kPathSeparator;
-    } else {
-      continue;
     }
+    ++i;
   }
 
   pathname_.erase(out, pathname_.end());
@@ -367,3 +406,5 @@ void FilePath::Normalize() {
 
 }  // namespace internal
 }  // namespace testing
+
+#endif  // GTEST_HAS_FILE_SYSTEM
diff --git a/googletest/googletest/src/gtest-internal-inl.h b/googletest/googletest/src/gtest-internal-inl.h
index 6d8cecbbb3828786e56e222999aeccffa1ee23fe..2c9db4f207854dba430fbed9ad79490289c46e13 100644
--- a/googletest/googletest/src/gtest-internal-inl.h
+++ b/googletest/googletest/src/gtest-internal-inl.h
@@ -35,7 +35,7 @@
 #define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
 
 #ifndef _WIN32_WCE
-# include <errno.h>
+#include <errno.h>
 #endif  // !_WIN32_WCE
 #include <stddef.h>
 #include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
@@ -44,28 +44,27 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "gtest/internal/gtest-port.h"
 
 #if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
+#include <arpa/inet.h>  // NOLINT
+#include <netdb.h>      // NOLINT
 #endif
 
 #if GTEST_OS_WINDOWS
-# include <windows.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS
+#include <windows.h>  // NOLINT
+#endif                // GTEST_OS_WINDOWS
 
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
 
-namespace testing {
-
 // Declares the flags.
 //
 // We don't want the users to modify this flag in the code, but want
@@ -73,32 +72,13 @@ namespace testing {
 // declare it here as opposed to in gtest.h.
 GTEST_DECLARE_bool_(death_test_use_fork);
 
+namespace testing {
 namespace internal {
 
 // The value of GetTestTypeId() as seen from within the Google Test
 // library.  This is solely for testing GetTestTypeId().
 GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
 
-// Names of the flags (needed for parsing Google Test flags).
-const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
-const char kBreakOnFailureFlag[] = "break_on_failure";
-const char kCatchExceptionsFlag[] = "catch_exceptions";
-const char kColorFlag[] = "color";
-const char kFailFast[] = "fail_fast";
-const char kFilterFlag[] = "filter";
-const char kListTestsFlag[] = "list_tests";
-const char kOutputFlag[] = "output";
-const char kBriefFlag[] = "brief";
-const char kPrintTimeFlag[] = "print_time";
-const char kPrintUTF8Flag[] = "print_utf8";
-const char kRandomSeedFlag[] = "random_seed";
-const char kRepeatFlag[] = "repeat";
-const char kShuffleFlag[] = "shuffle";
-const char kStackTraceDepthFlag[] = "stack_trace_depth";
-const char kStreamResultToFlag[] = "stream_result_to";
-const char kThrowOnFailureFlag[] = "throw_on_failure";
-const char kFlagfileFlag[] = "flagfile";
-
 // A valid random seed must be in [1, kMaxRandomSeed].
 const int kMaxRandomSeed = 99999;
 
@@ -125,21 +105,21 @@ GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-GTEST_API_ bool ParseInt32Flag(
-    const char* str, const char* flag, int32_t* value);
+GTEST_API_ bool ParseFlag(const char* str, const char* flag, int32_t* value);
 
 // Returns a random seed in range [1, kMaxRandomSeed] based on the
 // given --gtest_random_seed flag value.
 inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
-  const unsigned int raw_seed = (random_seed_flag == 0) ?
-      static_cast<unsigned int>(GetTimeInMillis()) :
-      static_cast<unsigned int>(random_seed_flag);
+  const unsigned int raw_seed =
+      (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
+                              : static_cast<unsigned int>(random_seed_flag);
 
   // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
   // it's easy to type.
   const int normalized_seed =
       static_cast<int>((raw_seed - 1U) %
-                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
+                       static_cast<unsigned int>(kMaxRandomSeed)) +
+      1;
   return normalized_seed;
 }
 
@@ -160,50 +140,54 @@ class GTestFlagSaver {
  public:
   // The c'tor.
   GTestFlagSaver() {
-    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
-    break_on_failure_ = GTEST_FLAG(break_on_failure);
-    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
-    color_ = GTEST_FLAG(color);
-    death_test_style_ = GTEST_FLAG(death_test_style);
-    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    fail_fast_ = GTEST_FLAG(fail_fast);
-    filter_ = GTEST_FLAG(filter);
-    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
-    list_tests_ = GTEST_FLAG(list_tests);
-    output_ = GTEST_FLAG(output);
-    brief_ = GTEST_FLAG(brief);
-    print_time_ = GTEST_FLAG(print_time);
-    print_utf8_ = GTEST_FLAG(print_utf8);
-    random_seed_ = GTEST_FLAG(random_seed);
-    repeat_ = GTEST_FLAG(repeat);
-    shuffle_ = GTEST_FLAG(shuffle);
-    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
-    stream_result_to_ = GTEST_FLAG(stream_result_to);
-    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
+    also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests);
+    break_on_failure_ = GTEST_FLAG_GET(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions);
+    color_ = GTEST_FLAG_GET(color);
+    death_test_style_ = GTEST_FLAG_GET(death_test_style);
+    death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork);
+    fail_fast_ = GTEST_FLAG_GET(fail_fast);
+    filter_ = GTEST_FLAG_GET(filter);
+    internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test);
+    list_tests_ = GTEST_FLAG_GET(list_tests);
+    output_ = GTEST_FLAG_GET(output);
+    brief_ = GTEST_FLAG_GET(brief);
+    print_time_ = GTEST_FLAG_GET(print_time);
+    print_utf8_ = GTEST_FLAG_GET(print_utf8);
+    random_seed_ = GTEST_FLAG_GET(random_seed);
+    repeat_ = GTEST_FLAG_GET(repeat);
+    recreate_environments_when_repeating_ =
+        GTEST_FLAG_GET(recreate_environments_when_repeating);
+    shuffle_ = GTEST_FLAG_GET(shuffle);
+    stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth);
+    stream_result_to_ = GTEST_FLAG_GET(stream_result_to);
+    throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure);
   }
 
   // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
   ~GTestFlagSaver() {
-    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
-    GTEST_FLAG(break_on_failure) = break_on_failure_;
-    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
-    GTEST_FLAG(color) = color_;
-    GTEST_FLAG(death_test_style) = death_test_style_;
-    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
-    GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(fail_fast) = fail_fast_;
-    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
-    GTEST_FLAG(list_tests) = list_tests_;
-    GTEST_FLAG(output) = output_;
-    GTEST_FLAG(brief) = brief_;
-    GTEST_FLAG(print_time) = print_time_;
-    GTEST_FLAG(print_utf8) = print_utf8_;
-    GTEST_FLAG(random_seed) = random_seed_;
-    GTEST_FLAG(repeat) = repeat_;
-    GTEST_FLAG(shuffle) = shuffle_;
-    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
-    GTEST_FLAG(stream_result_to) = stream_result_to_;
-    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
+    GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
+    GTEST_FLAG_SET(break_on_failure, break_on_failure_);
+    GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
+    GTEST_FLAG_SET(color, color_);
+    GTEST_FLAG_SET(death_test_style, death_test_style_);
+    GTEST_FLAG_SET(death_test_use_fork, death_test_use_fork_);
+    GTEST_FLAG_SET(filter, filter_);
+    GTEST_FLAG_SET(fail_fast, fail_fast_);
+    GTEST_FLAG_SET(internal_run_death_test, internal_run_death_test_);
+    GTEST_FLAG_SET(list_tests, list_tests_);
+    GTEST_FLAG_SET(output, output_);
+    GTEST_FLAG_SET(brief, brief_);
+    GTEST_FLAG_SET(print_time, print_time_);
+    GTEST_FLAG_SET(print_utf8, print_utf8_);
+    GTEST_FLAG_SET(random_seed, random_seed_);
+    GTEST_FLAG_SET(repeat, repeat_);
+    GTEST_FLAG_SET(recreate_environments_when_repeating,
+                   recreate_environments_when_repeating_);
+    GTEST_FLAG_SET(shuffle, shuffle_);
+    GTEST_FLAG_SET(stack_trace_depth, stack_trace_depth_);
+    GTEST_FLAG_SET(stream_result_to, stream_result_to_);
+    GTEST_FLAG_SET(throw_on_failure, throw_on_failure_);
   }
 
  private:
@@ -224,11 +208,12 @@ class GTestFlagSaver {
   bool print_utf8_;
   int32_t random_seed_;
   int32_t repeat_;
+  bool recreate_environments_when_repeating_;
   bool shuffle_;
   int32_t stack_trace_depth_;
   std::string stream_result_to_;
   bool throw_on_failure_;
-} GTEST_ATTRIBUTE_UNUSED_;
+};
 
 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
 // code_point parameter is of type UInt32 because wchar_t may not be
@@ -278,8 +263,8 @@ GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);
 // returns true if and only if the test should be run on this shard. The test id
 // is some arbitrary but unique non-negative integer assigned to each test
 // method. Assumes that 0 <= shard_index < total_shards.
-GTEST_API_ bool ShouldRunTestOnShard(
-    int total_shards, int shard_index, int test_id);
+GTEST_API_ bool ShouldRunTestOnShard(int total_shards, int shard_index,
+                                     int test_id);
 
 // STL container utilities.
 
@@ -290,9 +275,8 @@ inline int CountIf(const Container& c, Predicate predicate) {
   // Implemented as an explicit loop since std::count_if() in libCstd on
   // Solaris has a non-standard signature.
   int count = 0;
-  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
-    if (predicate(*it))
-      ++count;
+  for (auto it = c.begin(); it != c.end(); ++it) {
+    if (predicate(*it)) ++count;
   }
   return count;
 }
@@ -413,9 +397,11 @@ class GTEST_API_ UnitTestOptions {
   static bool MatchesFilter(const std::string& name, const char* filter);
 };
 
+#if GTEST_HAS_FILE_SYSTEM
 // Returns the current application's name, removing directory path if that
 // is present.  Used by UnitTestOptions::GetOutputFile.
 GTEST_API_ FilePath GetCurrentExecutableName();
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 // The role interface for getting the OS stack trace as a string.
 class OsStackTraceGetterInterface {
@@ -441,7 +427,9 @@ class OsStackTraceGetterInterface {
   static const char* const kElidedFramesMarker;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
+  OsStackTraceGetterInterface(const OsStackTraceGetterInterface&) = delete;
+  OsStackTraceGetterInterface& operator=(const OsStackTraceGetterInterface&) =
+      delete;
 };
 
 // A working implementation of the OsStackTraceGetterInterface interface.
@@ -463,7 +451,8 @@ class OsStackTraceGetter : public OsStackTraceGetterInterface {
   void* caller_frame_ = nullptr;
 #endif  // GTEST_HAS_ABSL
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
+  OsStackTraceGetter(const OsStackTraceGetter&) = delete;
+  OsStackTraceGetter& operator=(const OsStackTraceGetter&) = delete;
 };
 
 // Information about a Google Test trace point.
@@ -476,7 +465,7 @@ struct TraceInfo {
 // This is the default global test part result reporter used in UnitTestImpl.
 // This class should only be used by UnitTestImpl.
 class DefaultGlobalTestPartResultReporter
-  : public TestPartResultReporterInterface {
+    : public TestPartResultReporterInterface {
  public:
   explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
   // Implements the TestPartResultReporterInterface. Reports the test part
@@ -486,7 +475,10 @@ class DefaultGlobalTestPartResultReporter
  private:
   UnitTestImpl* const unit_test_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
+  DefaultGlobalTestPartResultReporter(
+      const DefaultGlobalTestPartResultReporter&) = delete;
+  DefaultGlobalTestPartResultReporter& operator=(
+      const DefaultGlobalTestPartResultReporter&) = delete;
 };
 
 // This is the default per thread test part result reporter used in
@@ -502,7 +494,10 @@ class DefaultPerThreadTestPartResultReporter
  private:
   UnitTestImpl* const unit_test_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
+  DefaultPerThreadTestPartResultReporter(
+      const DefaultPerThreadTestPartResultReporter&) = delete;
+  DefaultPerThreadTestPartResultReporter& operator=(
+      const DefaultPerThreadTestPartResultReporter&) = delete;
 };
 
 // The private implementation of the UnitTest class.  We don't protect
@@ -515,9 +510,9 @@ class GTEST_API_ UnitTestImpl {
   virtual ~UnitTestImpl();
 
   // There are two different ways to register your own TestPartResultReporter.
-  // You can register your own repoter to listen either only for test results
+  // You can register your own reporter to listen either only for test results
   // from the current thread or for results from all threads.
-  // By default, each per-thread test result repoter just passes a new
+  // By default, each per-thread test result reporter just passes a new
   // TestPartResult to the global test result reporter, which registers the
   // test part result for the currently running test.
 
@@ -640,7 +635,8 @@ class GTEST_API_ UnitTestImpl {
   // For example, if Foo() calls Bar(), which in turn calls
   // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
   // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
-  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
+  std::string CurrentOsStackTraceExceptTop(int skip_count)
+      GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_;
 
   // Finds and returns a TestSuite with the given name.  If one doesn't
   // exist, creates one and returns it.
@@ -744,9 +740,7 @@ class GTEST_API_ UnitTestImpl {
   }
 
   // Clears the results of ad-hoc test assertions.
-  void ClearAdHocTestResult() {
-    ad_hoc_test_result_.Clear();
-  }
+  void ClearAdHocTestResult() { ad_hoc_test_result_.Clear(); }
 
   // Adds a TestProperty to the current TestResult object when invoked in a
   // context of a test or a test suite, or to the global property set. If the
@@ -754,10 +748,7 @@ class GTEST_API_ UnitTestImpl {
   // updated.
   void RecordProperty(const TestProperty& test_property);
 
-  enum ReactionToSharding {
-    HONOR_SHARDING_PROTOCOL,
-    IGNORE_SHARDING_PROTOCOL
-  };
+  enum ReactionToSharding { HONOR_SHARDING_PROTOCOL, IGNORE_SHARDING_PROTOCOL };
 
   // Matches the full name of each test against the user-specified
   // filter to decide whether the test should run, then records the
@@ -852,9 +843,11 @@ class GTEST_API_ UnitTestImpl {
   // The UnitTest object that owns this implementation object.
   UnitTest* const parent_;
 
+#if GTEST_HAS_FILE_SYSTEM
   // The working directory when the first TEST() or TEST_F() was
   // executed.
   internal::FilePath original_working_dir_;
+#endif  // GTEST_HAS_FILE_SYSTEM
 
   // The default test part result reporters.
   DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
@@ -862,7 +855,7 @@ class GTEST_API_ UnitTestImpl {
       default_per_thread_test_part_result_reporter_;
 
   // Points to (but doesn't own) the global test part result reporter.
-  TestPartResultReporterInterface* global_test_part_result_repoter_;
+  TestPartResultReporterInterface* global_test_part_result_reporter_;
 
   // Protects read and write access to global_test_part_result_reporter_.
   internal::Mutex global_test_part_result_reporter_mutex_;
@@ -963,7 +956,8 @@ class GTEST_API_ UnitTestImpl {
   // starts.
   bool catch_exceptions_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
+  UnitTestImpl(const UnitTestImpl&) = delete;
+  UnitTestImpl& operator=(const UnitTestImpl&) = delete;
 };  // class UnitTestImpl
 
 // Convenience function for accessing the global UnitTest
@@ -986,8 +980,9 @@ GTEST_API_ bool IsValidEscape(char ch);
 GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
 GTEST_API_ bool ValidateRegex(const char* regex);
 GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
-GTEST_API_ bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char ch, char repeat, const char* regex, const char* str);
+GTEST_API_ bool MatchRepetitionAndRegexAtHead(bool escaped, char ch,
+                                              char repeat, const char* regex,
+                                              const char* str);
 GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
 
 #endif  // GTEST_USES_SIMPLE_RE
@@ -1089,8 +1084,7 @@ class StreamingListener : public EmptyTestEventListener {
     }
 
     ~SocketWriter() override {
-      if (sockfd_ != -1)
-        CloseConnection();
+      if (sockfd_ != -1) CloseConnection();
     }
 
     // Sends a string to the socket.
@@ -1100,9 +1094,8 @@ class StreamingListener : public EmptyTestEventListener {
 
       const auto len = static_cast<size_t>(message.length());
       if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
-        GTEST_LOG_(WARNING)
-            << "stream_result_to: failed to stream to "
-            << host_name_ << ":" << port_num_;
+        GTEST_LOG_(WARNING) << "stream_result_to: failed to stream to "
+                            << host_name_ << ":" << port_num_;
       }
     }
 
@@ -1123,7 +1116,8 @@ class StreamingListener : public EmptyTestEventListener {
     const std::string host_name_;
     const std::string port_num_;
 
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+    SocketWriter(const SocketWriter&) = delete;
+    SocketWriter& operator=(const SocketWriter&) = delete;
   };  // class SocketWriter
 
   // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
@@ -1135,7 +1129,9 @@ class StreamingListener : public EmptyTestEventListener {
   }
 
   explicit StreamingListener(AbstractSocketWriter* socket_writer)
-      : socket_writer_(socket_writer) { Start(); }
+      : socket_writer_(socket_writer) {
+    Start();
+  }
 
   void OnTestProgramStart(const UnitTest& /* unit_test */) override {
     SendLn("event=TestProgramStart");
@@ -1158,22 +1154,22 @@ class StreamingListener : public EmptyTestEventListener {
 
   void OnTestIterationEnd(const UnitTest& unit_test,
                           int /* iteration */) override {
-    SendLn("event=TestIterationEnd&passed=" +
-           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
-           StreamableToString(unit_test.elapsed_time()) + "ms");
+    SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) +
+           "&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) +
+           "ms");
   }
 
   // Note that "event=TestCaseStart" is a wire format and has to remain
   // "case" for compatibility
-  void OnTestCaseStart(const TestCase& test_case) override {
-    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  void OnTestSuiteStart(const TestSuite& test_suite) override {
+    SendLn(std::string("event=TestCaseStart&name=") + test_suite.name());
   }
 
   // Note that "event=TestCaseEnd" is a wire format and has to remain
   // "case" for compatibility
-  void OnTestCaseEnd(const TestCase& test_case) override {
-    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
-           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
+  void OnTestSuiteEnd(const TestSuite& test_suite) override {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_suite.Passed()) +
+           "&elapsed_time=" + StreamableToString(test_suite.elapsed_time()) +
            "ms");
   }
 
@@ -1183,8 +1179,7 @@ class StreamingListener : public EmptyTestEventListener {
 
   void OnTestEnd(const TestInfo& test_info) override {
     SendLn("event=TestEnd&passed=" +
-           FormatBool((test_info.result())->Passed()) +
-           "&elapsed_time=" +
+           FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
            StreamableToString((test_info.result())->elapsed_time()) + "ms");
   }
 
@@ -1208,7 +1203,8 @@ class StreamingListener : public EmptyTestEventListener {
 
   const std::unique_ptr<AbstractSocketWriter> socket_writer_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+  StreamingListener(const StreamingListener&) = delete;
+  StreamingListener& operator=(const StreamingListener&) = delete;
 };  // class StreamingListener
 
 #endif  // GTEST_CAN_STREAM_RESULTS_
diff --git a/googletest/googletest/src/gtest-matchers.cc b/googletest/googletest/src/gtest-matchers.cc
index 65104ebab1ba9af06327fc94c0a038b6806d4206..7e3bcc0cff3806c1151357ab1f31da2a0b5b9dbc 100644
--- a/googletest/googletest/src/gtest-matchers.cc
+++ b/googletest/googletest/src/gtest-matchers.cc
@@ -32,12 +32,13 @@
 // This file implements just enough of the matcher interface to allow
 // EXPECT_DEATH and friends to accept a matcher argument.
 
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-port.h"
 #include "gtest/gtest-matchers.h"
 
 #include <string>
 
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
 namespace testing {
 
 // Constructs a matcher that matches a const std::string& whose value is
diff --git a/googletest/googletest/src/gtest-port.cc b/googletest/googletest/src/gtest-port.cc
index 53a4d37f97d2ef1355cd2e5788569d8aab11f84a..d797fe4d5866c7da296a64428ad4da352c1e7fe4 100644
--- a/googletest/googletest/src/gtest-port.cc
+++ b/googletest/googletest/src/gtest-port.cc
@@ -27,61 +27,62 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/internal/gtest-port.h"
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include <cstdint>
 #include <fstream>
 #include <memory>
 
 #if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <io.h>
-# include <sys/stat.h>
-# include <map>  // Used in ThreadLocal.
-# ifdef _MSC_VER
-#  include <crtdbg.h>
-# endif  // _MSC_VER
+#include <io.h>
+#include <sys/stat.h>
+#include <windows.h>
+
+#include <map>  // Used in ThreadLocal.
+#ifdef _MSC_VER
+#include <crtdbg.h>
+#endif  // _MSC_VER
 #else
-# include <unistd.h>
+#include <unistd.h>
 #endif  // GTEST_OS_WINDOWS
 
 #if GTEST_OS_MAC
-# include <mach/mach_init.h>
-# include <mach/task.h>
-# include <mach/vm_map.h>
+#include <mach/mach_init.h>
+#include <mach/task.h>
+#include <mach/vm_map.h>
 #endif  // GTEST_OS_MAC
 
 #if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
     GTEST_OS_NETBSD || GTEST_OS_OPENBSD
-# include <sys/sysctl.h>
-# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
-#  include <sys/user.h>
-# endif
+#include <sys/sysctl.h>
+#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
+#include <sys/user.h>
+#endif
 #endif
 
 #if GTEST_OS_QNX
-# include <devctl.h>
-# include <fcntl.h>
-# include <sys/procfs.h>
+#include <devctl.h>
+#include <fcntl.h>
+#include <sys/procfs.h>
 #endif  // GTEST_OS_QNX
 
 #if GTEST_OS_AIX
-# include <procinfo.h>
-# include <sys/types.h>
+#include <procinfo.h>
+#include <sys/types.h>
 #endif  // GTEST_OS_AIX
 
 #if GTEST_OS_FUCHSIA
-# include <zircon/process.h>
-# include <zircon/syscalls.h>
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
 #endif  // GTEST_OS_FUCHSIA
 
-#include "gtest/gtest-spi.h"
 #include "gtest/gtest-message.h"
+#include "gtest/gtest-spi.h"
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"
 #include "src/gtest-internal-inl.h"
@@ -89,16 +90,7 @@
 namespace testing {
 namespace internal {
 
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
-const int kStdOutFileno = 1;
-const int kStdErrFileno = 2;
-#else
-const int kStdOutFileno = STDOUT_FILENO;
-const int kStdErrFileno = STDERR_FILENO;
-#endif  // _MSC_VER
-
-#if GTEST_OS_LINUX
+#if GTEST_OS_LINUX || GTEST_OS_GNU_HURD
 
 namespace {
 template <typename T>
@@ -131,8 +123,7 @@ size_t GetThreadCount() {
   if (status == KERN_SUCCESS) {
     // task_threads allocates resources in thread_list and we need to free them
     // to avoid leaks.
-    vm_deallocate(task,
-                  reinterpret_cast<vm_address_t>(thread_list),
+    vm_deallocate(task, reinterpret_cast<vm_address_t>(thread_list),
                   sizeof(thread_t) * thread_count);
     return static_cast<size_t>(thread_count);
   } else {
@@ -141,7 +132,7 @@ size_t GetThreadCount() {
 }
 
 #elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-      GTEST_OS_NETBSD
+    GTEST_OS_NETBSD
 
 #if GTEST_OS_NETBSD
 #undef KERN_PROC
@@ -184,12 +175,12 @@ size_t GetThreadCount() {
 // we cannot detect it.
 size_t GetThreadCount() {
   int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
-    getpid(),
-    sizeof(struct kinfo_proc),
-    0,
+      CTL_KERN,
+      KERN_PROC,
+      KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
+      getpid(),
+      sizeof(struct kinfo_proc),
+      0,
   };
   u_int miblen = sizeof(mib) / sizeof(mib[0]);
 
@@ -210,8 +201,7 @@ size_t GetThreadCount() {
   // exclude empty members
   size_t nthreads = 0;
   for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) {
-    if (info[i].p_tid != -1)
-      nthreads++;
+    if (info[i].p_tid != -1) nthreads++;
   }
   return nthreads;
 }
@@ -254,13 +244,9 @@ size_t GetThreadCount() {
 size_t GetThreadCount() {
   int dummy_buffer;
   size_t avail;
-  zx_status_t status = zx_object_get_info(
-      zx_process_self(),
-      ZX_INFO_PROCESS_THREADS,
-      &dummy_buffer,
-      0,
-      nullptr,
-      &avail);
+  zx_status_t status =
+      zx_object_get_info(zx_process_self(), ZX_INFO_PROCESS_THREADS,
+                         &dummy_buffer, 0, nullptr, &avail);
   if (status == ZX_OK) {
     return avail;
   } else {
@@ -280,27 +266,15 @@ size_t GetThreadCount() {
 
 #if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
 
-void SleepMilliseconds(int n) {
-  ::Sleep(static_cast<DWORD>(n));
-}
+AutoHandle::AutoHandle() : handle_(INVALID_HANDLE_VALUE) {}
 
-AutoHandle::AutoHandle()
-    : handle_(INVALID_HANDLE_VALUE) {}
+AutoHandle::AutoHandle(Handle handle) : handle_(handle) {}
 
-AutoHandle::AutoHandle(Handle handle)
-    : handle_(handle) {}
+AutoHandle::~AutoHandle() { Reset(); }
 
-AutoHandle::~AutoHandle() {
-  Reset();
-}
-
-AutoHandle::Handle AutoHandle::Get() const {
-  return handle_;
-}
+AutoHandle::Handle AutoHandle::Get() const { return handle_; }
 
-void AutoHandle::Reset() {
-  Reset(INVALID_HANDLE_VALUE);
-}
+void AutoHandle::Reset() { Reset(INVALID_HANDLE_VALUE); }
 
 void AutoHandle::Reset(HANDLE handle) {
   // Resetting with the same handle we already own is invalid.
@@ -312,7 +286,7 @@ void AutoHandle::Reset(HANDLE handle) {
   } else {
     GTEST_CHECK_(!IsCloseable())
         << "Resetting a valid handle to itself is likely a programmer error "
-            "and thus not allowed.";
+           "and thus not allowed.";
   }
 }
 
@@ -322,23 +296,6 @@ bool AutoHandle::IsCloseable() const {
   return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
 }
 
-Notification::Notification()
-    : event_(::CreateEvent(nullptr,     // Default security attributes.
-                           TRUE,        // Do not reset automatically.
-                           FALSE,       // Initially unset.
-                           nullptr)) {  // Anonymous event.
-  GTEST_CHECK_(event_.Get() != nullptr);
-}
-
-void Notification::Notify() {
-  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
-}
-
-void Notification::WaitForNotification() {
-  GTEST_CHECK_(
-      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
-}
-
 Mutex::Mutex()
     : owner_thread_id_(0),
       type_(kDynamic),
@@ -391,25 +348,25 @@ namespace {
 //    MemoryIsNotDeallocated memory_is_not_deallocated;
 //    critical_section_ = new CRITICAL_SECTION;
 //
-class MemoryIsNotDeallocated
-{
+class MemoryIsNotDeallocated {
  public:
   MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
     old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
     // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
     // doesn't report mem leak if there's no matching deallocation.
-    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
+    (void)_CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
   }
 
   ~MemoryIsNotDeallocated() {
     // Restore the original _CRTDBG_ALLOC_MEM_DF flag
-    _CrtSetDbgFlag(old_crtdbg_flag_);
+    (void)_CrtSetDbgFlag(old_crtdbg_flag_);
   }
 
  private:
   int old_crtdbg_flag_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
+  MemoryIsNotDeallocated(const MemoryIsNotDeallocated&) = delete;
+  MemoryIsNotDeallocated& operator=(const MemoryIsNotDeallocated&) = delete;
 };
 #endif  // _MSC_VER
 
@@ -435,15 +392,13 @@ void Mutex::ThreadSafeLazyInit() {
         ::InitializeCriticalSection(critical_section_);
         // Updates the critical_section_init_phase_ to 2 to signal
         // initialization complete.
-        GTEST_CHECK_(::InterlockedCompareExchange(
-                          &critical_section_init_phase_, 2L, 1L) ==
-                      1L);
+        GTEST_CHECK_(::InterlockedCompareExchange(&critical_section_init_phase_,
+                                                  2L, 1L) == 1L);
         break;
       case 1:
         // Somebody else is already initializing the mutex; spin until they
         // are done.
-        while (::InterlockedCompareExchange(&critical_section_init_phase_,
-                                            2L,
+        while (::InterlockedCompareExchange(&critical_section_init_phase_, 2L,
                                             2L) != 2L) {
           // Possibly yields the rest of the thread's time slice to other
           // threads.
@@ -488,9 +443,7 @@ class ThreadWithParamSupport : public ThreadWithParamBase {
  private:
   struct ThreadMainParam {
     ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
-        : runnable_(runnable),
-          thread_can_start_(thread_can_start) {
-    }
+        : runnable_(runnable), thread_can_start_(thread_can_start) {}
     std::unique_ptr<Runnable> runnable_;
     // Does not own.
     Notification* thread_can_start_;
@@ -508,20 +461,18 @@ class ThreadWithParamSupport : public ThreadWithParamBase {
   // Prohibit instantiation.
   ThreadWithParamSupport();
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
+  ThreadWithParamSupport(const ThreadWithParamSupport&) = delete;
+  ThreadWithParamSupport& operator=(const ThreadWithParamSupport&) = delete;
 };
 
 }  // namespace
 
-ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
+ThreadWithParamBase::ThreadWithParamBase(Runnable* runnable,
                                          Notification* thread_can_start)
-      : thread_(ThreadWithParamSupport::CreateThread(runnable,
-                                                     thread_can_start)) {
-}
+    : thread_(
+          ThreadWithParamSupport::CreateThread(runnable, thread_can_start)) {}
 
-ThreadWithParamBase::~ThreadWithParamBase() {
-  Join();
-}
+ThreadWithParamBase::~ThreadWithParamBase() { Join(); }
 
 void ThreadWithParamBase::Join() {
   GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
@@ -548,8 +499,10 @@ class ThreadLocalRegistryImpl {
     ThreadIdToThreadLocals::iterator thread_local_pos =
         thread_to_thread_locals->find(current_thread);
     if (thread_local_pos == thread_to_thread_locals->end()) {
-      thread_local_pos = thread_to_thread_locals->insert(
-          std::make_pair(current_thread, ThreadLocalValues())).first;
+      thread_local_pos =
+          thread_to_thread_locals
+              ->insert(std::make_pair(current_thread, ThreadLocalValues()))
+              .first;
       StartWatcherThreadFor(current_thread);
     }
     ThreadLocalValues& thread_local_values = thread_local_pos->second;
@@ -577,9 +530,8 @@ class ThreadLocalRegistryImpl {
       ThreadIdToThreadLocals* const thread_to_thread_locals =
           GetThreadLocalsMapLocked();
       for (ThreadIdToThreadLocals::iterator it =
-          thread_to_thread_locals->begin();
-          it != thread_to_thread_locals->end();
-          ++it) {
+               thread_to_thread_locals->begin();
+           it != thread_to_thread_locals->end(); ++it) {
         ThreadLocalValues& thread_local_values = it->second;
         ThreadLocalValues::iterator value_pos =
             thread_local_values.find(thread_local_instance);
@@ -609,9 +561,8 @@ class ThreadLocalRegistryImpl {
       if (thread_local_pos != thread_to_thread_locals->end()) {
         ThreadLocalValues& thread_local_values = thread_local_pos->second;
         for (ThreadLocalValues::iterator value_pos =
-            thread_local_values.begin();
-            value_pos != thread_local_values.end();
-            ++value_pos) {
+                 thread_local_values.begin();
+             value_pos != thread_local_values.end(); ++value_pos) {
           value_holders.push_back(value_pos->second);
         }
         thread_to_thread_locals->erase(thread_local_pos);
@@ -637,9 +588,8 @@ class ThreadLocalRegistryImpl {
   static void StartWatcherThreadFor(DWORD thread_id) {
     // The returned handle will be kept in thread_map and closed by
     // watcher_thread in WatcherThreadFunc.
-    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
-                                 FALSE,
-                                 thread_id);
+    HANDLE thread =
+        ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION, FALSE, thread_id);
     GTEST_CHECK_(thread != nullptr);
     // We need to pass a valid thread ID pointer into CreateThread for it
     // to work correctly under Win98.
@@ -650,7 +600,8 @@ class ThreadLocalRegistryImpl {
         &ThreadLocalRegistryImpl::WatcherThreadFunc,
         reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
         CREATE_SUSPENDED, &watcher_thread_id);
-    GTEST_CHECK_(watcher_thread != nullptr);
+    GTEST_CHECK_(watcher_thread != nullptr)
+        << "CreateThread failed with error " << ::GetLastError() << ".";
     // Give the watcher thread the same priority as ours to avoid being
     // blocked by it.
     ::SetThreadPriority(watcher_thread,
@@ -664,8 +615,7 @@ class ThreadLocalRegistryImpl {
   static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
     const ThreadIdAndHandle* tah =
         reinterpret_cast<const ThreadIdAndHandle*>(param);
-    GTEST_CHECK_(
-        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    GTEST_CHECK_(::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
     OnThreadExit(tah->first);
     ::CloseHandle(tah->second);
     delete tah;
@@ -689,16 +639,17 @@ class ThreadLocalRegistryImpl {
 };
 
 Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);  // NOLINT
-Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);  // NOLINT
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(
+    Mutex::kStaticMutex);  // NOLINT
 
 ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
-      const ThreadLocalBase* thread_local_instance) {
+    const ThreadLocalBase* thread_local_instance) {
   return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
       thread_local_instance);
 }
 
 void ThreadLocalRegistry::OnThreadLocalDestroyed(
-      const ThreadLocalBase* thread_local_instance) {
+    const ThreadLocalBase* thread_local_instance) {
   ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
 }
 
@@ -786,7 +737,7 @@ bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
 bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
 bool IsAsciiWordChar(char ch) {
   return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
-      ('0' <= ch && ch <= '9') || ch == '_';
+         ('0' <= ch && ch <= '9') || ch == '_';
 }
 
 // Returns true if and only if "\\c" is a supported escape sequence.
@@ -799,17 +750,28 @@ bool IsValidEscape(char c) {
 bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
   if (escaped) {  // "\\p" where p is pattern_char.
     switch (pattern_char) {
-      case 'd': return IsAsciiDigit(ch);
-      case 'D': return !IsAsciiDigit(ch);
-      case 'f': return ch == '\f';
-      case 'n': return ch == '\n';
-      case 'r': return ch == '\r';
-      case 's': return IsAsciiWhiteSpace(ch);
-      case 'S': return !IsAsciiWhiteSpace(ch);
-      case 't': return ch == '\t';
-      case 'v': return ch == '\v';
-      case 'w': return IsAsciiWordChar(ch);
-      case 'W': return !IsAsciiWordChar(ch);
+      case 'd':
+        return IsAsciiDigit(ch);
+      case 'D':
+        return !IsAsciiDigit(ch);
+      case 'f':
+        return ch == '\f';
+      case 'n':
+        return ch == '\n';
+      case 'r':
+        return ch == '\r';
+      case 's':
+        return IsAsciiWhiteSpace(ch);
+      case 'S':
+        return !IsAsciiWhiteSpace(ch);
+      case 't':
+        return ch == '\t';
+      case 'v':
+        return ch == '\v';
+      case 'w':
+        return IsAsciiWordChar(ch);
+      case 'W':
+        return !IsAsciiWordChar(ch);
     }
     return IsAsciiPunct(pattern_char) && pattern_char == ch;
   }
@@ -820,7 +782,8 @@ bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
 // Helper function used by ValidateRegex() to format error messages.
 static std::string FormatRegexSyntaxError(const char* regex, int index) {
   return (Message() << "Syntax error at index " << index
-          << " in simple regular expression \"" << regex << "\": ").GetString();
+                    << " in simple regular expression \"" << regex << "\": ")
+      .GetString();
 }
 
 // Generates non-fatal failures and returns false if regex is invalid;
@@ -862,12 +825,12 @@ bool ValidateRegex(const char* regex) {
                       << "'$' can only appear at the end.";
         is_valid = false;
       } else if (IsInSet(ch, "()[]{}|")) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' is unsupported.";
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch
+                      << "' is unsupported.";
         is_valid = false;
       } else if (IsRepeat(ch) && !prev_repeatable) {
-        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
-                      << "'" << ch << "' can only follow a repeatable token.";
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch
+                      << "' can only follow a repeatable token.";
         is_valid = false;
       }
 
@@ -885,12 +848,10 @@ bool ValidateRegex(const char* regex) {
 // characters to be indexable by size_t, in which case the test will
 // probably time out anyway.  We are fine with this limitation as
 // std::string has it too.
-bool MatchRepetitionAndRegexAtHead(
-    bool escaped, char c, char repeat, const char* regex,
-    const char* str) {
+bool MatchRepetitionAndRegexAtHead(bool escaped, char c, char repeat,
+                                   const char* regex, const char* str) {
   const size_t min_count = (repeat == '+') ? 1 : 0;
-  const size_t max_count = (repeat == '?') ? 1 :
-      static_cast<size_t>(-1) - 1;
+  const size_t max_count = (repeat == '?') ? 1 : static_cast<size_t>(-1) - 1;
   // We cannot call numeric_limits::max() as it conflicts with the
   // max() macro on Windows.
 
@@ -903,8 +864,7 @@ bool MatchRepetitionAndRegexAtHead(
       // greedy match.
       return true;
     }
-    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
-      return false;
+    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) return false;
   }
   return false;
 }
@@ -918,25 +878,23 @@ bool MatchRegexAtHead(const char* regex, const char* str) {
 
   // "$" only matches the end of a string.  Note that regex being
   // valid guarantees that there's nothing after "$" in it.
-  if (*regex == '$')
-    return *str == '\0';
+  if (*regex == '$') return *str == '\0';
 
   // Is the first thing in regex an escape sequence?
   const bool escaped = *regex == '\\';
-  if (escaped)
-    ++regex;
+  if (escaped) ++regex;
   if (IsRepeat(regex[1])) {
     // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
     // here's an indirect recursion.  It terminates as the regex gets
     // shorter in each recursion.
-    return MatchRepetitionAndRegexAtHead(
-        escaped, regex[0], regex[1], regex + 2, str);
+    return MatchRepetitionAndRegexAtHead(escaped, regex[0], regex[1], regex + 2,
+                                         str);
   } else {
     // regex isn't empty, isn't "$", and doesn't start with a
     // repetition.  We match the first atom of regex with the first
     // character of str and recurse.
     return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
-        MatchRegexAtHead(regex + 1, str + 1);
+           MatchRegexAtHead(regex + 1, str + 1);
   }
 }
 
@@ -951,13 +909,11 @@ bool MatchRegexAtHead(const char* regex, const char* str) {
 bool MatchRegexAnywhere(const char* regex, const char* str) {
   if (regex == nullptr || str == nullptr) return false;
 
-  if (*regex == '^')
-    return MatchRegexAtHead(regex + 1, str);
+  if (*regex == '^') return MatchRegexAtHead(regex + 1, str);
 
   // A successful match can be anywhere in str.
   do {
-    if (MatchRegexAtHead(regex, str))
-      return true;
+    if (MatchRegexAtHead(regex, str)) return true;
   } while (*str++ != '\0');
   return false;
 }
@@ -1038,8 +994,8 @@ GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
 // FormatFileLocation in order to contrast the two functions.
 // Note that FormatCompilerIndependentFileLocation() does NOT append colon
 // to the file location it produces, unlike FormatFileLocation().
-GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
-    const char* file, int line) {
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line) {
   const std::string file_name(file == nullptr ? kUnknownFile : file);
 
   if (line < 0)
@@ -1050,12 +1006,13 @@ GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
 
 GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
     : severity_(severity) {
-  const char* const marker =
-      severity == GTEST_INFO ?    "[  INFO ]" :
-      severity == GTEST_WARNING ? "[WARNING]" :
-      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
-  GetStream() << ::std::endl << marker << " "
-              << FormatFileLocation(file, line).c_str() << ": ";
+  const char* const marker = severity == GTEST_INFO      ? "[  INFO ]"
+                             : severity == GTEST_WARNING ? "[WARNING]"
+                             : severity == GTEST_ERROR   ? "[ ERROR ]"
+                                                         : "[ FATAL ]";
+  GetStream() << ::std::endl
+              << marker << " " << FormatFileLocation(file, line).c_str()
+              << ": ";
 }
 
 // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
@@ -1078,27 +1035,26 @@ class CapturedStream {
  public:
   // The ctor redirects the stream to a temporary file.
   explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
-# if GTEST_OS_WINDOWS
-    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
-    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+#if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = {'\0'};   // NOLINT
+    char temp_file_path[MAX_PATH + 1] = {'\0'};  // NOLINT
 
     ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
-    const UINT success = ::GetTempFileNameA(temp_dir_path,
-                                            "gtest_redir",
+    const UINT success = ::GetTempFileNameA(temp_dir_path, "gtest_redir",
                                             0,  // Generate unique file name.
                                             temp_file_path);
     GTEST_CHECK_(success != 0)
         << "Unable to create a temporary file in " << temp_dir_path;
     const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
-    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
-                                    << temp_file_path;
+    GTEST_CHECK_(captured_fd != -1)
+        << "Unable to open temporary file " << temp_file_path;
     filename_ = temp_file_path;
-# else
+#else
     // There's no guarantee that a test has write access to the current
     // directory, so we create the temporary file in a temporary directory.
     std::string name_template;
 
-#  if GTEST_OS_LINUX_ANDROID
+#if GTEST_OS_LINUX_ANDROID
     // Note: Android applications are expected to call the framework's
     // Context.getExternalStorageDirectory() method through JNI to get
     // the location of the world-writable SD Card directory. However,
@@ -1111,7 +1067,7 @@ class CapturedStream {
     // '/sdcard' and other variants cannot be relied on, as they are not
     // guaranteed to be mounted, or may have a delay in mounting.
     name_template = "/data/local/tmp/";
-#  elif GTEST_OS_IOS
+#elif GTEST_OS_IOS
     char user_temp_dir[PATH_MAX + 1];
 
     // Documented alternative to NSTemporaryDirectory() (for obtaining creating
@@ -1132,9 +1088,9 @@ class CapturedStream {
     name_template = user_temp_dir;
     if (name_template.back() != GTEST_PATH_SEP_[0])
       name_template.push_back(GTEST_PATH_SEP_[0]);
-#  else
+#else
     name_template = "/tmp/";
-#  endif
+#endif
     name_template.append("gtest_captured_stream.XXXXXX");
 
     // mkstemp() modifies the string bytes in place, and does not go beyond the
@@ -1150,15 +1106,13 @@ class CapturedStream {
           << " for test; does the test have access to the /tmp directory?";
     }
     filename_ = std::move(name_template);
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
     fflush(nullptr);
     dup2(captured_fd, fd_);
     close(captured_fd);
   }
 
-  ~CapturedStream() {
-    remove(filename_.c_str());
-  }
+  ~CapturedStream() { remove(filename_.c_str()); }
 
   std::string GetCapturedString() {
     if (uncaptured_fd_ != -1) {
@@ -1185,7 +1139,8 @@ class CapturedStream {
   // Name of the temporary file holding the stderr output.
   ::std::string filename_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
+  CapturedStream(const CapturedStream&) = delete;
+  CapturedStream& operator=(const CapturedStream&) = delete;
 };
 
 GTEST_DISABLE_MSC_DEPRECATED_POP_()
@@ -1213,6 +1168,15 @@ static std::string GetCapturedStream(CapturedStream** captured_stream) {
   return content;
 }
 
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
+const int kStdOutFileno = 1;
+const int kStdErrFileno = 2;
+#else
+const int kStdOutFileno = STDOUT_FILENO;
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+
 // Starts capturing stdout.
 void CaptureStdout() {
   CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
@@ -1235,10 +1199,6 @@ std::string GetCapturedStderr() {
 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
-
-
-
-
 size_t GetFileSize(FILE* file) {
   fseek(file, 0, SEEK_END);
   return static_cast<size_t>(ftell(file));
@@ -1256,7 +1216,8 @@ std::string ReadEntireFile(FILE* file) {
   // Keeps reading the file until we cannot read further or the
   // pre-determined file size is reached.
   do {
-    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_last_read =
+        fread(buffer + bytes_read, 1, file_size - bytes_read, file);
     bytes_read += bytes_last_read;
   } while (bytes_last_read > 0 && bytes_read < file_size);
 
@@ -1344,7 +1305,7 @@ bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
       // LONG_MAX or LONG_MIN when the input overflows.)
       result != long_value
       // The parsed value overflows as an int32_t.
-      ) {
+  ) {
     Message msg;
     msg << "WARNING: " << src_text
         << " is expected to be a 32-bit integer, but actually"
@@ -1388,8 +1349,8 @@ int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
   }
 
   int32_t result = default_value;
-  if (!ParseInt32(Message() << "Environment variable " << env_var,
-                  string_value, &result)) {
+  if (!ParseInt32(Message() << "Environment variable " << env_var, string_value,
+                  &result)) {
     printf("The default value %s is used.\n",
            (Message() << default_value).GetString().c_str());
     fflush(stdout);
@@ -1408,7 +1369,7 @@ int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
 // not check that the flag is 'output'
 // In essence this checks an env variable called XML_OUTPUT_FILE
 // and if it is set we prepend "xml:" to its value, if it not set we return ""
-std::string OutputFlagAlsoCheckEnvVar(){
+std::string OutputFlagAlsoCheckEnvVar() {
   std::string default_value_for_output_flag = "";
   const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
   if (nullptr != xml_output_file_env) {
diff --git a/googletest/googletest/src/gtest-printers.cc b/googletest/googletest/src/gtest-printers.cc
index 1b68fcb500550f8d0846b158455a126bbc4bfdf1..d475ad36f5eccf07a245cd60460c6207b0769863 100644
--- a/googletest/googletest/src/gtest-printers.cc
+++ b/googletest/googletest/src/gtest-printers.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Test - The Google C++ Testing and Mocking Framework
 //
 // This file implements a universal value printer that can print a
@@ -101,7 +100,7 @@ void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
     PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
     *os << " ... ";
     // Rounds up to 2-byte boundary.
-    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
+    const size_t resume_pos = (count - kChunkSize + 1) / 2 * 2;
     PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
   }
   *os << ">";
@@ -136,11 +135,7 @@ void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
 //   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
 //   - as a hexadecimal escape sequence (e.g. '\x7F'), or
 //   - as a special escape sequence (e.g. '\r', '\n').
-enum CharFormat {
-  kAsIs,
-  kHexEscape,
-  kSpecialEscape
-};
+enum CharFormat { kAsIs, kHexEscape, kSpecialEscape };
 
 // Returns true if c is a printable ASCII character.  We test the
 // value of c directly instead of calling isprint(), which is buggy on
@@ -213,35 +208,21 @@ static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
   }
 }
 
-static const char* GetCharWidthPrefix(char) {
-  return "";
-}
+static const char* GetCharWidthPrefix(char) { return ""; }
 
-static const char* GetCharWidthPrefix(signed char) {
-  return "";
-}
+static const char* GetCharWidthPrefix(signed char) { return ""; }
 
-static const char* GetCharWidthPrefix(unsigned char) {
-  return "";
-}
+static const char* GetCharWidthPrefix(unsigned char) { return ""; }
 
 #ifdef __cpp_char8_t
-static const char* GetCharWidthPrefix(char8_t) {
-  return "u8";
-}
+static const char* GetCharWidthPrefix(char8_t) { return "u8"; }
 #endif
 
-static const char* GetCharWidthPrefix(char16_t) {
-  return "u";
-}
+static const char* GetCharWidthPrefix(char16_t) { return "u"; }
 
-static const char* GetCharWidthPrefix(char32_t) {
-  return "U";
-}
+static const char* GetCharWidthPrefix(char32_t) { return "U"; }
 
-static const char* GetCharWidthPrefix(wchar_t) {
-  return "L";
-}
+static const char* GetCharWidthPrefix(wchar_t) { return "L"; }
 
 // Prints a char c as if it's part of a string literal, escaping it when
 // necessary; returns how c was formatted.
@@ -276,8 +257,7 @@ void PrintCharAndCodeTo(Char c, ostream* os) {
   // To aid user debugging, we also print c's code in decimal, unless
   // it's 0 (in which case c was printed as '\\0', making the code
   // obvious).
-  if (c == 0)
-    return;
+  if (c == 0) return;
   *os << " (" << static_cast<int>(c);
 
   // For more convenience, we print c's code again in hexadecimal,
@@ -304,17 +284,60 @@ void PrintTo(char32_t c, ::std::ostream* os) {
       << static_cast<uint32_t>(c);
 }
 
+// gcc/clang __{u,}int128_t
+#if defined(__SIZEOF_INT128__)
+void PrintTo(__uint128_t v, ::std::ostream* os) {
+  if (v == 0) {
+    *os << "0";
+    return;
+  }
+
+  // Buffer large enough for ceil(log10(2^128))==39 and the null terminator
+  char buf[40];
+  char* p = buf + sizeof(buf);
+
+  // Some configurations have a __uint128_t, but no support for built in
+  // division. Do manual long division instead.
+
+  uint64_t high = static_cast<uint64_t>(v >> 64);
+  uint64_t low = static_cast<uint64_t>(v);
+
+  *--p = 0;
+  while (high != 0 || low != 0) {
+    uint64_t high_mod = high % 10;
+    high = high / 10;
+    // This is the long division algorithm specialized for a divisor of 10 and
+    // only two elements.
+    // Notable values:
+    //   2^64 / 10 == 1844674407370955161
+    //   2^64 % 10 == 6
+    const uint64_t carry = 6 * high_mod + low % 10;
+    low = low / 10 + high_mod * 1844674407370955161 + carry / 10;
+
+    char digit = static_cast<char>(carry % 10);
+    *--p = static_cast<char>('0' + digit);
+  }
+  *os << p;
+}
+void PrintTo(__int128_t v, ::std::ostream* os) {
+  __uint128_t uv = static_cast<__uint128_t>(v);
+  if (v < 0) {
+    *os << "-";
+    uv = -uv;
+  }
+  PrintTo(uv, os);
+}
+#endif  // __SIZEOF_INT128__
+
 // Prints the given array of characters to the ostream.  CharType must be either
 // char, char8_t, char16_t, char32_t, or wchar_t.
 // The array starts at begin, the length is len, it may include '\0' characters
 // and may not be NUL-terminated.
 template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static CharFormat PrintCharsAsStringTo(
-    const CharType* begin, size_t len, ostream* os) {
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+    GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+        GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ static CharFormat
+        PrintCharsAsStringTo(const CharType* begin, size_t len, ostream* os) {
   const char* const quote_prefix = GetCharWidthPrefix(*begin);
   *os << quote_prefix << "\"";
   bool is_previous_hex = false;
@@ -340,12 +363,11 @@ static CharFormat PrintCharsAsStringTo(
 // Prints a (const) char/wchar_t array of 'len' elements, starting at address
 // 'begin'.  CharType must be either char or wchar_t.
 template <typename CharType>
-GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static void UniversalPrintCharArray(
-    const CharType* begin, size_t len, ostream* os) {
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+    GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+        GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ static void
+        UniversalPrintCharArray(const CharType* begin, size_t len,
+                                ostream* os) {
   // The code
   //   const char kFoo[] = "foo";
   // generates an array of 4, not 3, elements, with the last one being '\0'.
@@ -436,28 +458,28 @@ void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
 namespace {
 
 bool ContainsUnprintableControlCodes(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+  const unsigned char* s = reinterpret_cast<const unsigned char*>(str);
 
   for (size_t i = 0; i < length; i++) {
     unsigned char ch = *s++;
     if (std::iscntrl(ch)) {
-        switch (ch) {
+      switch (ch) {
         case '\t':
         case '\n':
         case '\r':
           break;
         default:
           return true;
-        }
       }
+    }
   }
   return false;
 }
 
-bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
+bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t <= 0xbf; }
 
 bool IsValidUTF8(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+  const unsigned char* s = reinterpret_cast<const unsigned char*>(str);
 
   for (size_t i = 0; i < length;) {
     unsigned char lead = s[i++];
@@ -470,15 +492,13 @@ bool IsValidUTF8(const char* str, size_t length) {
     } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
       ++i;  // 2-byte character
     } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
+               IsUTF8TrailByte(s[i]) && IsUTF8TrailByte(s[i + 1]) &&
                // check for non-shortest form and surrogate
                (lead != 0xe0 || s[i] >= 0xa0) &&
                (lead != 0xed || s[i] < 0xa0)) {
       i += 2;  // 3-byte character
     } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
+               IsUTF8TrailByte(s[i]) && IsUTF8TrailByte(s[i + 1]) &&
                IsUTF8TrailByte(s[i + 2]) &&
                // check for non-shortest form
                (lead != 0xf0 || s[i] >= 0x90) &&
@@ -502,7 +522,7 @@ void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
 
 void PrintStringTo(const ::std::string& s, ostream* os) {
   if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
-    if (GTEST_FLAG(print_utf8)) {
+    if (GTEST_FLAG_GET(print_utf8)) {
       ConditionalPrintAsText(s.data(), s.size(), os);
     }
   }
diff --git a/googletest/googletest/src/gtest-test-part.cc b/googletest/googletest/src/gtest-test-part.cc
index a938683ceded2f34697efd8305a67368064d0198..eb7c8d1cf9235390e1081c5d5f9acb886802f220 100644
--- a/googletest/googletest/src/gtest-test-part.cc
+++ b/googletest/googletest/src/gtest-test-part.cc
@@ -51,13 +51,11 @@ std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
   return os << internal::FormatFileLocation(result.file_name(),
                                             result.line_number())
             << " "
-            << (result.type() == TestPartResult::kSuccess
-                    ? "Success"
-                    : result.type() == TestPartResult::kSkip
-                          ? "Skipped"
-                          : result.type() == TestPartResult::kFatalFailure
-                                ? "Fatal failure"
-                                : "Non-fatal failure")
+            << (result.type() == TestPartResult::kSuccess ? "Success"
+                : result.type() == TestPartResult::kSkip  ? "Skipped"
+                : result.type() == TestPartResult::kFatalFailure
+                    ? "Fatal failure"
+                    : "Non-fatal failure")
             << ":\n"
             << result.message() << std::endl;
 }
@@ -86,8 +84,8 @@ namespace internal {
 
 HasNewFatalFailureHelper::HasNewFatalFailureHelper()
     : has_new_fatal_failure_(false),
-      original_reporter_(GetUnitTestImpl()->
-                         GetTestPartResultReporterForCurrentThread()) {
+      original_reporter_(
+          GetUnitTestImpl()->GetTestPartResultReporterForCurrentThread()) {
   GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
 }
 
@@ -98,8 +96,7 @@ HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
 
 void HasNewFatalFailureHelper::ReportTestPartResult(
     const TestPartResult& result) {
-  if (result.fatally_failed())
-    has_new_fatal_failure_ = true;
+  if (result.fatally_failed()) has_new_fatal_failure_ = true;
   original_reporter_->ReportTestPartResult(result);
 }
 
diff --git a/googletest/googletest/src/gtest-typed-test.cc b/googletest/googletest/src/gtest-typed-test.cc
index c02c3df6599527af878d28f4aa2311a61a65c48a..a2828b83c66457d6082d55b05ac5ae596a9d1efc 100644
--- a/googletest/googletest/src/gtest-typed-test.cc
+++ b/googletest/googletest/src/gtest-typed-test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest-typed-test.h"
 
 #include "gtest/gtest.h"
@@ -38,8 +37,7 @@ namespace internal {
 // Skips to the first non-space char in str. Returns an empty string if str
 // contains only whitespace characters.
 static const char* SkipSpaces(const char* str) {
-  while (IsSpace(*str))
-    str++;
+  while (IsSpace(*str)) str++;
   return str;
 }
 
@@ -85,8 +83,7 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames(
   }
 
   for (RegisteredTestIter it = registered_tests_.begin();
-       it != registered_tests_.end();
-       ++it) {
+       it != registered_tests_.end(); ++it) {
     if (tests.count(it->first) == 0) {
       errors << "You forgot to list test " << it->first << ".\n";
     }
diff --git a/googletest/googletest/src/gtest.cc b/googletest/googletest/src/gtest.cc
index 840e38a8ddf277ab2b0f145c6dbfa1d748f6e7ce..918ce1d3ad113f4b56a585909cce4b39a2a5b4bd 100644
--- a/googletest/googletest/src/gtest.cc
+++ b/googletest/googletest/src/gtest.cc
@@ -31,8 +31,6 @@
 // The Google C++ Testing and Mocking Framework (Google Test)
 
 #include "gtest/gtest.h"
-#include "gtest/internal/custom/gtest.h"
-#include "gtest/gtest-spi.h"
 
 #include <ctype.h>
 #include <stdarg.h>
@@ -46,79 +44,89 @@
 #include <chrono>  // NOLINT
 #include <cmath>
 #include <cstdint>
+#include <initializer_list>
 #include <iomanip>
+#include <iterator>
 #include <limits>
 #include <list>
 #include <map>
 #include <ostream>  // NOLINT
 #include <sstream>
+#include <unordered_set>
 #include <vector>
+
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/internal/custom/gtest.h"
+#include "gtest/internal/gtest-port.h"
+
 using namespace testing::ext;
 #if GTEST_OS_LINUX
 
-# include <fcntl.h>  // NOLINT
-# include <limits.h>  // NOLINT
-# include <sched.h>  // NOLINT
+#include <fcntl.h>   // NOLINT
+#include <limits.h>  // NOLINT
+#include <sched.h>   // NOLINT
 // Declares vsnprintf().  This header is not available on Windows.
-# include <strings.h>  // NOLINT
-# include <sys/mman.h>  // NOLINT
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
-# include <string>
+#include <strings.h>   // NOLINT
+#include <sys/mman.h>  // NOLINT
+#include <sys/time.h>  // NOLINT
+#include <unistd.h>    // NOLINT
+
+#include <string>
 
 #elif GTEST_OS_ZOS
-# include <sys/time.h>  // NOLINT
+#include <sys/time.h>  // NOLINT
 
 // On z/OS we additionally need strings.h for strcasecmp.
-# include <strings.h>  // NOLINT
+#include <strings.h>   // NOLINT
 
 #elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
 
-# include <windows.h>  // NOLINT
-# undef min
+#include <windows.h>  // NOLINT
+#undef min
 
 #elif GTEST_OS_WINDOWS  // We are on Windows proper.
 
-# include <windows.h>  // NOLINT
-# undef min
+#include <windows.h>  // NOLINT
+#undef min
 
 #ifdef _MSC_VER
-# include <crtdbg.h>  // NOLINT
+#include <crtdbg.h>  // NOLINT
 #endif
 
-# include <io.h>  // NOLINT
-# include <sys/timeb.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
-# include <sys/stat.h>  // NOLINT
+#include <io.h>         // NOLINT
+#include <sys/stat.h>   // NOLINT
+#include <sys/timeb.h>  // NOLINT
+#include <sys/types.h>  // NOLINT
 
-# if GTEST_OS_WINDOWS_MINGW
-#  include <sys/time.h>  // NOLINT
-# endif  // GTEST_OS_WINDOWS_MINGW
+#if GTEST_OS_WINDOWS_MINGW
+#include <sys/time.h>  // NOLINT
+#endif                 // GTEST_OS_WINDOWS_MINGW
 
 #else
 
 // cpplint thinks that the header is already included, so we want to
 // silence it.
-# include <sys/time.h>  // NOLINT
-# include <unistd.h>  // NOLINT
+#include <sys/time.h>  // NOLINT
+#include <unistd.h>    // NOLINT
 
 #endif  // GTEST_OS_LINUX
 
 #if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>
+#include <stdexcept>
 #endif
 
 #if GTEST_CAN_STREAM_RESULTS_
-# include <arpa/inet.h>  // NOLINT
-# include <netdb.h>  // NOLINT
-# include <sys/socket.h>  // NOLINT
-# include <sys/types.h>  // NOLINT
+#include <arpa/inet.h>   // NOLINT
+#include <netdb.h>       // NOLINT
+#include <sys/socket.h>  // NOLINT
+#include <sys/types.h>   // NOLINT
 #endif
 
 #include "src/gtest-internal-inl.h"
 
 #if GTEST_OS_WINDOWS
-# define vsnprintf _vsnprintf
+#define vsnprintf _vsnprintf
 #endif  // GTEST_OS_WINDOWS
 
 #if GTEST_OS_MAC
@@ -131,9 +139,20 @@ using namespace testing::ext;
 #include "absl/debugging/failure_signal_handler.h"
 #include "absl/debugging/stacktrace.h"
 #include "absl/debugging/symbolize.h"
+#include "absl/flags/parse.h"
+#include "absl/flags/usage.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_replace.h"
 #endif  // GTEST_HAS_ABSL
 
+// Checks builtin compiler feature |x| while avoiding an extra layer of #ifdefs
+// at the callsite.
+#if defined(__has_builtin)
+#define GTEST_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define GTEST_HAS_BUILTIN(x) 0
+#endif  // defined(__has_builtin)
+
 namespace testing {
 
 using internal::CountIf;
@@ -177,7 +196,8 @@ const char kStackTraceMarker[] = "\nStack trace:\n";
 // is specified on the command line.
 bool g_help_flag = false;
 
-// Utilty function to Open File for Writing
+#if GTEST_HAS_FILE_SYSTEM
+// Utility function to Open File for Writing
 static FILE* OpenFileForWriting(const std::string& output_file) {
   FILE* fileout = nullptr;
   FilePath output_file_path(output_file);
@@ -191,6 +211,7 @@ static FILE* OpenFileForWriting(const std::string& output_file) {
   }
   return fileout;
 }
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 }  // namespace internal
 
@@ -216,28 +237,33 @@ static bool GetDefaultFailFast() {
   return false;
 }
 
+}  // namespace testing
+
 GTEST_DEFINE_bool_(
-    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
+    fail_fast,
+    testing::internal::BoolFromGTestEnv("fail_fast",
+                                        testing::GetDefaultFailFast()),
     "True if and only if a test failure should stop further test execution.");
 
 GTEST_DEFINE_bool_(
     also_run_disabled_tests,
-    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
+    testing::internal::BoolFromGTestEnv("also_run_disabled_tests", false),
     "Run disabled tests too, in addition to the tests normally being run.");
 
 GTEST_DEFINE_bool_(
-    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
+    break_on_failure,
+    testing::internal::BoolFromGTestEnv("break_on_failure", false),
     "True if and only if a failed assertion should be a debugger "
     "break-point.");
 
 GTEST_DEFINE_bool_(catch_exceptions,
-                   internal::BoolFromGTestEnv("catch_exceptions", true),
+                   testing::internal::BoolFromGTestEnv("catch_exceptions",
+                                                       true),
                    "True if and only if " GTEST_NAME_
                    " should catch exceptions and treat them as test failures.");
 
 GTEST_DEFINE_string_(
-    color,
-    internal::StringFromGTestEnv("color", "auto"),
+    color, testing::internal::StringFromGTestEnv("color", "auto"),
     "Whether to use colors in the output.  Valid values: yes, no, "
     "and auto.  'auto' means to use colors if the output is "
     "being sent to a terminal and the TERM environment variable "
@@ -245,7 +271,8 @@ GTEST_DEFINE_string_(
 
 GTEST_DEFINE_string_(
     filter,
-    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
+    testing::internal::StringFromGTestEnv("filter",
+                                          testing::GetDefaultFilter()),
     "A colon-separated list of glob (not regex) patterns "
     "for filtering the tests to run, optionally followed by a "
     "'-' and a : separated list of negative patterns (tests to "
@@ -254,13 +281,14 @@ GTEST_DEFINE_string_(
 
 GTEST_DEFINE_bool_(
     install_failure_signal_handler,
-    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
-    "If true and supported on the current platform, " GTEST_NAME_ " should "
+    testing::internal::BoolFromGTestEnv("install_failure_signal_handler",
+                                        false),
+    "If true and supported on the current platform, " GTEST_NAME_
+    " should "
     "install a signal handler that dumps debugging information when fatal "
     "signals are raised.");
 
-GTEST_DEFINE_bool_(list_tests, false,
-                   "List all tests without running them.");
+GTEST_DEFINE_bool_(list_tests, false, "List all tests without running them.");
 
 // The net priority order after flag processing is thus:
 //   --gtest_output command line flag
@@ -269,8 +297,8 @@ GTEST_DEFINE_bool_(list_tests, false,
 //   ''
 GTEST_DEFINE_string_(
     output,
-    internal::StringFromGTestEnv("output",
-      internal::OutputFlagAlsoCheckEnvVar().c_str()),
+    testing::internal::StringFromGTestEnv(
+        "output", testing::internal::OutputFlagAlsoCheckEnvVar().c_str()),
     "A format (defaults to \"xml\" but can be specified to be \"json\"), "
     "optionally followed by a colon and an output file name or directory. "
     "A directory is indicated by a trailing pathname separator. "
@@ -281,77 +309,92 @@ GTEST_DEFINE_string_(
     "digits.");
 
 GTEST_DEFINE_bool_(
-    brief, internal::BoolFromGTestEnv("brief", false),
+    brief, testing::internal::BoolFromGTestEnv("brief", false),
     "True if only test failures should be displayed in text output.");
 
-GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
+GTEST_DEFINE_bool_(print_time,
+                   testing::internal::BoolFromGTestEnv("print_time", true),
                    "True if and only if " GTEST_NAME_
                    " should display elapsed time in text output.");
 
-GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
+GTEST_DEFINE_bool_(print_utf8,
+                   testing::internal::BoolFromGTestEnv("print_utf8", true),
                    "True if and only if " GTEST_NAME_
                    " prints UTF8 characters as text.");
 
 GTEST_DEFINE_int32_(
-    random_seed,
-    internal::Int32FromGTestEnv("random_seed", 0),
+    random_seed, testing::internal::Int32FromGTestEnv("random_seed", 0),
     "Random number seed to use when shuffling test orders.  Must be in range "
     "[1, 99999], or 0 to use a seed based on the current time.");
 
 GTEST_DEFINE_int32_(
-    repeat,
-    internal::Int32FromGTestEnv("repeat", 1),
+    repeat, testing::internal::Int32FromGTestEnv("repeat", 1),
     "How many times to repeat each test.  Specify a negative number "
     "for repeating forever.  Useful for shaking out flaky tests.");
 
+GTEST_DEFINE_bool_(
+    recreate_environments_when_repeating,
+    testing::internal::BoolFromGTestEnv("recreate_environments_when_repeating",
+                                        false),
+    "Controls whether global test environments are recreated for each repeat "
+    "of the tests. If set to false the global test environments are only set "
+    "up once, for the first iteration, and only torn down once, for the last. "
+    "Useful for shaking out flaky tests with stable, expensive test "
+    "environments. If --gtest_repeat is set to a negative number, meaning "
+    "there is no last run, the environments will always be recreated to avoid "
+    "leaks.");
+
 GTEST_DEFINE_bool_(show_internal_stack_frames, false,
                    "True if and only if " GTEST_NAME_
                    " should include internal stack frames when "
                    "printing test failure stack traces.");
 
-GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
+GTEST_DEFINE_bool_(shuffle,
+                   testing::internal::BoolFromGTestEnv("shuffle", false),
                    "True if and only if " GTEST_NAME_
                    " should randomize tests' order on every run.");
 
 GTEST_DEFINE_int32_(
     stack_trace_depth,
-    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    testing::internal::Int32FromGTestEnv("stack_trace_depth",
+                                         testing::kMaxStackTraceDepth),
     "The maximum number of stack frames to print when an "
     "assertion fails.  The valid range is 0 through 100, inclusive.");
 
 GTEST_DEFINE_string_(
     stream_result_to,
-    internal::StringFromGTestEnv("stream_result_to", ""),
+    testing::internal::StringFromGTestEnv("stream_result_to", ""),
     "This flag specifies the host name and the port number on which to stream "
     "test results. Example: \"localhost:555\". The flag is effective only on "
     "Linux.");
 
 GTEST_DEFINE_bool_(
     throw_on_failure,
-    internal::BoolFromGTestEnv("throw_on_failure", false),
+    testing::internal::BoolFromGTestEnv("throw_on_failure", false),
     "When this flag is specified, a failed assertion will throw an exception "
     "if exceptions are enabled or exit the program with a non-zero code "
     "otherwise. For use with an external test framework.");
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
 GTEST_DEFINE_string_(
-    flagfile,
-    internal::StringFromGTestEnv("flagfile", ""),
+    flagfile, testing::internal::StringFromGTestEnv("flagfile", ""),
     "This flag specifies the flagfile to read command-line flags from.");
 #endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
 
+namespace testing {
 namespace internal {
 
+const uint32_t Random::kMaxRange;
+
 // Generates a random number from [0, range), using a Linear
 // Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
 // than kMaxRange.
 uint32_t Random::Generate(uint32_t range) {
   // These constants are the same as are used in glibc's rand(3).
   // Use wider types than necessary to prevent unsigned overflow diagnostics.
-  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
+  state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;
 
-  GTEST_CHECK_(range > 0)
-      << "Cannot generate a number in the range [0, 0).";
+  GTEST_CHECK_(range > 0) << "Cannot generate a number in the range [0, 0).";
   GTEST_CHECK_(range <= kMaxRange)
       << "Generation of a number in [0, " << range << ") was requested, "
       << "but this can only generate numbers in [0, " << kMaxRange << ").";
@@ -396,32 +439,26 @@ static bool ShouldRunTestSuite(const TestSuite* test_suite) {
 }
 
 // AssertHelper constructor.
-AssertHelper::AssertHelper(TestPartResult::Type type,
-                           const char* file,
-                           int line,
-                           const char* message)
-    : data_(new AssertHelperData(type, file, line, message)) {
-}
+AssertHelper::AssertHelper(TestPartResult::Type type, const char* file,
+                           int line, const char* message)
+    : data_(new AssertHelperData(type, file, line, message)) {}
 
-AssertHelper::~AssertHelper() {
-  delete data_;
-}
+AssertHelper::~AssertHelper() { delete data_; }
 
 // Message assignment, for assertion streaming support.
 void AssertHelper::operator=(const Message& message) const {
-  UnitTest::GetInstance()->
-    AddTestPartResult(data_->type, data_->file, data_->line,
-                      AppendUserMessage(data_->message, message),
-                      UnitTest::GetInstance()->impl()
-                      ->CurrentOsStackTraceExceptTop(1)
-                      // Skips the stack frame for this function itself.
-                      );  // NOLINT
+  UnitTest::GetInstance()->AddTestPartResult(
+      data_->type, data_->file, data_->line,
+      AppendUserMessage(data_->message, message),
+      UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
+      // Skips the stack frame for this function itself.
+  );  // NOLINT
 }
 
 namespace {
 
 // When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
-// to creates test cases for it, a syntetic test case is
+// to creates test cases for it, a synthetic test case is
 // inserted to report ether an error or a log message.
 //
 // This configuration bit will likely be removed at some point.
@@ -452,7 +489,6 @@ class FailureTest : public Test {
   const bool as_error_;
 };
 
-
 }  // namespace
 
 std::set<std::string>* GetIgnoredParameterizedTestSuites() {
@@ -496,7 +532,8 @@ void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
       "To suppress this error for this test suite, insert the following line "
       "(in a non-header) in the namespace it is defined in:"
       "\n\n"
-      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
+      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
+      name + ");";
 
   std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
   RegisterTest(  //
@@ -516,19 +553,18 @@ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
 }
 
 void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
-  GetUnitTestImpl()
-      ->type_parameterized_test_registry()
-      .RegisterInstantiation(case_name);
+  GetUnitTestImpl()->type_parameterized_test_registry().RegisterInstantiation(
+      case_name);
 }
 
 void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
     const char* test_suite_name, CodeLocation code_location) {
   suites_.emplace(std::string(test_suite_name),
-                 TypeParameterizedTestSuiteInfo(code_location));
+                  TypeParameterizedTestSuiteInfo(code_location));
 }
 
 void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
-        const char* test_suite_name) {
+    const char* test_suite_name) {
   auto it = suites_.find(std::string(test_suite_name));
   if (it != suites_.end()) {
     it->second.instantiated = true;
@@ -588,6 +624,7 @@ static ::std::vector<std::string> g_argvs;
 #endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
 }
 
+#if GTEST_HAS_FILE_SYSTEM
 // Returns the current application's name, removing directory path if that
 // is present.
 FilePath GetCurrentExecutableName() {
@@ -601,12 +638,14 @@ FilePath GetCurrentExecutableName() {
 
   return result.RemoveDirectoryName();
 }
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 // Functions for processing the gtest_output flag.
 
 // Returns the output format, or "" for normal printed output.
 std::string UnitTestOptions::GetOutputFormat() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  std::string s = GTEST_FLAG_GET(output);
+  const char* const gtest_output_flag = s.c_str();
   const char* const colon = strchr(gtest_output_flag, ':');
   return (colon == nullptr)
              ? std::string(gtest_output_flag)
@@ -614,22 +653,23 @@ std::string UnitTestOptions::GetOutputFormat() {
                            static_cast<size_t>(colon - gtest_output_flag));
 }
 
+#if GTEST_HAS_FILE_SYSTEM
 // Returns the name of the requested output file, or the default if none
 // was explicitly specified.
 std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
-  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  std::string s = GTEST_FLAG_GET(output);
+  const char* const gtest_output_flag = s.c_str();
 
   std::string format = GetOutputFormat();
-  if (format.empty())
-    format = std::string(kDefaultOutputFormat);
+  if (format.empty()) format = std::string(kDefaultOutputFormat);
 
   const char* const colon = strchr(gtest_output_flag, ':');
   if (colon == nullptr)
     return internal::FilePath::MakeFileName(
-        internal::FilePath(
-            UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(kDefaultOutputFile), 0,
-        format.c_str()).string();
+               internal::FilePath(
+                   UnitTest::GetInstance()->original_working_dir()),
+               internal::FilePath(kDefaultOutputFile), 0, format.c_str())
+        .string();
 
   internal::FilePath output_name(colon + 1);
   if (!output_name.IsAbsolutePath())
@@ -637,14 +677,14 @@ std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
         internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
         internal::FilePath(colon + 1));
 
-  if (!output_name.IsDirectory())
-    return output_name.string();
+  if (!output_name.IsDirectory()) return output_name.string();
 
   internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
       output_name, internal::GetCurrentExecutableName(),
       GetOutputFormat().c_str()));
   return result.string();
 }
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 // Returns true if and only if the wildcard pattern matches the string. Each
 // pattern consists of regular characters, single-character wildcards (?), and
@@ -699,59 +739,119 @@ static bool PatternMatchesString(const std::string& name_str,
   return true;
 }
 
-bool UnitTestOptions::MatchesFilter(const std::string& name_str,
-                                    const char* filter) {
-  // The filter is a list of patterns separated by colons (:).
-  const char* pattern = filter;
-  while (true) {
-    // Find the bounds of this pattern.
-    const char* const next_sep = strchr(pattern, ':');
-    const char* const pattern_end =
-        next_sep != nullptr ? next_sep : pattern + strlen(pattern);
-
-    // Check if this pattern matches name_str.
-    if (PatternMatchesString(name_str, pattern, pattern_end)) {
-      return true;
-    }
+namespace {
 
-    // Give up on this pattern. However, if we found a pattern separator (:),
-    // advance to the next pattern (skipping over the separator) and restart.
-    if (next_sep == nullptr) {
-      return false;
+bool IsGlobPattern(const std::string& pattern) {
+  return std::any_of(pattern.begin(), pattern.end(),
+                     [](const char c) { return c == '?' || c == '*'; });
+}
+
+class UnitTestFilter {
+ public:
+  UnitTestFilter() = default;
+
+  // Constructs a filter from a string of patterns separated by `:`.
+  explicit UnitTestFilter(const std::string& filter) {
+    // By design "" filter matches "" string.
+    std::vector<std::string> all_patterns;
+    SplitString(filter, ':', &all_patterns);
+    const auto exact_match_patterns_begin = std::partition(
+        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
+
+    glob_patterns_.reserve(static_cast<size_t>(
+        std::distance(all_patterns.begin(), exact_match_patterns_begin)));
+    std::move(all_patterns.begin(), exact_match_patterns_begin,
+              std::inserter(glob_patterns_, glob_patterns_.begin()));
+    std::move(
+        exact_match_patterns_begin, all_patterns.end(),
+        std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
+  }
+
+  // Returns true if and only if name matches at least one of the patterns in
+  // the filter.
+  bool MatchesName(const std::string& name) const {
+    return exact_match_patterns_.count(name) > 0 ||
+           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
+                       [&name](const std::string& pattern) {
+                         return PatternMatchesString(
+                             name, pattern.c_str(),
+                             pattern.c_str() + pattern.size());
+                       });
+  }
+
+ private:
+  std::vector<std::string> glob_patterns_;
+  std::unordered_set<std::string> exact_match_patterns_;
+};
+
+class PositiveAndNegativeUnitTestFilter {
+ public:
+  // Constructs a positive and a negative filter from a string. The string
+  // contains a positive filter optionally followed by a '-' character and a
+  // negative filter. In case only a negative filter is provided the positive
+  // filter will be assumed "*".
+  // A filter is a list of patterns separated by ':'.
+  explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
+    std::vector<std::string> positive_and_negative_filters;
+
+    // NOTE: `SplitString` always returns a non-empty container.
+    SplitString(filter, '-', &positive_and_negative_filters);
+    const auto& positive_filter = positive_and_negative_filters.front();
+
+    if (positive_and_negative_filters.size() > 1) {
+      positive_filter_ = UnitTestFilter(
+          positive_filter.empty() ? kUniversalFilter : positive_filter);
+
+      // TODO(b/214626361): Fail on multiple '-' characters
+      // For the moment to preserve old behavior we concatenate the rest of the
+      // string parts with `-` as separator to generate the negative filter.
+      auto negative_filter_string = positive_and_negative_filters[1];
+      for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++)
+        negative_filter_string =
+            negative_filter_string + '-' + positive_and_negative_filters[i];
+      negative_filter_ = UnitTestFilter(negative_filter_string);
+    } else {
+      // In case we don't have a negative filter and positive filter is ""
+      // we do not use kUniversalFilter by design as opposed to when we have a
+      // negative filter.
+      positive_filter_ = UnitTestFilter(positive_filter);
     }
-    pattern = next_sep + 1;
   }
-  return true;
+
+  // Returns true if and only if test name (this is generated by appending test
+  // suit name and test name via a '.' character) matches the positive filter
+  // and does not match the negative filter.
+  bool MatchesTest(const std::string& test_suite_name,
+                   const std::string& test_name) const {
+    return MatchesName(test_suite_name + "." + test_name);
+  }
+
+  // Returns true if and only if name matches the positive filter and does not
+  // match the negative filter.
+  bool MatchesName(const std::string& name) const {
+    return positive_filter_.MatchesName(name) &&
+           !negative_filter_.MatchesName(name);
+  }
+
+ private:
+  UnitTestFilter positive_filter_;
+  UnitTestFilter negative_filter_;
+};
+}  // namespace
+
+bool UnitTestOptions::MatchesFilter(const std::string& name_str,
+                                    const char* filter) {
+  return UnitTestFilter(filter).MatchesName(name_str);
 }
 
 // Returns true if and only if the user-specified filter matches the test
 // suite name and the test name.
 bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
                                         const std::string& test_name) {
-  const std::string& full_name = test_suite_name + "." + test_name.c_str();
-
   // Split --gtest_filter at '-', if there is one, to separate into
   // positive filter and negative filter portions
-  const char* const p = GTEST_FLAG(filter).c_str();
-  const char* const dash = strchr(p, '-');
-  std::string positive;
-  std::string negative;
-  if (dash == nullptr) {
-    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
-    negative = "";
-  } else {
-    positive = std::string(p, dash);   // Everything up to the dash
-    negative = std::string(dash + 1);  // Everything after the dash
-    if (positive.empty()) {
-      // Treat '-test1' as the same as '*-test1'
-      positive = kUniversalFilter;
-    }
-  }
-
-  // A filter is a colon-separated list of patterns.  It matches a
-  // test if any pattern in it matches the test.
-  return (MatchesFilter(full_name, positive.c_str()) &&
-          !MatchesFilter(full_name, negative.c_str()));
+  return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_GET(filter))
+      .MatchesTest(test_suite_name, test_name);
 }
 
 #if GTEST_HAS_SEH
@@ -771,7 +871,7 @@ int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
 
   bool should_handle = true;
 
-  if (!GTEST_FLAG(catch_exceptions))
+  if (!GTEST_FLAG_GET(catch_exceptions))
     should_handle = false;
   else if (exception_code == EXCEPTION_BREAKPOINT)
     should_handle = false;
@@ -789,8 +889,7 @@ int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
 // results. Intercepts only failures from the current thread.
 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
     TestPartResultArray* result)
-    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
-      result_(result) {
+    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), result_(result) {
   Init();
 }
 
@@ -799,8 +898,7 @@ ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
 // results.
 ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
     InterceptMode intercept_mode, TestPartResultArray* result)
-    : intercept_mode_(intercept_mode),
-      result_(result) {
+    : intercept_mode_(intercept_mode), result_(result) {
   Init();
 }
 
@@ -844,9 +942,7 @@ namespace internal {
 // from user test code.  GetTestTypeId() is guaranteed to always
 // return the same value, as it always calls GetTypeId<>() from the
 // gtest.cc, which is within the Google Test framework.
-TypeId GetTestTypeId() {
-  return GetTypeId<Test>();
-}
+TypeId GetTestTypeId() { return GetTypeId<Test>(); }
 
 // The value of GetTestTypeId() as seen from within the Google Test
 // library.  This is solely for testing GetTestTypeId().
@@ -861,9 +957,9 @@ static AssertionResult HasOneFailure(const char* /* results_expr */,
                                      const TestPartResultArray& results,
                                      TestPartResult::Type type,
                                      const std::string& substr) {
-  const std::string expected(type == TestPartResult::kFatalFailure ?
-                        "1 fatal failure" :
-                        "1 non-fatal failure");
+  const std::string expected(type == TestPartResult::kFatalFailure
+                                 ? "1 fatal failure"
+                                 : "1 non-fatal failure");
   Message msg;
   if (results.size() != 1) {
     msg << "Expected: " << expected << "\n"
@@ -882,10 +978,10 @@ static AssertionResult HasOneFailure(const char* /* results_expr */,
   }
 
   if (strstr(r.message(), substr.c_str()) == nullptr) {
-    return AssertionFailure() << "Expected: " << expected << " containing \""
-                              << substr << "\"\n"
-                              << "  Actual:\n"
-                              << r;
+    return AssertionFailure()
+           << "Expected: " << expected << " containing \"" << substr << "\"\n"
+           << "  Actual:\n"
+           << r;
   }
 
   return AssertionSuccess();
@@ -908,7 +1004,8 @@ SingleFailureChecker::~SingleFailureChecker() {
 }
 
 DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+    UnitTestImpl* unit_test)
+    : unit_test_(unit_test) {}
 
 void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
     const TestPartResult& result) {
@@ -917,7 +1014,8 @@ void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
 }
 
 DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
-    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+    UnitTestImpl* unit_test)
+    : unit_test_(unit_test) {}
 
 void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
     const TestPartResult& result) {
@@ -928,14 +1026,14 @@ void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
 TestPartResultReporterInterface*
 UnitTestImpl::GetGlobalTestPartResultReporter() {
   internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  return global_test_part_result_repoter_;
+  return global_test_part_result_reporter_;
 }
 
 // Sets the global test part result reporter.
 void UnitTestImpl::SetGlobalTestPartResultReporter(
     TestPartResultReporterInterface* reporter) {
   internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
-  global_test_part_result_repoter_ = reporter;
+  global_test_part_result_reporter_ = reporter;
 }
 
 // Returns the test part result reporter for the current thread.
@@ -1024,27 +1122,33 @@ int UnitTestImpl::test_to_run_count() const {
 // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
 std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
   return os_stack_trace_getter()->CurrentStackTrace(
-      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
-      skip_count + 1
+      static_cast<int>(GTEST_FLAG_GET(stack_trace_depth)), skip_count + 1
       // Skips the user-specified number of frames plus this function
       // itself.
-      );  // NOLINT
+  );  // NOLINT
 }
 
 // A helper class for measuring elapsed times.
 class Timer {
  public:
-  Timer() : start_(std::chrono::steady_clock::now()) {}
+  Timer() : start_(clock::now()) {}
 
   // Return time elapsed in milliseconds since the timer was created.
   TimeInMillis Elapsed() {
     return std::chrono::duration_cast<std::chrono::milliseconds>(
-               std::chrono::steady_clock::now() - start_)
+               clock::now() - start_)
         .count();
   }
 
  private:
-  std::chrono::steady_clock::time_point start_;
+  // Fall back to the system_clock when building with newlib on a system
+  // without a monotonic clock.
+#if defined(_NEWLIB_VERSION) && !defined(CLOCK_MONOTONIC)
+  using clock = std::chrono::system_clock;
+#else
+  using clock = std::chrono::steady_clock;
+#endif
+  clock::time_point start_;
 };
 
 // Returns a timestamp as milliseconds since the epoch. Note this time may jump
@@ -1072,8 +1176,7 @@ LPCWSTR String::AnsiToUtf16(const char* ansi) {
   const int unicode_length =
       MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
   WCHAR* unicode = new WCHAR[unicode_length + 1];
-  MultiByteToWideChar(CP_ACP, 0, ansi, length,
-                      unicode, unicode_length);
+  MultiByteToWideChar(CP_ACP, 0, ansi, length, unicode, unicode_length);
   unicode[unicode_length] = 0;
   return unicode;
 }
@@ -1082,7 +1185,7 @@ LPCWSTR String::AnsiToUtf16(const char* ansi) {
 // memory using new. The caller is responsible for deleting the return
 // value using delete[]. Returns the ANSI string, or NULL if the
 // input is NULL.
-const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
+const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {
   if (!utf16_str) return nullptr;
   const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
                                               0, nullptr, nullptr);
@@ -1101,7 +1204,7 @@ const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
 // Unlike strcmp(), this function can handle NULL argument(s).  A NULL
 // C string is considered different to any non-NULL C string,
 // including the empty string.
-bool String::CStringEquals(const char * lhs, const char * rhs) {
+bool String::CStringEquals(const char* lhs, const char* rhs) {
   if (lhs == nullptr) return rhs == nullptr;
 
   if (rhs == nullptr) return false;
@@ -1115,11 +1218,10 @@ bool String::CStringEquals(const char * lhs, const char * rhs) {
 // encoding, and streams the result to the given Message object.
 static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
                                      Message* msg) {
-  for (size_t i = 0; i != length; ) {  // NOLINT
+  for (size_t i = 0; i != length;) {  // NOLINT
     if (wstr[i] != L'\0') {
       *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
-      while (i != length && wstr[i] != L'\0')
-        i++;
+      while (i != length && wstr[i] != L'\0') i++;
     } else {
       *msg << '\0';
       i++;
@@ -1161,17 +1263,17 @@ Message::Message() : ss_(new ::std::stringstream) {
 
 // These two overloads allow streaming a wide C string to a Message
 // using the UTF-8 encoding.
-Message& Message::operator <<(const wchar_t* wide_c_str) {
+Message& Message::operator<<(const wchar_t* wide_c_str) {
   return *this << internal::String::ShowWideCString(wide_c_str);
 }
-Message& Message::operator <<(wchar_t* wide_c_str) {
+Message& Message::operator<<(wchar_t* wide_c_str) {
   return *this << internal::String::ShowWideCString(wide_c_str);
 }
 
 #if GTEST_HAS_STD_WSTRING
 // Converts the given wide string to a narrow string using the UTF-8
 // encoding, and streams the result to this Message object.
-Message& Message::operator <<(const ::std::wstring& wstr) {
+Message& Message::operator<<(const ::std::wstring& wstr) {
   internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
   return *this;
 }
@@ -1183,44 +1285,6 @@ std::string Message::GetString() const {
   return internal::StringStreamToString(ss_.get());
 }
 
-// AssertionResult constructors.
-// Used in EXPECT_TRUE/FALSE(assertion_result).
-AssertionResult::AssertionResult(const AssertionResult& other)
-    : success_(other.success_),
-      message_(other.message_.get() != nullptr
-                   ? new ::std::string(*other.message_)
-                   : static_cast< ::std::string*>(nullptr)) {}
-
-// Swaps two AssertionResults.
-void AssertionResult::swap(AssertionResult& other) {
-  using std::swap;
-  swap(success_, other.success_);
-  swap(message_, other.message_);
-}
-
-// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
-AssertionResult AssertionResult::operator!() const {
-  AssertionResult negation(!success_);
-  if (message_.get() != nullptr) negation << *message_;
-  return negation;
-}
-
-// Makes a successful assertion result.
-AssertionResult AssertionSuccess() {
-  return AssertionResult(true);
-}
-
-// Makes a failed assertion result.
-AssertionResult AssertionFailure() {
-  return AssertionResult(false);
-}
-
-// Makes a failed assertion result with the given failure message.
-// Deprecated; use AssertionFailure() << message.
-AssertionResult AssertionFailure(const Message& message) {
-  return AssertionFailure() << message;
-}
-
 namespace internal {
 
 namespace edit_distance {
@@ -1512,8 +1576,7 @@ std::vector<std::string> SplitEscapedString(const std::string& str) {
 AssertionResult EqFailure(const char* lhs_expression,
                           const char* rhs_expression,
                           const std::string& lhs_value,
-                          const std::string& rhs_value,
-                          bool ignoring_case) {
+                          const std::string& rhs_value, bool ignoring_case) {
   Message msg;
   msg << "Expected equality of these values:";
   msg << "\n  " << lhs_expression;
@@ -1530,10 +1593,8 @@ AssertionResult EqFailure(const char* lhs_expression,
   }
 
   if (!lhs_value.empty() && !rhs_value.empty()) {
-    const std::vector<std::string> lhs_lines =
-        SplitEscapedString(lhs_value);
-    const std::vector<std::string> rhs_lines =
-        SplitEscapedString(rhs_value);
+    const std::vector<std::string> lhs_lines = SplitEscapedString(lhs_value);
+    const std::vector<std::string> rhs_lines = SplitEscapedString(rhs_value);
     if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
       msg << "\nWith diff:\n"
           << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
@@ -1545,27 +1606,21 @@ AssertionResult EqFailure(const char* lhs_expression,
 
 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
 std::string GetBoolAssertionFailureMessage(
-    const AssertionResult& assertion_result,
-    const char* expression_text,
-    const char* actual_predicate_value,
-    const char* expected_predicate_value) {
+    const AssertionResult& assertion_result, const char* expression_text,
+    const char* actual_predicate_value, const char* expected_predicate_value) {
   const char* actual_message = assertion_result.message();
   Message msg;
   msg << "Value of: " << expression_text
       << "\n  Actual: " << actual_predicate_value;
-  if (actual_message[0] != '\0')
-    msg << " (" << actual_message << ")";
+  if (actual_message[0] != '\0') msg << " (" << actual_message << ")";
   msg << "\nExpected: " << expected_predicate_value;
   return msg.GetString();
 }
 
 // Helper function for implementing ASSERT_NEAR.
-AssertionResult DoubleNearPredFormat(const char* expr1,
-                                     const char* expr2,
-                                     const char* abs_error_expr,
-                                     double val1,
-                                     double val2,
-                                     double abs_error) {
+AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2,
+                                     const char* abs_error_expr, double val1,
+                                     double val2, double abs_error) {
   const double diff = fabs(val1 - val2);
   if (diff <= abs_error) return AssertionSuccess();
 
@@ -1595,20 +1650,17 @@ AssertionResult DoubleNearPredFormat(const char* expr1,
               "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
   }
   return AssertionFailure()
-      << "The difference between " << expr1 << " and " << expr2
-      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
-      << expr1 << " evaluates to " << val1 << ",\n"
-      << expr2 << " evaluates to " << val2 << ", and\n"
-      << abs_error_expr << " evaluates to " << abs_error << ".";
+         << "The difference between " << expr1 << " and " << expr2 << " is "
+         << diff << ", which exceeds " << abs_error_expr << ", where\n"
+         << expr1 << " evaluates to " << val1 << ",\n"
+         << expr2 << " evaluates to " << val2 << ", and\n"
+         << abs_error_expr << " evaluates to " << abs_error << ".";
 }
 
-
 // Helper template for implementing FloatLE() and DoubleLE().
 template <typename RawType>
-AssertionResult FloatingPointLE(const char* expr1,
-                                const char* expr2,
-                                RawType val1,
-                                RawType val2) {
+AssertionResult FloatingPointLE(const char* expr1, const char* expr2,
+                                RawType val1, RawType val2) {
   // Returns success if val1 is less than val2,
   if (val1 < val2) {
     return AssertionSuccess();
@@ -1633,24 +1685,24 @@ AssertionResult FloatingPointLE(const char* expr1,
           << val2;
 
   return AssertionFailure()
-      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
-      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
-      << StringStreamToString(&val2_ss);
+         << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+         << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
+         << StringStreamToString(&val2_ss);
 }
 
 }  // namespace internal
 
 // Asserts that val1 is less than, or almost equal to, val2.  Fails
 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult FloatLE(const char* expr1, const char* expr2,
-                        float val1, float val2) {
+AssertionResult FloatLE(const char* expr1, const char* expr2, float val1,
+                        float val2) {
   return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
 }
 
 // Asserts that val1 is less than, or almost equal to, val2.  Fails
 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
-AssertionResult DoubleLE(const char* expr1, const char* expr2,
-                         double val1, double val2) {
+AssertionResult DoubleLE(const char* expr1, const char* expr2, double val1,
+                         double val2) {
   return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
 }
 
@@ -1658,62 +1710,51 @@ namespace internal {
 
 // The helper function for {ASSERT|EXPECT}_STREQ.
 AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const char* lhs,
+                               const char* rhs_expression, const char* lhs,
                                const char* rhs) {
   if (String::CStringEquals(lhs, rhs)) {
     return AssertionSuccess();
   }
 
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
+  return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),
+                   PrintToString(rhs), false);
 }
 
 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
 AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
-                                   const char* rhs_expression,
-                                   const char* lhs,
+                                   const char* rhs_expression, const char* lhs,
                                    const char* rhs) {
   if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
     return AssertionSuccess();
   }
 
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   true);
+  return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),
+                   PrintToString(rhs), true);
 }
 
 // The helper function for {ASSERT|EXPECT}_STRNE.
 AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const char* s1,
+                               const char* s2_expression, const char* s1,
                                const char* s2) {
   if (!String::CStringEquals(s1, s2)) {
     return AssertionSuccess();
   } else {
-    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                              << s2_expression << "), actual: \""
-                              << s1 << "\" vs \"" << s2 << "\"";
+    return AssertionFailure()
+           << "Expected: (" << s1_expression << ") != (" << s2_expression
+           << "), actual: \"" << s1 << "\" vs \"" << s2 << "\"";
   }
 }
 
 // The helper function for {ASSERT|EXPECT}_STRCASENE.
 AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
-                                   const char* s2_expression,
-                                   const char* s1,
+                                   const char* s2_expression, const char* s1,
                                    const char* s2) {
   if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
     return AssertionSuccess();
   } else {
     return AssertionFailure()
-        << "Expected: (" << s1_expression << ") != ("
-        << s2_expression << ") (ignoring case), actual: \""
-        << s1 << "\" vs \"" << s2 << "\"";
+           << "Expected: (" << s1_expression << ") != (" << s2_expression
+           << ") (ignoring case), actual: \"" << s1 << "\" vs \"" << s2 << "\"";
   }
 }
 
@@ -1741,8 +1782,7 @@ bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
 
 // StringType here can be either ::std::string or ::std::wstring.
 template <typename StringType>
-bool IsSubstringPred(const StringType& needle,
-                     const StringType& haystack) {
+bool IsSubstringPred(const StringType& needle, const StringType& haystack) {
   return haystack.find(needle) != StringType::npos;
 }
 
@@ -1751,21 +1791,22 @@ bool IsSubstringPred(const StringType& needle,
 // StringType here can be const char*, const wchar_t*, ::std::string,
 // or ::std::wstring.
 template <typename StringType>
-AssertionResult IsSubstringImpl(
-    bool expected_to_be_substring,
-    const char* needle_expr, const char* haystack_expr,
-    const StringType& needle, const StringType& haystack) {
+AssertionResult IsSubstringImpl(bool expected_to_be_substring,
+                                const char* needle_expr,
+                                const char* haystack_expr,
+                                const StringType& needle,
+                                const StringType& haystack) {
   if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
     return AssertionSuccess();
 
   const bool is_wide_string = sizeof(needle[0]) > 1;
   const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
   return AssertionFailure()
-      << "Value of: " << needle_expr << "\n"
-      << "  Actual: " << begin_string_quote << needle << "\"\n"
-      << "Expected: " << (expected_to_be_substring ? "" : "not ")
-      << "a substring of " << haystack_expr << "\n"
-      << "Which is: " << begin_string_quote << haystack << "\"";
+         << "Value of: " << needle_expr << "\n"
+         << "  Actual: " << begin_string_quote << needle << "\"\n"
+         << "Expected: " << (expected_to_be_substring ? "" : "not ")
+         << "a substring of " << haystack_expr << "\n"
+         << "Which is: " << begin_string_quote << haystack << "\"";
 }
 
 }  // namespace
@@ -1774,52 +1815,52 @@ AssertionResult IsSubstringImpl(
 // substring of haystack (NULL is considered a substring of itself
 // only), and return an appropriate error message when they fail.
 
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
+AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,
+                            const char* needle, const char* haystack) {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
+AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,
+                            const wchar_t* needle, const wchar_t* haystack) {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const char* needle, const char* haystack) {
+AssertionResult IsNotSubstring(const char* needle_expr,
+                               const char* haystack_expr, const char* needle,
+                               const char* haystack) {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const wchar_t* needle, const wchar_t* haystack) {
+AssertionResult IsNotSubstring(const char* needle_expr,
+                               const char* haystack_expr, const wchar_t* needle,
+                               const wchar_t* haystack) {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
+AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,
+                            const ::std::string& needle,
+                            const ::std::string& haystack) {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::string& needle, const ::std::string& haystack) {
+AssertionResult IsNotSubstring(const char* needle_expr,
+                               const char* haystack_expr,
+                               const ::std::string& needle,
+                               const ::std::string& haystack) {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }
 
 #if GTEST_HAS_STD_WSTRING
-AssertionResult IsSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
+AssertionResult IsSubstring(const char* needle_expr, const char* haystack_expr,
+                            const ::std::wstring& needle,
+                            const ::std::wstring& haystack) {
   return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
 }
 
-AssertionResult IsNotSubstring(
-    const char* needle_expr, const char* haystack_expr,
-    const ::std::wstring& needle, const ::std::wstring& haystack) {
+AssertionResult IsNotSubstring(const char* needle_expr,
+                               const char* haystack_expr,
+                               const ::std::wstring& needle,
+                               const ::std::wstring& haystack) {
   return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
 }
 #endif  // GTEST_HAS_STD_WSTRING
@@ -1831,43 +1872,42 @@ namespace internal {
 namespace {
 
 // Helper function for IsHRESULT{SuccessFailure} predicates
-AssertionResult HRESULTFailureHelper(const char* expr,
-                                     const char* expected,
+AssertionResult HRESULTFailureHelper(const char* expr, const char* expected,
                                      long hr) {  // NOLINT
-# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
 
   // Windows CE doesn't support FormatMessage.
   const char error_text[] = "";
 
-# else
+#else
 
   // Looks up the human-readable system message for the HRESULT code
   // and since we're not passing any params to FormatMessage, we don't
   // want inserts expanded.
-  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kFlags =
+      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
   const DWORD kBufSize = 4096;
   // Gets the system's human readable message string for this HRESULT.
-  char error_text[kBufSize] = { '\0' };
+  char error_text[kBufSize] = {'\0'};
   DWORD message_length = ::FormatMessageA(kFlags,
-                                          0,   // no source, we're asking system
+                                          0,  // no source, we're asking system
                                           static_cast<DWORD>(hr),  // the error
-                                          0,   // no line width restrictions
+                                          0,  // no line width restrictions
                                           error_text,  // output buffer
                                           kBufSize,    // buf size
                                           nullptr);  // no arguments for inserts
   // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
   for (; message_length && IsSpace(error_text[message_length - 1]);
-          --message_length) {
+       --message_length) {
     error_text[message_length - 1] = '\0';
   }
 
-# endif  // GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_OS_WINDOWS_MOBILE
 
   const std::string error_hex("0x" + String::FormatHexInt(hr));
   return ::testing::AssertionFailure()
-      << "Expected: " << expr << " " << expected << ".\n"
-      << "  Actual: " << error_hex << " " << error_text << "\n";
+         << "Expected: " << expr << " " << expected << ".\n"
+         << "  Actual: " << error_hex << " " << error_text << "\n";
 }
 
 }  // namespace
@@ -1901,16 +1941,18 @@ AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
 //  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 
 // The maximum code-point a one-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1;
+constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1;
 
 // The maximum code-point a two-byte UTF-8 sequence can represent.
 constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
 
 // The maximum code-point a three-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
+constexpr uint32_t kMaxCodePoint3 =
+    (static_cast<uint32_t>(1) << (4 + 2 * 6)) - 1;
 
 // The maximum code-point a four-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
+constexpr uint32_t kMaxCodePoint4 =
+    (static_cast<uint32_t>(1) << (3 + 3 * 6)) - 1;
 
 // Chops off the n lowest bits from a bit pattern.  Returns the n
 // lowest bits.  As a side effect, the original bit pattern will be
@@ -1935,7 +1977,7 @@ std::string CodePointToUtf8(uint32_t code_point) {
   char str[5];  // Big enough for the largest valid code point.
   if (code_point <= kMaxCodePoint1) {
     str[1] = '\0';
-    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
+    str[0] = static_cast<char>(code_point);  // 0xxxxxxx
   } else if (code_point <= kMaxCodePoint2) {
     str[2] = '\0';
     str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
@@ -1963,8 +2005,8 @@ std::string CodePointToUtf8(uint32_t code_point) {
 // and thus should be combined into a single Unicode code point
 // using CreateCodePointFromUtf16SurrogatePair.
 inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
-  return sizeof(wchar_t) == 2 &&
-      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
+  return sizeof(wchar_t) == 2 && (first & 0xFC00) == 0xD800 &&
+         (second & 0xFC00) == 0xDC00;
 }
 
 // Creates a Unicode code point from UTF16 surrogate pair.
@@ -1995,8 +2037,7 @@ inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
 // and contains invalid UTF-16 surrogate pairs, values in those pairs
 // will be encoded as individual Unicode characters from Basic Normal Plane.
 std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
-  if (num_chars == -1)
-    num_chars = static_cast<int>(wcslen(str));
+  if (num_chars == -1) num_chars = static_cast<int>(wcslen(str));
 
   ::std::stringstream stream;
   for (int i = 0; i < num_chars; ++i) {
@@ -2005,8 +2046,8 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
     if (str[i] == L'\0') {
       break;
     } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
-      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
-                                                                 str[i + 1]);
+      unicode_code_point =
+          CreateCodePointFromUtf16SurrogatePair(str[i], str[i + 1]);
       i++;
     } else {
       unicode_code_point = static_cast<uint32_t>(str[i]);
@@ -2019,7 +2060,7 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
 
 // Converts a wide C string to an std::string using the UTF-8 encoding.
 // NULL will be converted to "(null)".
-std::string String::ShowWideCString(const wchar_t * wide_c_str) {
+std::string String::ShowWideCString(const wchar_t* wide_c_str) {
   if (wide_c_str == nullptr) return "(null)";
 
   return internal::WideStringToUtf8(wide_c_str, -1);
@@ -2031,7 +2072,7 @@ std::string String::ShowWideCString(const wchar_t * wide_c_str) {
 // Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
 // C string is considered different to any non-NULL C string,
 // including the empty string.
-bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
+bool String::WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs) {
   if (lhs == nullptr) return rhs == nullptr;
 
   if (rhs == nullptr) return false;
@@ -2041,33 +2082,27 @@ bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
 
 // Helper function for *_STREQ on wide strings.
 AssertionResult CmpHelperSTREQ(const char* lhs_expression,
-                               const char* rhs_expression,
-                               const wchar_t* lhs,
+                               const char* rhs_expression, const wchar_t* lhs,
                                const wchar_t* rhs) {
   if (String::WideCStringEquals(lhs, rhs)) {
     return AssertionSuccess();
   }
 
-  return EqFailure(lhs_expression,
-                   rhs_expression,
-                   PrintToString(lhs),
-                   PrintToString(rhs),
-                   false);
+  return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),
+                   PrintToString(rhs), false);
 }
 
 // Helper function for *_STRNE on wide strings.
 AssertionResult CmpHelperSTRNE(const char* s1_expression,
-                               const char* s2_expression,
-                               const wchar_t* s1,
+                               const char* s2_expression, const wchar_t* s1,
                                const wchar_t* s2) {
   if (!String::WideCStringEquals(s1, s2)) {
     return AssertionSuccess();
   }
 
-  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
-                            << s2_expression << "), actual: "
-                            << PrintToString(s1)
-                            << " vs " << PrintToString(s2);
+  return AssertionFailure()
+         << "Expected: (" << s1_expression << ") != (" << s2_expression
+         << "), actual: " << PrintToString(s1) << " vs " << PrintToString(s2);
 }
 
 // Compares two C strings, ignoring case.  Returns true if and only if they have
@@ -2076,7 +2111,7 @@ AssertionResult CmpHelperSTRNE(const char* s1_expression,
 // Unlike strcasecmp(), this function can handle NULL argument(s).  A
 // NULL C string is considered different to any non-NULL C string,
 // including the empty string.
-bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
+bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
   if (lhs == nullptr) return rhs == nullptr;
   if (rhs == nullptr) return false;
   return posix::StrCaseCmp(lhs, rhs) == 0;
@@ -2118,8 +2153,8 @@ bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
 
 // Returns true if and only if str ends with the given suffix, ignoring case.
 // Any string is considered to end with an empty suffix.
-bool String::EndsWithCaseInsensitive(
-    const std::string& str, const std::string& suffix) {
+bool String::EndsWithCaseInsensitive(const std::string& str,
+                                     const std::string& suffix) {
   const size_t str_len = str.length();
   const size_t suffix_len = suffix.length();
   return (str_len >= suffix_len) &&
@@ -2202,15 +2237,13 @@ TestResult::TestResult()
     : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
 
 // D'tor.
-TestResult::~TestResult() {
-}
+TestResult::~TestResult() {}
 
 // Returns the i-th test part result among all the results. i can
 // range from 0 to total_part_count() - 1. If i is not in that range,
 // aborts the program.
 const TestPartResult& TestResult::GetTestPartResult(int i) const {
-  if (i < 0 || i >= total_part_count())
-    internal::posix::Abort();
+  if (i < 0 || i >= total_part_count()) internal::posix::Abort();
   return test_part_results_.at(static_cast<size_t>(i));
 }
 
@@ -2218,15 +2251,12 @@ const TestPartResult& TestResult::GetTestPartResult(int i) const {
 // test_property_count() - 1. If i is not in that range, aborts the
 // program.
 const TestProperty& TestResult::GetTestProperty(int i) const {
-  if (i < 0 || i >= test_property_count())
-    internal::posix::Abort();
+  if (i < 0 || i >= test_property_count()) internal::posix::Abort();
   return test_properties_.at(static_cast<size_t>(i));
 }
 
 // Clears the test part results.
-void TestResult::ClearTestPartResults() {
-  test_part_results_.clear();
-}
+void TestResult::ClearTestPartResults() { test_part_results_.clear(); }
 
 // Adds a test part result to the list.
 void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
@@ -2255,15 +2285,8 @@ void TestResult::RecordProperty(const std::string& xml_element,
 // The list of reserved attributes used in the <testsuites> element of XML
 // output.
 static const char* const kReservedTestSuitesAttributes[] = {
-  "disabled",
-  "errors",
-  "failures",
-  "name",
-  "random_seed",
-  "tests",
-  "time",
-  "timestamp"
-};
+    "disabled",    "errors", "failures", "name",
+    "random_seed", "tests",  "time",     "timestamp"};
 
 // The list of reserved attributes used in the <testsuite> element of XML
 // output.
@@ -2273,8 +2296,8 @@ static const char* const kReservedTestSuiteAttributes[] = {
 
 // The list of reserved attributes used in the <testcase> element of XML output.
 static const char* const kReservedTestCaseAttributes[] = {
-    "classname",   "name", "status", "time",  "type_param",
-    "value_param", "file", "line", "level"};
+    "classname",  "name",        "status", "time",
+    "type_param", "value_param", "file",   "line", "level"};
 
 // Use a slightly different set for allowed output to ensure existing tests can
 // still RecordProperty("result") or "RecordProperty(timestamp")
@@ -2336,7 +2359,7 @@ static bool ValidateTestPropertyName(
     const std::string& property_name,
     const std::vector<std::string>& reserved_names) {
   if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
-          reserved_names.end()) {
+      reserved_names.end()) {
     ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
                   << " (" << FormatWordList(reserved_names)
                   << " are reserved by " << GTEST_NAME_ << ")";
@@ -2374,8 +2397,7 @@ bool TestResult::Skipped() const {
 // Returns true if and only if the test failed.
 bool TestResult::Failed() const {
   for (int i = 0; i < total_part_count(); ++i) {
-    if (GetTestPartResult(i).failed())
-      return true;
+    if (GetTestPartResult(i).failed()) return true;
   }
   return false;
 }
@@ -2416,38 +2438,31 @@ int TestResult::test_property_count() const {
 // Creates a Test object.
 
 // The c'tor saves the states of all flags.
-Test::Test()
-    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
-}
+Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}
 
 // The d'tor restores the states of all flags.  The actual work is
 // done by the d'tor of the gtest_flag_saver_ field, and thus not
 // visible here.
-Test::~Test() {
-}
+Test::~Test() {}
 
 // Sets up the test fixture.
 //
 // A sub-class may override this.
-void Test::SetUp() {
-}
+void Test::SetUp() {}
 
 // Tears down the test fixture.
 //
 // A sub-class may override this.
-void Test::TearDown() {
-}
+void Test::TearDown() {}
 
 // Allows user supplied key value pairs to be recorded for later output.
 void Test::RecordProperty(const std::string& key, const std::string& value) {
   UnitTest::GetInstance()->RecordProperty(key, value);
 }
-
-// Allows user supplied key value pairs to be recorded for later output.
-void Test::RecordProperty(const std::string& key, int value) {
-  Message value_message;
-  value_message << value;
-  RecordProperty(key, value_message.GetString().c_str());
+// We do not define a customary serialization except for integers,
+// but other values could be logged in this way.
+void Test::RecordProperty(const std::string& key, int64_t value) {
+  RecordProperty(key, (Message() << value).GetString());
 }
 
 namespace internal {
@@ -2541,8 +2556,8 @@ bool Test::HasSameFixtureClass() {
 static std::string* FormatSehExceptionMessage(DWORD exception_code,
                                               const char* location) {
   Message message;
-  message << "SEH exception with code 0x" << std::setbase(16) <<
-    exception_code << std::setbase(10) << " thrown in " << location << ".";
+  message << "SEH exception with code 0x" << std::setbase(16) << exception_code
+          << std::setbase(10) << " thrown in " << location << ".";
 
   return new std::string(message.GetString());
 }
@@ -2585,8 +2600,8 @@ GoogleTestFailureException::GoogleTestFailureException(
 // exceptions in the same function.  Therefore, we provide a separate
 // wrapper function for handling SEH exceptions.)
 template <class T, typename Result>
-Result HandleSehExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
+Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
+                                              const char* location) {
 #if GTEST_HAS_SEH
   __try {
     return (object->*method)();
@@ -2595,8 +2610,8 @@ Result HandleSehExceptionsInMethodIfSupported(
     // We create the exception message on the heap because VC++ prohibits
     // creation of objects with destructors on stack in functions using __try
     // (see error C2712).
-    std::string* exception_message = FormatSehExceptionMessage(
-        GetExceptionCode(), location);
+    std::string* exception_message =
+        FormatSehExceptionMessage(GetExceptionCode(), location);
     internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                              *exception_message);
     delete exception_message;
@@ -2612,8 +2627,8 @@ Result HandleSehExceptionsInMethodIfSupported(
 // exceptions, if they are supported; returns the 0-value for type
 // Result in case of an SEH exception.
 template <class T, typename Result>
-Result HandleExceptionsInMethodIfSupported(
-    T* object, Result (T::*method)(), const char* location) {
+Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
+                                           const char* location) {
   // NOTE: The user code can affect the way in which Google Test handles
   // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
   // RUN_ALL_TESTS() starts. It is technically possible to check the flag
@@ -2623,7 +2638,7 @@ Result HandleExceptionsInMethodIfSupported(
   // try {
   //   // Perform the test method.
   // } catch (...) {
-  //   if (GTEST_FLAG(catch_exceptions))
+  //   if (GTEST_FLAG_GET(catch_exceptions))
   //     // Report the exception as failure.
   //   else
   //     throw;  // Re-throws the original exception.
@@ -2679,16 +2694,16 @@ void Test::Run() {
   // GTEST_SKIP().
   if (!HasFatalFailure() && !IsSkipped()) {
     impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        this, &Test::TestBody, "the test body");
+    internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody,
+                                                  "the test body");
   }
 
   // However, we want to clean up as much as possible.  Hence we will
   // always call TearDown(), even if SetUp() or the test body has
   // failed.
   impl->os_stack_trace_getter()->UponLeavingGTest();
-  internal::HandleExceptionsInMethodIfSupported(
-      this, &Test::TearDown, "TearDown()");
+  internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown,
+                                                "TearDown()");
 }
 
 // Returns true if and only if the current test has a fatal failure.
@@ -2698,8 +2713,9 @@ bool Test::HasFatalFailure() {
 
 // Returns true if and only if the current test has a non-fatal failure.
 bool Test::HasNonfatalFailure() {
-  return internal::GetUnitTestImpl()->current_test_result()->
-      HasNonfatalFailure();
+  return internal::GetUnitTestImpl()
+      ->current_test_result()
+      ->HasNonfatalFailure();
 }
 
 // Returns true if and only if the current test was skipped.
@@ -2718,7 +2734,8 @@ TestInfo::TestInfo(const std::string& a_test_suite_name,
                    internal::TypeId fixture_class_id,
                    internal::TestFactoryBase* factory)
     : test_suite_name_(a_test_suite_name),
-      name_(a_name),
+      // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
+      name_(a_name.begin(), a_name.end()),
       type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
       value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
       location_(a_code_location),
@@ -2782,38 +2799,6 @@ void ReportInvalidTestSuiteType(const char* test_suite_name,
                                           code_location.line)
                     << " " << errors.GetString();
 }
-}  // namespace internal
-
-namespace {
-
-// A predicate that checks the test name of a TestInfo against a known
-// value.
-//
-// This is used for implementation of the TestSuite class only.  We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestNameIs is copyable.
-class TestNameIs {
- public:
-  // Constructor.
-  //
-  // TestNameIs has NO default constructor.
-  explicit TestNameIs(const char* name)
-      : name_(name) {}
-
-  // Returns true if and only if the test name of test_info matches name_.
-  bool operator()(const TestInfo * test_info) const {
-    return test_info && test_info->name() == name_;
-  }
-
- private:
-  std::string name_;
-};
-
-}  // namespace
-
-namespace internal {
 
 // This method expands all parameterized tests registered with macros TEST_P
 // and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
@@ -2831,20 +2816,20 @@ void UnitTestImpl::RegisterParameterizedTests() {
 // Creates the test object, runs it, records its result, and then
 // deletes it.
 void TestInfo::Run() {
-  if (!should_run_) return;
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+  if (!should_run_) {
+    if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this);
+    return;
+  }
 
   // Tells UnitTest where to store test result.
   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
   impl->set_current_test_info(this);
 
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
   // Notifies the unit test event listeners that a test is about to start.
   repeater->OnTestStart(*this);
-
   result_.set_start_timestamp(internal::GetTimeInMillis());
   internal::Timer timer;
-
   impl->os_stack_trace_getter()->UponLeavingGTest();
 
   // Creates the test object.
@@ -3009,11 +2994,18 @@ void TestSuite::Run() {
   internal::HandleExceptionsInMethodIfSupported(
       this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
 
+  const bool skip_all = ad_hoc_test_result().Failed();
+
   start_timestamp_ = internal::GetTimeInMillis();
   internal::Timer timer;
   for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Run();
-    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
+    if (skip_all) {
+      GetMutableTestInfo(i)->Skip();
+    } else {
+      GetMutableTestInfo(i)->Run();
+    }
+    if (GTEST_FLAG_GET(fail_fast) &&
+        GetMutableTestInfo(i)->result()->Failed()) {
       for (int j = i + 1; j < total_test_count(); j++) {
         GetMutableTestInfo(j)->Skip();
       }
@@ -3089,11 +3081,10 @@ void TestSuite::UnshuffleTests() {
 //
 // FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
 // FormatCountableNoun(5, "book", "books") returns "5 books".
-static std::string FormatCountableNoun(int count,
-                                       const char * singular_form,
-                                       const char * plural_form) {
+static std::string FormatCountableNoun(int count, const char* singular_form,
+                                       const char* plural_form) {
   return internal::StreamableToString(count) + " " +
-      (count == 1 ? singular_form : plural_form);
+         (count == 1 ? singular_form : plural_form);
 }
 
 // Formats the count of tests.
@@ -3110,7 +3101,7 @@ static std::string FormatTestSuiteCount(int test_suite_count) {
 // representation.  Both kNonFatalFailure and kFatalFailure are translated
 // to "Failure", as the user usually doesn't care about the difference
 // between the two when viewing the test result.
-static const char * TestPartResultTypeToString(TestPartResult::Type type) {
+static const char* TestPartResultTypeToString(TestPartResult::Type type) {
   switch (type) {
     case TestPartResult::kSkip:
       return "Skipped\n";
@@ -3137,17 +3128,18 @@ enum class GTestColor { kDefault, kRed, kGreen, kYellow };
 // Prints a TestPartResult to an std::string.
 static std::string PrintTestPartResultToString(
     const TestPartResult& test_part_result) {
-  return (Message()
-          << internal::FormatFileLocation(test_part_result.file_name(),
-                                          test_part_result.line_number())
-          << " " << TestPartResultTypeToString(test_part_result.type())
-          << test_part_result.message()).GetString();
+  return (Message() << internal::FormatFileLocation(
+                           test_part_result.file_name(),
+                           test_part_result.line_number())
+                    << " "
+                    << TestPartResultTypeToString(test_part_result.type())
+                    << test_part_result.message())
+      .GetString();
 }
 
 // Prints a TestPartResult.
 static void PrintTestPartResult(const TestPartResult& test_part_result) {
-  const std::string& result =
-      PrintTestPartResultToString(test_part_result);
+  const std::string& result = PrintTestPartResultToString(test_part_result);
   printf("%s\n", result.c_str());
   fflush(stdout);
   // If the test program runs in Visual Studio or a debugger, the
@@ -3164,8 +3156,8 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
 }
 
 // class PrettyUnitTestResultPrinter
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
 
 // Returns the character attribute for the given color.
 static WORD GetColorAttribute(GTestColor color) {
@@ -3176,7 +3168,8 @@ static WORD GetColorAttribute(GTestColor color) {
       return FOREGROUND_GREEN;
     case GTestColor::kYellow:
       return FOREGROUND_RED | FOREGROUND_GREEN;
-    default:           return 0;
+    default:
+      return 0;
   }
 }
 
@@ -3232,7 +3225,8 @@ static const char* GetAnsiColorCode(GTestColor color) {
 
 // Returns true if and only if Google Test should use colors in the output.
 bool ShouldUseColor(bool stdout_is_tty) {
-  const char* const gtest_color = GTEST_FLAG(color).c_str();
+  std::string c = GTEST_FLAG_GET(color);
+  const char* const gtest_color = c.c_str();
 
   if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
@@ -3243,25 +3237,23 @@ bool ShouldUseColor(bool stdout_is_tty) {
     // On non-Windows platforms, we rely on the TERM variable.
     const char* const term = posix::GetEnv("TERM");
     const bool term_supports_color =
-        String::CStringEquals(term, "xterm") ||
-        String::CStringEquals(term, "xterm-color") ||
-        String::CStringEquals(term, "xterm-256color") ||
-        String::CStringEquals(term, "screen") ||
-        String::CStringEquals(term, "screen-256color") ||
-        String::CStringEquals(term, "tmux") ||
-        String::CStringEquals(term, "tmux-256color") ||
-        String::CStringEquals(term, "rxvt-unicode") ||
-        String::CStringEquals(term, "rxvt-unicode-256color") ||
-        String::CStringEquals(term, "linux") ||
-        String::CStringEquals(term, "cygwin");
+        term != nullptr && (String::CStringEquals(term, "xterm") ||
+                            String::CStringEquals(term, "xterm-color") ||
+                            String::CStringEquals(term, "xterm-kitty") ||
+                            String::CStringEquals(term, "screen") ||
+                            String::CStringEquals(term, "tmux") ||
+                            String::CStringEquals(term, "rxvt-unicode") ||
+                            String::CStringEquals(term, "linux") ||
+                            String::CStringEquals(term, "cygwin") ||
+                            String::EndsWithCaseInsensitive(term, "-256color"));
     return stdout_is_tty && term_supports_color;
 #endif  // GTEST_OS_WINDOWS
   }
 
   return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
-      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
-      String::CStringEquals(gtest_color, "1");
+         String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+         String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+         String::CStringEquals(gtest_color, "1");
   // We take "yes", "true", "t", and "1" as meaning "yes".  If the
   // value is neither one of these nor "auto", we treat it as "no" to
   // be conservative.
@@ -3273,18 +3265,18 @@ bool ShouldUseColor(bool stdout_is_tty) {
 // that would be colored when printed, as can be done on Linux.
 
 GTEST_ATTRIBUTE_PRINTF_(2, 3)
-static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
+static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
 
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
-    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
-  const bool use_color = AlwaysFalse();
-#else
   static const bool in_color_mode =
+#if GTEST_HAS_FILE_SYSTEM
       ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
+#else
+      false;
+#endif  // GTEST_HAS_FILE_SYSTEM
+
   const bool use_color = in_color_mode && (color != GTestColor::kDefault);
-#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
 
   if (!use_color) {
     vprintf(fmt, args);
@@ -3292,8 +3284,8 @@ static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
     return;
   }
 
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
   const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 
   // Gets the current text color.
@@ -3364,6 +3356,7 @@ class PrettyUnitTestResultPrinter : public TestEventListener {
 #endif  // OnTestCaseStart
 
   void OnTestStart(const TestInfo& test_info) override;
+  void OnTestDisabled(const TestInfo& test_info) override;
 
   void OnTestPartResult(const TestPartResult& result) override;
   void OnTestEnd(const TestInfo& test_info) override;
@@ -3384,13 +3377,14 @@ class PrettyUnitTestResultPrinter : public TestEventListener {
   static void PrintSkippedTests(const UnitTest& unit_test);
 };
 
-  // Fired before each iteration of tests starts.
+// Fired before each iteration of tests starts.
 void PrettyUnitTestResultPrinter::OnTestIterationStart(
     const UnitTest& unit_test, int iteration) {
-  if (GTEST_FLAG(repeat) != 1)
+  if (GTEST_FLAG_GET(repeat) != 1)
     printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
 
-  const char* const filter = GTEST_FLAG(filter).c_str();
+  std::string f = GTEST_FLAG_GET(filter);
+  const char* const filter = f.c_str();
 
   // Prints the filter if it's not *.  This reminds the user that some
   // tests may be skipped.
@@ -3406,7 +3400,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationStart(
                   internal::posix::GetEnv(kTestTotalShards));
   }
 
-  if (GTEST_FLAG(shuffle)) {
+  if (GTEST_FLAG_GET(shuffle)) {
     ColoredPrintf(GTestColor::kYellow,
                   "Note: Randomizing tests' orders with a seed of %d .\n",
                   unit_test.random_seed());
@@ -3462,6 +3456,13 @@ void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
   fflush(stdout);
 }
 
+void PrettyUnitTestResultPrinter::OnTestDisabled(const TestInfo& test_info) {
+  ColoredPrintf(GTestColor::kYellow, "[ DISABLED ] ");
+  PrintTestName(test_info.test_suite_name(), test_info.name());
+  printf("\n");
+  fflush(stdout);
+}
+
 // Called after an assertion failure.
 void PrettyUnitTestResultPrinter::OnTestPartResult(
     const TestPartResult& result) {
@@ -3486,12 +3487,12 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
     ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
   }
   PrintTestName(test_info.test_suite_name(), test_info.name());
-  if (test_info.result()->Failed())
-    PrintFullTestCommentIfPresent(test_info);
+  if (test_info.result()->Failed()) PrintFullTestCommentIfPresent(test_info);
 
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms)\n", internal::StreamableToString(
-           test_info.result()->elapsed_time()).c_str());
+  if (GTEST_FLAG_GET(print_time)) {
+    printf(" (%s ms)\n",
+           internal::StreamableToString(test_info.result()->elapsed_time())
+               .c_str());
   } else {
     printf("\n");
   }
@@ -3500,7 +3501,7 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
 
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
-  if (!GTEST_FLAG(print_time)) return;
+  if (!GTEST_FLAG_GET(print_time)) return;
 
   const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
@@ -3511,7 +3512,7 @@ void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
 }
 #else
 void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
-  if (!GTEST_FLAG(print_time)) return;
+  if (!GTEST_FLAG_GET(print_time)) return;
 
   const std::string counts =
       FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
@@ -3607,7 +3608,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   printf("%s from %s ran.",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
          FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
-  if (GTEST_FLAG(print_time)) {
+  if (GTEST_FLAG_GET(print_time)) {
     printf(" (%s ms total)",
            internal::StreamableToString(unit_test.elapsed_time()).c_str());
   }
@@ -3628,7 +3629,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   }
 
   int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+  if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {
     if (unit_test.Passed()) {
       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
     }
@@ -3664,6 +3665,7 @@ class BriefUnitTestResultPrinter : public TestEventListener {
 #endif  // OnTestCaseStart
 
   void OnTestStart(const TestInfo& /*test_info*/) override {}
+  void OnTestDisabled(const TestInfo& /*test_info*/) override {}
 
   void OnTestPartResult(const TestPartResult& result) override;
   void OnTestEnd(const TestInfo& test_info) override;
@@ -3700,7 +3702,7 @@ void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
     PrintTestName(test_info.test_suite_name(), test_info.name());
     PrintFullTestCommentIfPresent(test_info);
 
-    if (GTEST_FLAG(print_time)) {
+    if (GTEST_FLAG_GET(print_time)) {
       printf(" (%s ms)\n",
              internal::StreamableToString(test_info.result()->elapsed_time())
                  .c_str());
@@ -3717,7 +3719,7 @@ void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   printf("%s from %s ran.",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
          FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
-  if (GTEST_FLAG(print_time)) {
+  if (GTEST_FLAG_GET(print_time)) {
     printf(" (%s ms total)",
            internal::StreamableToString(unit_test.elapsed_time()).c_str());
   }
@@ -3732,7 +3734,7 @@ void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   }
 
   int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+  if (num_disabled && !GTEST_FLAG_GET(also_run_disabled_tests)) {
     if (unit_test.Passed()) {
       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
     }
@@ -3752,7 +3754,7 @@ class TestEventRepeater : public TestEventListener {
  public:
   TestEventRepeater() : forwarding_enabled_(true) {}
   ~TestEventRepeater() override;
-  void Append(TestEventListener *listener);
+  void Append(TestEventListener* listener);
   TestEventListener* Release(TestEventListener* listener);
 
   // Controls whether events will be forwarded to listeners_. Set to false
@@ -3770,6 +3772,7 @@ class TestEventRepeater : public TestEventListener {
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   void OnTestSuiteStart(const TestSuite& parameter) override;
   void OnTestStart(const TestInfo& test_info) override;
+  void OnTestDisabled(const TestInfo& test_info) override;
   void OnTestPartResult(const TestPartResult& result) override;
   void OnTestEnd(const TestInfo& test_info) override;
 //  Legacy API is deprecated but still available
@@ -3789,18 +3792,19 @@ class TestEventRepeater : public TestEventListener {
   // The list of listeners that receive events.
   std::vector<TestEventListener*> listeners_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
+  TestEventRepeater(const TestEventRepeater&) = delete;
+  TestEventRepeater& operator=(const TestEventRepeater&) = delete;
 };
 
 TestEventRepeater::~TestEventRepeater() {
   ForEach(listeners_, Delete<TestEventListener>);
 }
 
-void TestEventRepeater::Append(TestEventListener *listener) {
+void TestEventRepeater::Append(TestEventListener* listener) {
   listeners_.push_back(listener);
 }
 
-TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
+TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
   for (size_t i = 0; i < listeners_.size(); ++i) {
     if (listeners_[i] == listener) {
       listeners_.erase(listeners_.begin() + static_cast<int>(i));
@@ -3813,14 +3817,14 @@ TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
 
 // Since most methods are very similar, use macros to reduce boilerplate.
 // This defines a member that forwards the call to all listeners.
-#define GTEST_REPEATER_METHOD_(Name, Type) \
-void TestEventRepeater::Name(const Type& parameter) { \
-  if (forwarding_enabled_) { \
-    for (size_t i = 0; i < listeners_.size(); i++) { \
-      listeners_[i]->Name(parameter); \
-    } \
-  } \
-}
+#define GTEST_REPEATER_METHOD_(Name, Type)              \
+  void TestEventRepeater::Name(const Type& parameter) { \
+    if (forwarding_enabled_) {                          \
+      for (size_t i = 0; i < listeners_.size(); i++) {  \
+        listeners_[i]->Name(parameter);                 \
+      }                                                 \
+    }                                                   \
+  }
 // This defines a member that forwards the call to all listeners in reverse
 // order.
 #define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \
@@ -3840,6 +3844,7 @@ GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
 GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
+GTEST_REPEATER_METHOD_(OnTestDisabled, TestInfo)
 GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
 GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
@@ -3875,6 +3880,7 @@ void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
 
 // End TestEventRepeater
 
+#if GTEST_HAS_FILE_SYSTEM
 // This class generates an XML output file.
 class XmlUnitTestResultPrinter : public EmptyTestEventListener {
  public:
@@ -3890,12 +3896,13 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
  private:
   // Is c a whitespace character that is normalized to a space character
   // when it appears in an XML attribute value?
-  static bool IsNormalizableWhitespace(char c) {
-    return c == 0x9 || c == 0xA || c == 0xD;
+  static bool IsNormalizableWhitespace(unsigned char c) {
+    return c == '\t' || c == '\n' || c == '\r';
   }
 
   // May c appear in a well-formed XML document?
-  static bool IsValidXmlCharacter(char c) {
+  // https://www.w3.org/TR/REC-xml/#charsets
+  static bool IsValidXmlCharacter(unsigned char c) {
     return IsNormalizableWhitespace(c) || c >= 0x20;
   }
 
@@ -3965,7 +3972,8 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
   // The output file.
   const std::string output_file_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
+  XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
+  XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter&) = delete;
 };
 
 // Creates a new XmlUnitTestResultPrinter.
@@ -3984,8 +3992,6 @@ void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   PrintXmlUnitTest(&stream, unit_test);
   fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
   fclose(xmlout);
-  // add a print tag for xml output finished
-  printf("Gtest xml output finished\n");
 }
 
 void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
@@ -4007,8 +4013,8 @@ void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
 // module will consist of ordinary English text.
 // If this module is ever modified to produce version 1.1 XML output,
 // most invalid characters can be retained using character references.
-std::string XmlUnitTestResultPrinter::EscapeXml(
-    const std::string& str, bool is_attribute) {
+std::string XmlUnitTestResultPrinter::EscapeXml(const std::string& str,
+                                                bool is_attribute) {
   Message m;
 
   for (size_t i = 0; i < str.size(); ++i) {
@@ -4036,8 +4042,9 @@ std::string XmlUnitTestResultPrinter::EscapeXml(
           m << '"';
         break;
       default:
-        if (IsValidXmlCharacter(ch)) {
-          if (is_attribute && IsNormalizableWhitespace(ch))
+        if (IsValidXmlCharacter(static_cast<unsigned char>(ch))) {
+          if (is_attribute &&
+              IsNormalizableWhitespace(static_cast<unsigned char>(ch)))
             m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
               << ";";
           else
@@ -4058,7 +4065,7 @@ std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
   std::string output;
   output.reserve(str.size());
   for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-    if (IsValidXmlCharacter(*it))
+    if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))
       output.push_back(*it);
 
   return output;
@@ -4066,7 +4073,6 @@ std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
 
 // The following routines generate an XML representation of a UnitTest
 // object.
-// GOOGLETEST_CM0009 DO NOT DELETE
 //
 // This is how Google Test concepts map to the DTD:
 //
@@ -4115,12 +4121,12 @@ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
     return "";
   // YYYY-MM-DDThh:mm:ss.sss
   return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec) + "." +
-      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
+         String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+         String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+         String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+         String::FormatIntWidth2(time_struct.tm_min) + ":" +
+         String::FormatIntWidth2(time_struct.tm_sec) + "." +
+         String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
 }
 
 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
@@ -4131,8 +4137,8 @@ void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
   for (;;) {
     const char* const next_segment = strstr(segment, "]]>");
     if (next_segment != nullptr) {
-      stream->write(
-          segment, static_cast<std::streamsize>(next_segment - segment));
+      stream->write(segment,
+                    static_cast<std::streamsize>(next_segment - segment));
       *stream << "]]>]]&gt;<![CDATA[";
       segment = next_segment + strlen("]]>");
     } else {
@@ -4144,15 +4150,13 @@ void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
 }
 
 void XmlUnitTestResultPrinter::OutputXmlAttribute(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value) {
+    std::ostream* stream, const std::string& element_name,
+    const std::string& name, const std::string& value) {
   const std::vector<std::string>& allowed_names =
       GetReservedOutputAttributesForElement(element_name);
 
   GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
+               allowed_names.end())
       << "Attribute " << name << " is not allowed for element <" << element_name
       << ">.";
 
@@ -4218,10 +4222,11 @@ void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
     OutputXmlAttribute(stream, kTestsuite, "type_param",
                        test_info.type_param());
   }
-  if (GTEST_FLAG(list_tests)) {
-    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
-    OutputXmlAttribute(stream, kTestsuite, "line",
-                       StreamableToString(test_info.line()));
+
+  OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
+  OutputXmlAttribute(stream, kTestsuite, "line",
+                     StreamableToString(test_info.line()));
+  if (GTEST_FLAG_GET(list_tests)) {
     *stream << " />\n";
     return;
   }
@@ -4259,8 +4264,7 @@ void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
           internal::FormatCompilerIndependentFileLocation(part.file_name(),
                                                           part.line_number());
       const std::string summary = location + "\n" + part.summary();
-      *stream << "      <failure message=\""
-              << EscapeXmlAttribute(summary)
+      *stream << "      <failure message=\"" << EscapeXmlAttribute(summary)
               << "\" type=\"\">";
       const std::string detail = location + "\n" + part.message();
       OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
@@ -4300,7 +4304,7 @@ void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
   OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
   OutputXmlAttribute(stream, kTestsuite, "tests",
                      StreamableToString(test_suite.reportable_test_count()));
-  if (!GTEST_FLAG(list_tests)) {
+  if (!GTEST_FLAG_GET(list_tests)) {
     OutputXmlAttribute(stream, kTestsuite, "failures",
                        StreamableToString(test_suite.failed_test_count()));
     OutputXmlAttribute(
@@ -4348,7 +4352,7 @@ void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
       stream, kTestsuites, "timestamp",
       FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
 
-  if (GTEST_FLAG(shuffle)) {
+  if (GTEST_FLAG_GET(shuffle)) {
     OutputXmlAttribute(stream, kTestsuites, "random_seed",
                        StreamableToString(unit_test.random_seed()));
   }
@@ -4401,7 +4405,7 @@ std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
   for (int i = 0; i < result.test_property_count(); ++i) {
     const TestProperty& property = result.GetTestProperty(i);
     attributes << " " << property.key() << "="
-        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
+               << "\"" << EscapeXmlAttribute(property.value()) << "\"";
   }
   return attributes.GetString();
 }
@@ -4415,19 +4419,21 @@ void XmlUnitTestResultPrinter::OutputXmlTestProperties(
     return;
   }
 
-  *stream << "<" << kProperties << ">\n";
+  *stream << "      <" << kProperties << ">\n";
   for (int i = 0; i < result.test_property_count(); ++i) {
     const TestProperty& property = result.GetTestProperty(i);
-    *stream << "<" << kProperty;
+    *stream << "        <" << kProperty;
     *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
     *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
     *stream << "/>\n";
   }
-  *stream << "</" << kProperties << ">\n";
+  *stream << "      </" << kProperties << ">\n";
 }
 
 // End XmlUnitTestResultPrinter
+#endif  // GTEST_HAS_FILE_SYSTEM
 
+#if GTEST_HAS_FILE_SYSTEM
 // This class generates an JSON output file.
 class JsonUnitTestResultPrinter : public EmptyTestEventListener {
  public:
@@ -4447,16 +4453,12 @@ class JsonUnitTestResultPrinter : public EmptyTestEventListener {
   //// streams the attribute as JSON.
   static void OutputJsonKey(std::ostream* stream,
                             const std::string& element_name,
-                            const std::string& name,
-                            const std::string& value,
-                            const std::string& indent,
-                            bool comma = true);
+                            const std::string& name, const std::string& value,
+                            const std::string& indent, bool comma = true);
   static void OutputJsonKey(std::ostream* stream,
                             const std::string& element_name,
-                            const std::string& name,
-                            int value,
-                            const std::string& indent,
-                            bool comma = true);
+                            const std::string& name, int value,
+                            const std::string& indent, bool comma = true);
 
   // Streams a test suite JSON stanza containing the given test result.
   //
@@ -4489,7 +4491,9 @@ class JsonUnitTestResultPrinter : public EmptyTestEventListener {
   // The output file.
   const std::string output_file_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
+  JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
+  JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrinter&) =
+      delete;
 };
 
 // Creates a new JsonUnitTestResultPrinter.
@@ -4501,7 +4505,7 @@ JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
 }
 
 void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
+                                                   int /*iteration*/) {
   FILE* jsonout = OpenFileForWriting(output_file_);
   std::stringstream stream;
   PrintJsonUnitTest(&stream, unit_test);
@@ -4567,55 +4571,48 @@ static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
     return "";
   // YYYY-MM-DDThh:mm:ss
   return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
+         String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+         String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+         String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+         String::FormatIntWidth2(time_struct.tm_min) + ":" +
+         String::FormatIntWidth2(time_struct.tm_sec) + "Z";
 }
 
 static inline std::string Indent(size_t width) {
   return std::string(width, ' ');
 }
 
-void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value,
-    const std::string& indent,
-    bool comma) {
+void JsonUnitTestResultPrinter::OutputJsonKey(std::ostream* stream,
+                                              const std::string& element_name,
+                                              const std::string& name,
+                                              const std::string& value,
+                                              const std::string& indent,
+                                              bool comma) {
   const std::vector<std::string>& allowed_names =
       GetReservedOutputAttributesForElement(element_name);
 
   GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
+               allowed_names.end())
       << "Key \"" << name << "\" is not allowed for value \"" << element_name
       << "\".";
 
   *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
-  if (comma)
-    *stream << ",\n";
+  if (comma) *stream << ",\n";
 }
 
 void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    int value,
-    const std::string& indent,
-    bool comma) {
+    std::ostream* stream, const std::string& element_name,
+    const std::string& name, int value, const std::string& indent, bool comma) {
   const std::vector<std::string>& allowed_names =
       GetReservedOutputAttributesForElement(element_name);
 
   GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
+               allowed_names.end())
       << "Key \"" << name << "\" is not allowed for value \"" << element_name
       << "\".";
 
   *stream << indent << "\"" << name << "\": " << StreamableToString(value);
-  if (comma)
-    *stream << ",\n";
+  if (comma) *stream << ",\n";
 }
 
 // Streams a test suite JSON stanza containing the given test result.
@@ -4625,7 +4622,7 @@ void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
   *stream << Indent(4) << "{\n";
   OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
   OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
-  if (!GTEST_FLAG(list_tests)) {
+  if (!GTEST_FLAG_GET(list_tests)) {
     OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
     OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
     OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
@@ -4679,11 +4676,14 @@ void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
     OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
                   kIndent);
   }
-  if (GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
+
+  OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
+  OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
+  if (GTEST_FLAG_GET(list_tests)) {
     *stream << "\n" << Indent(8) << "}";
     return;
+  } else {
+    *stream << ",\n";
   }
 
   OutputJsonKey(stream, kTestsuite, "status",
@@ -4715,7 +4715,9 @@ void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
     if (part.failed()) {
       *stream << ",\n";
       if (++failures == 1) {
-        *stream << kIndent << "\"" << "failures" << "\": [\n";
+        *stream << kIndent << "\""
+                << "failures"
+                << "\": [\n";
       }
       const std::string location =
           internal::FormatCompilerIndependentFileLocation(part.file_name(),
@@ -4728,8 +4730,7 @@ void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
     }
   }
 
-  if (failures > 0)
-    *stream << "\n" << kIndent << "]";
+  if (failures > 0) *stream << "\n" << kIndent << "]";
   *stream << "\n" << Indent(8) << "}";
 }
 
@@ -4743,7 +4744,7 @@ void JsonUnitTestResultPrinter::PrintJsonTestSuite(
   OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
   OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
                 kIndent);
-  if (!GTEST_FLAG(list_tests)) {
+  if (!GTEST_FLAG_GET(list_tests)) {
     OutputJsonKey(stream, kTestsuite, "failures",
                   test_suite.failed_test_count(), kIndent);
     OutputJsonKey(stream, kTestsuite, "disabled",
@@ -4790,7 +4791,7 @@ void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
   OutputJsonKey(stream, kTestsuites, "disabled",
                 unit_test.reportable_disabled_test_count(), kIndent);
   OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
-  if (GTEST_FLAG(shuffle)) {
+  if (GTEST_FLAG_GET(shuffle)) {
     OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
                   kIndent);
   }
@@ -4822,10 +4823,15 @@ void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
   // If there was a test failure outside of one of the test suites (like in a
   // test environment) include that in the output.
   if (unit_test.ad_hoc_test_result().Failed()) {
+    if (comma) {
+      *stream << ",\n";
+    }
     OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
   }
 
-  *stream << "\n" << kIndent << "]\n" << "}\n";
+  *stream << "\n"
+          << kIndent << "]\n"
+          << "}\n";
 }
 
 void JsonUnitTestResultPrinter::PrintJsonTestList(
@@ -4860,13 +4866,15 @@ std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
   Message attributes;
   for (int i = 0; i < result.test_property_count(); ++i) {
     const TestProperty& property = result.GetTestProperty(i);
-    attributes << ",\n" << indent << "\"" << property.key() << "\": "
+    attributes << ",\n"
+               << indent << "\"" << property.key() << "\": "
                << "\"" << EscapeJson(property.value()) << "\"";
   }
   return attributes.GetString();
 }
 
 // End JsonUnitTestResultPrinter
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 #if GTEST_CAN_STREAM_RESULTS_
 
@@ -4884,7 +4892,8 @@ std::string StreamingListener::UrlEncode(const char* str) {
       case '=':
       case '&':
       case '\n':
-        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
+        result.push_back('%');
+        result.append(String::FormatByte(static_cast<unsigned char>(ch)));
         break;
       default:
         result.push_back(ch);
@@ -4900,14 +4909,14 @@ void StreamingListener::SocketWriter::MakeConnection() {
 
   addrinfo hints;
   memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
+  hints.ai_family = AF_UNSPEC;  // To allow both IPv4 and IPv6 addresses.
   hints.ai_socktype = SOCK_STREAM;
   addrinfo* servinfo = nullptr;
 
   // Use the getaddrinfo() to get a linked list of IP addresses for
   // the given host name.
-  const int error_num = getaddrinfo(
-      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
+  const int error_num =
+      getaddrinfo(host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
   if (error_num != 0) {
     GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
                         << gai_strerror(error_num);
@@ -4916,8 +4925,8 @@ void StreamingListener::SocketWriter::MakeConnection() {
   // Loop through all the results and connect to the first we can.
   for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
        cur_addr = cur_addr->ai_next) {
-    sockfd_ = socket(
-        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
+    sockfd_ = socket(cur_addr->ai_family, cur_addr->ai_socktype,
+                     cur_addr->ai_protocol);
     if (sockfd_ != -1) {
       // Connect the client socket to the server socket.
       if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
@@ -4967,7 +4976,7 @@ std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
 
   for (int i = 0; i < raw_stack_size; ++i) {
     if (raw_stack[i] == caller_frame &&
-        !GTEST_FLAG(show_internal_stack_frames)) {
+        !GTEST_FLAG_GET(show_internal_stack_frames)) {
       // Add a marker to the trace and stop adding frames.
       absl::StrAppend(&result, kElidedFramesMarker, "\n");
       break;
@@ -4986,7 +4995,7 @@ std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
 
   return result;
 
-#else  // !GTEST_HAS_ABSL
+#else   // !GTEST_HAS_ABSL
   static_cast<void>(max_depth);
   static_cast<void>(skip_count);
   return "";
@@ -5005,26 +5014,27 @@ void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 #endif  // GTEST_HAS_ABSL
 }
 
+#if GTEST_HAS_DEATH_TEST
 // A helper class that creates the premature-exit file in its
 // constructor and deletes the file in its destructor.
 class ScopedPrematureExitFile {
  public:
   explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
-      : premature_exit_filepath_(premature_exit_filepath ?
-                                 premature_exit_filepath : "") {
+      : premature_exit_filepath_(
+            premature_exit_filepath ? premature_exit_filepath : "") {
     // If a path to the premature-exit file is specified...
     if (!premature_exit_filepath_.empty()) {
       // create the file with a single "0" character in it.  I/O
       // errors are ignored as there's nothing better we can do and we
       // don't want to fail the test because of this.
-      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");
       fwrite("0", 1, 1, pfile);
       fclose(pfile);
     }
   }
 
   ~ScopedPrematureExitFile() {
-#if !defined GTEST_OS_ESP8266
+#if !GTEST_OS_ESP8266
     if (!premature_exit_filepath_.empty()) {
       int retval = remove(premature_exit_filepath_.c_str());
       if (retval) {
@@ -5039,8 +5049,10 @@ class ScopedPrematureExitFile {
  private:
   const std::string premature_exit_filepath_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+  ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
+  ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&) = delete;
 };
+#endif  // GTEST_HAS_DEATH_TEST
 
 }  // namespace internal
 
@@ -5213,7 +5225,7 @@ int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
 // Gets the time of the test program start, in ms from the start of the
 // UNIX epoch.
 internal::TimeInMillis UnitTest::start_timestamp() const {
-    return impl()->start_timestamp();
+  return impl()->start_timestamp();
 }
 
 // Gets the elapsed time, in milliseconds.
@@ -5256,9 +5268,7 @@ TestSuite* UnitTest::GetMutableTestSuite(int i) {
 
 // Returns the list of event listeners that can be used to track events
 // inside Google Test.
-TestEventListeners& UnitTest::listeners() {
-  return *impl()->listeners();
-}
+TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
 
 // Registers and returns a global test environment.  When a test
 // program is run, all global test environments will be set-up in the
@@ -5283,12 +5293,11 @@ Environment* UnitTest::AddEnvironment(Environment* env) {
 // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
 // this to report their results.  The user code should use the
 // assertion macros instead of calling this directly.
-void UnitTest::AddTestPartResult(
-    TestPartResult::Type result_type,
-    const char* file_name,
-    int line_number,
-    const std::string& message,
-    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
+void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
+                                 const char* file_name, int line_number,
+                                 const std::string& message,
+                                 const std::string& os_stack_trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
   Message msg;
   msg << message;
 
@@ -5298,8 +5307,9 @@ void UnitTest::AddTestPartResult(
 
     for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
       const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
-      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
-          << " " << trace.message;
+      msg << "\n"
+          << internal::FormatFileLocation(trace.file, trace.line) << " "
+          << trace.message;
     }
   }
 
@@ -5309,8 +5319,8 @@ void UnitTest::AddTestPartResult(
 
   const TestPartResult result = TestPartResult(
       result_type, file_name, line_number, msg.GetString().c_str());
-  impl_->GetTestPartResultReporterForCurrentThread()->
-      ReportTestPartResult(result);
+  impl_->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
+      result);
 
   if (result_type != TestPartResult::kSuccess &&
       result_type != TestPartResult::kSkip) {
@@ -5319,7 +5329,7 @@ void UnitTest::AddTestPartResult(
     // in the code (perhaps in order to use Google Test assertions
     // with another testing framework) and specify the former on the
     // command line for debugging.
-    if (GTEST_FLAG(break_on_failure)) {
+    if (GTEST_FLAG_GET(break_on_failure)) {
 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
       // Using DebugBreak on Windows allows gtest to still break into a debugger
       // when a failure happens and both the --gtest_break_on_failure and
@@ -5330,13 +5340,17 @@ void UnitTest::AddTestPartResult(
      (defined(__x86_64__) || defined(__i386__)))
       // with clang/gcc we can achieve the same effect on x86 by invoking int3
       asm("int3");
+#elif GTEST_HAS_BUILTIN(__builtin_trap)
+      __builtin_trap();
+#elif defined(SIGTRAP)
+      raise(SIGTRAP);
 #else
       // Dereference nullptr through a volatile pointer to prevent the compiler
       // from removing. We use this rather than abort() or __builtin_trap() for
       // portability: some debuggers don't correctly trap abort().
       *static_cast<volatile int*>(nullptr) = 1;
 #endif  // GTEST_OS_WINDOWS
-    } else if (GTEST_FLAG(throw_on_failure)) {
+    } else if (GTEST_FLAG_GET(throw_on_failure)) {
 #if GTEST_HAS_EXCEPTIONS
       throw internal::GoogleTestFailureException(result);
 #else
@@ -5364,8 +5378,9 @@ void UnitTest::RecordProperty(const std::string& key,
 // We don't protect this under mutex_, as we only support calling it
 // from the main thread.
 int UnitTest::Run() {
+#if GTEST_HAS_DEATH_TEST
   const bool in_death_test_child_process =
-      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+      GTEST_FLAG_GET(internal_run_death_test).length() > 0;
 
   // Google Test implements this protocol for catching that a test
   // program exits before returning control to Google Test:
@@ -5392,10 +5407,11 @@ int UnitTest::Run() {
       in_death_test_child_process
           ? nullptr
           : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+#endif  // GTEST_HAS_DEATH_TEST
 
   // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
   // used for the duration of the program.
-  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
+  impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
 
 #if GTEST_OS_WINDOWS
   // Either the user wants Google Test to catch exceptions thrown by the
@@ -5403,26 +5419,26 @@ int UnitTest::Run() {
   // process. In either case the user does not want to see pop-up dialogs
   // about crashes - they are expected.
   if (impl()->catch_exceptions() || in_death_test_child_process) {
-# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
     // SetErrorMode doesn't exist on CE.
     SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
                  SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
-# endif  // !GTEST_OS_WINDOWS_MOBILE
+#endif  // !GTEST_OS_WINDOWS_MOBILE
 
-# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
+#if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
     // Death test children can be terminated with _abort().  On Windows,
     // _abort() can show a dialog with a warning message.  This forces the
     // abort message to go to stderr instead.
     _set_error_mode(_OUT_TO_STDERR);
-# endif
+#endif
 
-# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
+#if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
     // In the debug version, Visual Studio pops up a separate dialog
     // offering a choice to debug the aborted program. We need to suppress
     // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
     // executed. Google Test will notify the user of any unexpected
     // failure via stderr.
-    if (!GTEST_FLAG(break_on_failure))
+    if (!GTEST_FLAG_GET(break_on_failure))
       _set_abort_behavior(
           0x0,                                    // Clear the following flags:
           _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
@@ -5436,21 +5452,24 @@ int UnitTest::Run() {
                               _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
       (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
     }
-# endif
+#endif
   }
 #endif  // GTEST_OS_WINDOWS
 
   return internal::HandleExceptionsInMethodIfSupported(
-      impl(),
-      &internal::UnitTestImpl::RunAllTests,
-      "auxiliary test code (environments or event listeners)") ? 0 : 1;
+             impl(), &internal::UnitTestImpl::RunAllTests,
+             "auxiliary test code (environments or event listeners)")
+             ? 0
+             : 1;
 }
 
+#if GTEST_HAS_FILE_SYSTEM
 // Returns the working directory when the first TEST() or TEST_F() was
 // executed.
 const char* UnitTest::original_working_dir() const {
   return impl_->original_working_dir_.c_str();
 }
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 // Returns the TestSuite object for the test that's currently running,
 // or NULL if no test is running.
@@ -5488,14 +5507,10 @@ UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
 }
 
 // Creates an empty UnitTest.
-UnitTest::UnitTest() {
-  impl_ = new internal::UnitTestImpl(this);
-}
+UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); }
 
 // Destructor of UnitTest.
-UnitTest::~UnitTest() {
-  delete impl_;
-}
+UnitTest::~UnitTest() { delete impl_; }
 
 // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
 // Google Test trace stack.
@@ -5506,8 +5521,7 @@ void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
 }
 
 // Pops a trace from the per-thread Google Test trace stack.
-void UnitTest::PopGTestTrace()
-    GTEST_LOCK_EXCLUDED_(mutex_) {
+void UnitTest::PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
   impl_->gtest_trace_stack().pop_back();
 }
@@ -5519,7 +5533,7 @@ UnitTestImpl::UnitTestImpl(UnitTest* parent)
       GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
           default_global_test_part_result_reporter_(this),
       default_per_thread_test_part_result_reporter_(this),
-      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
+      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(
           &default_global_test_part_result_reporter_),
       per_thread_test_part_result_reporter_(
           &default_per_thread_test_part_result_reporter_),
@@ -5588,6 +5602,7 @@ void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
 // UnitTestOptions. Must not be called before InitGoogleTest.
 void UnitTestImpl::ConfigureXmlOutput() {
   const std::string& output_format = UnitTestOptions::GetOutputFormat();
+#if GTEST_HAS_FILE_SYSTEM
   if (output_format == "xml") {
     listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
         UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
@@ -5598,18 +5613,22 @@ void UnitTestImpl::ConfigureXmlOutput() {
     GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                         << output_format << "\" ignored.";
   }
+#else
+  GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
+                    << "GTEST_HAS_FILE_SYSTEM to be enabled";
+#endif  // GTEST_HAS_FILE_SYSTEM
 }
 
 #if GTEST_CAN_STREAM_RESULTS_
 // Initializes event listeners for streaming test results in string form.
 // Must not be called before InitGoogleTest.
 void UnitTestImpl::ConfigureStreamingOutput() {
-  const std::string& target = GTEST_FLAG(stream_result_to);
+  const std::string& target = GTEST_FLAG_GET(stream_result_to);
   if (!target.empty()) {
     const size_t pos = target.find(':');
     if (pos != std::string::npos) {
-      listeners()->Append(new StreamingListener(target.substr(0, pos),
-                                                target.substr(pos+1)));
+      listeners()->Append(
+          new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));
     } else {
       GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
                           << "\" ignored.";
@@ -5647,7 +5666,7 @@ void UnitTestImpl::PostFlagParsingInit() {
     // to shut down the default XML output before invoking RUN_ALL_TESTS.
     ConfigureXmlOutput();
 
-    if (GTEST_FLAG(brief)) {
+    if (GTEST_FLAG_GET(brief)) {
       listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
     }
 
@@ -5657,7 +5676,7 @@ void UnitTestImpl::PostFlagParsingInit() {
 #endif  // GTEST_CAN_STREAM_RESULTS_
 
 #if GTEST_HAS_ABSL
-    if (GTEST_FLAG(install_failure_signal_handler)) {
+    if (GTEST_FLAG_GET(install_failure_signal_handler)) {
       absl::FailureSignalHandlerOptions options;
       absl::InstallFailureSignalHandler(options);
     }
@@ -5715,9 +5734,9 @@ TestSuite* UnitTestImpl::GetTestSuite(
   auto* const new_test_suite =
       new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
 
+  const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
   // Is this a death test suite?
-  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
-                                               kDeathTestSuiteFilter)) {
+  if (death_test_suite_filter.MatchesName(test_suite_name)) {
     // Yes.  Inserts the test suite after the last death test suite
     // defined so far.  This only works when the test suites haven't
     // been shuffled.  Otherwise we may end up running a death test
@@ -5754,17 +5773,18 @@ bool UnitTestImpl::RunAllTests() {
   const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
 
   // Do not run any test if the --help flag was specified.
-  if (g_help_flag)
-    return true;
+  if (g_help_flag) return true;
 
   // Repeats the call to the post-flag parsing initialization in case the
   // user didn't call InitGoogleTest.
   PostFlagParsingInit();
 
+#if GTEST_HAS_FILE_SYSTEM
   // Even if sharding is not on, test runners may want to use the
   // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
   // protocol.
   internal::WriteToShardStatusFileIfNeeded();
+#endif  // GTEST_HAS_FILE_SYSTEM
 
   // True if and only if we are in a subprocess for running a thread-safe-style
   // death test.
@@ -5773,11 +5793,11 @@ bool UnitTestImpl::RunAllTests() {
 #if GTEST_HAS_DEATH_TEST
   in_subprocess_for_death_test =
       (internal_run_death_test_flag_.get() != nullptr);
-# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
   if (in_subprocess_for_death_test) {
     GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
   }
-# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 #endif  // GTEST_HAS_DEATH_TEST
 
   const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
@@ -5785,19 +5805,18 @@ bool UnitTestImpl::RunAllTests() {
 
   // Compares the full test names with the filter to decide which
   // tests to run.
-  const bool has_tests_to_run = FilterTests(should_shard
-                                              ? HONOR_SHARDING_PROTOCOL
-                                              : IGNORE_SHARDING_PROTOCOL) > 0;
+  const bool has_tests_to_run =
+      FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL
+                               : IGNORE_SHARDING_PROTOCOL) > 0;
 
   // Lists the tests and exits if the --gtest_list_tests flag was specified.
-  if (GTEST_FLAG(list_tests)) {
+  if (GTEST_FLAG_GET(list_tests)) {
     // This must be called *after* FilterTests() has been called.
     ListTestsMatchingFilter();
     return true;
   }
 
-  random_seed_ = GTEST_FLAG(shuffle) ?
-      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
+  random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));
 
   // True if and only if at least one test has failed.
   bool failed = false;
@@ -5809,9 +5828,21 @@ bool UnitTestImpl::RunAllTests() {
 
   // How many times to repeat the tests?  We don't want to repeat them
   // when we are inside the subprocess of a death test.
-  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
+  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);
+
   // Repeats forever if the repeat count is negative.
   const bool gtest_repeat_forever = repeat < 0;
+
+  // Should test environments be set up and torn down for each repeat, or only
+  // set up on the first and torn down on the last iteration? If there is no
+  // "last" iteration because the tests will repeat forever, always recreate the
+  // environments to avoid leaks in case one of the environments is using
+  // resources that are external to this process. Without this check there would
+  // be no way to clean up those external resources automatically.
+  const bool recreate_environments_when_repeating =
+      GTEST_FLAG_GET(recreate_environments_when_repeating) ||
+      gtest_repeat_forever;
+
   for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
     // We want to preserve failures generated by ad-hoc test
     // assertions executed before RUN_ALL_TESTS().
@@ -5820,7 +5851,7 @@ bool UnitTestImpl::RunAllTests() {
     Timer timer;
 
     // Shuffles test suites and tests if requested.
-    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
+    if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {
       random()->Reseed(static_cast<uint32_t>(random_seed_));
       // This should be done before calling OnTestIterationStart(),
       // such that a test event listener can see the actual test order
@@ -5833,10 +5864,13 @@ bool UnitTestImpl::RunAllTests() {
 
     // Runs each test suite if there is at least one test to run.
     if (has_tests_to_run) {
-      // Sets up all environments beforehand.
-      repeater->OnEnvironmentsSetUpStart(*parent_);
-      ForEach(environments_, SetUpEnvironment);
-      repeater->OnEnvironmentsSetUpEnd(*parent_);
+      // Sets up all environments beforehand. If test environments aren't
+      // recreated for each iteration, only do so on the first iteration.
+      if (i == 0 || recreate_environments_when_repeating) {
+        repeater->OnEnvironmentsSetUpStart(*parent_);
+        ForEach(environments_, SetUpEnvironment);
+        repeater->OnEnvironmentsSetUpEnd(*parent_);
+      }
 
       // Runs the tests only if there was no fatal failure or skip triggered
       // during global set-up.
@@ -5858,7 +5892,7 @@ bool UnitTestImpl::RunAllTests() {
         for (int test_index = 0; test_index < total_test_suite_count();
              test_index++) {
           GetMutableSuiteCase(test_index)->Run();
-          if (GTEST_FLAG(fail_fast) &&
+          if (GTEST_FLAG_GET(fail_fast) &&
               GetMutableSuiteCase(test_index)->Failed()) {
             for (int j = test_index + 1; j < total_test_suite_count(); j++) {
               GetMutableSuiteCase(j)->Skip();
@@ -5876,11 +5910,15 @@ bool UnitTestImpl::RunAllTests() {
         }
       }
 
-      // Tears down all environments in reverse order afterwards.
-      repeater->OnEnvironmentsTearDownStart(*parent_);
-      std::for_each(environments_.rbegin(), environments_.rend(),
-                    TearDownEnvironment);
-      repeater->OnEnvironmentsTearDownEnd(*parent_);
+      // Tears down all environments in reverse order afterwards. If test
+      // environments aren't recreated for each iteration, only do so on the
+      // last iteration.
+      if (i == repeat - 1 || recreate_environments_when_repeating) {
+        repeater->OnEnvironmentsTearDownStart(*parent_);
+        std::for_each(environments_.rbegin(), environments_.rend(),
+                      TearDownEnvironment);
+        repeater->OnEnvironmentsTearDownEnd(*parent_);
+      }
     }
 
     elapsed_time_ = timer.Elapsed();
@@ -5901,7 +5939,7 @@ bool UnitTestImpl::RunAllTests() {
     // (it's always safe to unshuffle the tests).
     UnshuffleTests();
 
-    if (GTEST_FLAG(shuffle)) {
+    if (GTEST_FLAG_GET(shuffle)) {
       // Picks a new random seed for each iteration.
       random_seed_ = GetNextRandomSeed(random_seed_);
     }
@@ -5926,6 +5964,7 @@ bool UnitTestImpl::RunAllTests() {
   return !failed;
 }
 
+#if GTEST_HAS_FILE_SYSTEM
 // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
 // if the variable is present. If a file already exists at this location, this
 // function will write over it. If the variable is present, but the file cannot
@@ -5945,6 +5984,7 @@ void WriteToShardStatusFileIfNeeded() {
     fclose(file);
   }
 }
+#endif  // GTEST_HAS_FILE_SYSTEM
 
 // Checks whether sharding is enabled by examining the relevant
 // environment variable values. If the variables are present,
@@ -5952,8 +5992,7 @@ void WriteToShardStatusFileIfNeeded() {
 // an error and exits. If in_subprocess_for_death_test, sharding is
 // disabled because it must only be applied to the original test
 // process. Otherwise, we could filter out death tests we intended to execute.
-bool ShouldShard(const char* total_shards_env,
-                 const char* shard_index_env,
+bool ShouldShard(const char* total_shards_env, const char* shard_index_env,
                  bool in_subprocess_for_death_test) {
   if (in_subprocess_for_death_test) {
     return false;
@@ -5965,27 +6004,27 @@ bool ShouldShard(const char* total_shards_env,
   if (total_shards == -1 && shard_index == -1) {
     return false;
   } else if (total_shards == -1 && shard_index != -1) {
-    const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestShardIndex << " = " << shard_index
-      << ", but have left " << kTestTotalShards << " unset.\n";
+    const Message msg = Message() << "Invalid environment variables: you have "
+                                  << kTestShardIndex << " = " << shard_index
+                                  << ", but have left " << kTestTotalShards
+                                  << " unset.\n";
     ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (total_shards != -1 && shard_index == -1) {
     const Message msg = Message()
-      << "Invalid environment variables: you have "
-      << kTestTotalShards << " = " << total_shards
-      << ", but have left " << kTestShardIndex << " unset.\n";
+                        << "Invalid environment variables: you have "
+                        << kTestTotalShards << " = " << total_shards
+                        << ", but have left " << kTestShardIndex << " unset.\n";
     ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (shard_index < 0 || shard_index >= total_shards) {
-    const Message msg = Message()
-      << "Invalid environment variables: we require 0 <= "
-      << kTestShardIndex << " < " << kTestTotalShards
-      << ", but you have " << kTestShardIndex << "=" << shard_index
-      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
+    const Message msg =
+        Message() << "Invalid environment variables: we require 0 <= "
+                  << kTestShardIndex << " < " << kTestTotalShards
+                  << ", but you have " << kTestShardIndex << "=" << shard_index
+                  << ", " << kTestTotalShards << "=" << total_shards << ".\n";
     ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
@@ -6024,14 +6063,19 @@ bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
 // each TestSuite and TestInfo object.
 // If shard_tests == true, further filters tests based on sharding
 // variables in the environment - see
-// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
+// https://github.com/google/googletest/blob/main/docs/advanced.md
 // . Returns the number of tests that should run.
 int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
-  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
-  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
-      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
-
+  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL
+                                   ? Int32FromEnvOrDie(kTestTotalShards, -1)
+                                   : -1;
+  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL
+                                  ? Int32FromEnvOrDie(kTestShardIndex, -1)
+                                  : -1;
+
+  const PositiveAndNegativeUnitTestFilter gtest_flag_filter(
+      GTEST_FLAG_GET(filter));
+  const UnitTestFilter disable_test_filter(kDisableTestFilter);
   // num_runnable_tests are the number of tests that will
   // run across all shards (i.e., match filter and are not disabled).
   // num_selected_tests are the number of tests to be run on
@@ -6047,18 +6091,17 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
       const std::string test_name(test_info->name());
       // A test is disabled if test suite name or test name matches
       // kDisableTestFilter.
-      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
-                                   test_suite_name, kDisableTestFilter) ||
-                               internal::UnitTestOptions::MatchesFilter(
-                                   test_name, kDisableTestFilter);
+      const bool is_disabled =
+          disable_test_filter.MatchesName(test_suite_name) ||
+          disable_test_filter.MatchesName(test_name);
       test_info->is_disabled_ = is_disabled;
 
-      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
-          test_suite_name, test_name);
+      const bool matches_filter =
+          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
       test_info->matches_filter_ = matches_filter;
 
       const bool is_runnable =
-          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
+          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
           matches_filter &&
           testing::ext::TestFilter::instance()->accept(testing::ext::TestDefManager::cinstance()->queryFlagsFor(test_info, testing::ext::TestFlag::None))
           ;
@@ -6135,6 +6178,7 @@ void UnitTestImpl::ListTestsMatchingFilter() {
     }
   }
   fflush(stdout);
+  #if GTEST_HAS_FILE_SYSTEM
   const std::string& output_format = UnitTestOptions::GetOutputFormat();
   if (output_format == "xml" || output_format == "json") {
     FILE* fileout = OpenFileForWriting(
@@ -6152,6 +6196,7 @@ void UnitTestImpl::ListTestsMatchingFilter() {
     fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
     fclose(fileout);
   }
+#endif  // GTEST_HAS_FILE_SYSTEM
 }
 
 // Sets the OS stack trace getter.
@@ -6229,8 +6274,8 @@ void UnitTestImpl::UnshuffleTests() {
 // For example, if Foo() calls Bar(), which in turn calls
 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
-std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
-                                            int skip_count) {
+GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string
+GetCurrentOsStackTraceExceptTop(int skip_count) {
   // We pass skip_count + 1 to skip this wrapper function in addition
   // to what the user really wants to skip.
   return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
@@ -6240,7 +6285,7 @@ std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
 // suppress unreachable code warnings.
 namespace {
 class ClassUniqueToAlwaysTrue {};
-}
+}  // namespace
 
 bool IsTrue(bool condition) { return condition; }
 
@@ -6248,8 +6293,7 @@ bool AlwaysTrue() {
 #if GTEST_HAS_EXCEPTIONS
   // This condition is always false so AlwaysTrue() never actually throws,
   // but it makes the compiler think that it may throw.
-  if (IsTrue(false))
-    throw ClassUniqueToAlwaysTrue();
+  if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
 #endif  // GTEST_HAS_EXCEPTIONS
   return true;
 }
@@ -6271,13 +6315,14 @@ bool SkipPrefix(const char* prefix, const char** pstr) {
 // part can be omitted.
 //
 // Returns the value of the flag, or NULL if the parsing failed.
-static const char* ParseFlagValue(const char* str, const char* flag,
+static const char* ParseFlagValue(const char* str, const char* flag_name,
                                   bool def_optional) {
   // str and flag must not be NULL.
-  if (str == nullptr || flag == nullptr) return nullptr;
+  if (str == nullptr || flag_name == nullptr) return nullptr;
 
   // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
-  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
+  const std::string flag_str =
+      std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
   const size_t flag_len = flag_str.length();
   if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
 
@@ -6308,9 +6353,9 @@ static const char* ParseFlagValue(const char* str, const char* flag,
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, true);
+  const char* const value_str = ParseFlagValue(str, flag_name, true);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
@@ -6324,16 +6369,16 @@ static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
+bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
+  const char* const value_str = ParseFlagValue(str, flag_name, false);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
 
   // Sets *value to the value of the flag.
-  return ParseInt32(Message() << "The value of flag --" << flag,
-                    value_str, value);
+  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
+                    value);
 }
 
 // Parses a string for a string flag, in the form of "--flag=value".
@@ -6341,9 +6386,9 @@ bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
 template <typename String>
-static bool ParseStringFlag(const char* str, const char* flag, String* value) {
+static bool ParseFlag(const char* str, const char* flag_name, String* value) {
   // Gets the value of the flag as a string.
-  const char* const value_str = ParseFlagValue(str, flag, false);
+  const char* const value_str = ParseFlagValue(str, flag_name, false);
 
   // Aborts if the parsing failed.
   if (value_str == nullptr) return false;
@@ -6360,8 +6405,7 @@ static bool ParseStringFlag(const char* str, const char* flag, String* value) {
 // GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
 // internal flags and do not trigger the help message.
 static bool HasGoogleTestFlagPrefix(const char* str) {
-  return (SkipPrefix("--", &str) ||
-          SkipPrefix("-", &str) ||
+  return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||
           SkipPrefix("/", &str)) &&
          !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
          (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
@@ -6415,7 +6459,7 @@ static bool ParseFilterFlag(const char* arg) {
   const std::map<const char*, string*> kvs = testing::ext::TestFilter::instance()->getAllFilterFlagsKv();
   std::map<const char*, string*>::const_iterator c_iter;
   for (c_iter = kvs.begin(); c_iter != kvs.end(); c_iter++) {
-    if (ParseStringFlag(arg, c_iter->first, c_iter->second)) {
+    if (ParseFlag(arg, c_iter->first, c_iter->second)) {
       return true;
     }
   }
@@ -6455,6 +6499,10 @@ static const char kColorEncodedHelpMessage[] =
     "random_seed=@Y[NUMBER]@D\n"
     "      Random number seed to use for shuffling test orders (between 1 and\n"
     "      99999, or 0 to use a seed based on the current time).\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "recreate_environments_when_repeating@D\n"
+    "      Sets up and tears down the global test environment on each repeat\n"
+    "      of the test.\n"
     "\n"
     "Test Output:\n"
     "  @G--" GTEST_FLAG_PREFIX_
@@ -6472,18 +6520,18 @@ static const char kColorEncodedHelpMessage[] =
     "      Generate a JSON or XML report in the given directory or with the "
     "given\n"
     "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
-# if GTEST_CAN_STREAM_RESULTS_
+#if GTEST_CAN_STREAM_RESULTS_
     "  @G--" GTEST_FLAG_PREFIX_
     "stream_result_to=@YHOST@G:@YPORT@D\n"
     "      Stream test results to the given server.\n"
-# endif  // GTEST_CAN_STREAM_RESULTS_
+#endif  // GTEST_CAN_STREAM_RESULTS_
     "\n"
     "Assertion Behavior:\n"
-# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
     "  @G--" GTEST_FLAG_PREFIX_
     "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
     "      Set the default death test style.\n"
-# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+#endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
     "  @G--" GTEST_FLAG_PREFIX_
     "break_on_failure@D\n"
     "      Turn assertion failures into debugger break-points.\n"
@@ -6515,43 +6563,45 @@ static const char kColorEncodedHelpMessage[] =
     "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
 
 static bool ParseGoogleTestFlag(const char* const arg) {
-  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
-                       &GTEST_FLAG(also_run_disabled_tests)) ||
-         ParseBoolFlag(arg, kBreakOnFailureFlag,
-                       &GTEST_FLAG(break_on_failure)) ||
-         ParseBoolFlag(arg, kCatchExceptionsFlag,
-                       &GTEST_FLAG(catch_exceptions)) ||
-         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
-         ParseStringFlag(arg, kDeathTestStyleFlag,
-                         &GTEST_FLAG(death_test_style)) ||
-         ParseBoolFlag(arg, kDeathTestUseFork,
-                       &GTEST_FLAG(death_test_use_fork)) ||
-         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
-         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
-         ParseStringFlag(arg, kInternalRunDeathTestFlag,
-                         &GTEST_FLAG(internal_run_death_test)) ||
-         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
-         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
-         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
-         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
-         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
-         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
-         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
-         ParseInt32Flag(arg, kStackTraceDepthFlag,
-                        &GTEST_FLAG(stack_trace_depth)) ||
-         ParseStringFlag(arg, kStreamResultToFlag,
-                         &GTEST_FLAG(stream_result_to)) ||
-         ParseBoolFlag(arg, kThrowOnFailureFlag,
-                         &GTEST_FLAG(throw_on_failure)) ||
-                             ParseFilterFlag(arg);
-}
-
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
+#define GTEST_INTERNAL_PARSE_FLAG(flag_name)  \
+  do {                                        \
+    auto value = GTEST_FLAG_GET(flag_name);   \
+    if (ParseFlag(arg, #flag_name, &value)) { \
+      GTEST_FLAG_SET(flag_name, value);       \
+      return true;                            \
+    }                                         \
+  } while (false)
+
+  GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests);
+  GTEST_INTERNAL_PARSE_FLAG(break_on_failure);
+  GTEST_INTERNAL_PARSE_FLAG(catch_exceptions);
+  GTEST_INTERNAL_PARSE_FLAG(color);
+  GTEST_INTERNAL_PARSE_FLAG(death_test_style);
+  GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);
+  GTEST_INTERNAL_PARSE_FLAG(fail_fast);
+  GTEST_INTERNAL_PARSE_FLAG(filter);
+  GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);
+  GTEST_INTERNAL_PARSE_FLAG(list_tests);
+  GTEST_INTERNAL_PARSE_FLAG(output);
+  GTEST_INTERNAL_PARSE_FLAG(brief);
+  GTEST_INTERNAL_PARSE_FLAG(print_time);
+  GTEST_INTERNAL_PARSE_FLAG(print_utf8);
+  GTEST_INTERNAL_PARSE_FLAG(random_seed);
+  GTEST_INTERNAL_PARSE_FLAG(repeat);
+  GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating);
+  GTEST_INTERNAL_PARSE_FLAG(shuffle);
+  GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth);
+  GTEST_INTERNAL_PARSE_FLAG(stream_result_to);
+  GTEST_INTERNAL_PARSE_FLAG(throw_on_failure);
+  return ParseFilterFlag(arg);
+}
+
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 static void LoadFlagsFromFile(const std::string& path) {
   FILE* flagfile = posix::FOpen(path.c_str(), "r");
   if (!flagfile) {
-    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG_GET(flagfile)
                       << "\"";
   }
   std::string contents(ReadEntireFile(flagfile));
@@ -6559,38 +6609,34 @@ static void LoadFlagsFromFile(const std::string& path) {
   std::vector<std::string> lines;
   SplitString(contents, '\n', &lines);
   for (size_t i = 0; i < lines.size(); ++i) {
-    if (lines[i].empty())
-      continue;
-    if (!ParseGoogleTestFlag(lines[i].c_str()))
-      g_help_flag = true;
+    if (lines[i].empty()) continue;
+    if (!ParseGoogleTestFlag(lines[i].c_str())) g_help_flag = true;
   }
 }
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 
 // Parses the command line for Google Test flags, without initializing
 // other parts of Google Test.  The type parameter CharType can be
 // instantiated to either char or wchar_t.
 template <typename CharType>
 void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
+  std::string flagfile_value;
   for (int i = 1; i < *argc; i++) {
     const std::string arg_string = StreamableToString(argv[i]);
     const char* const arg = arg_string.c_str();
 
-    using internal::ParseBoolFlag;
-    using internal::ParseInt32Flag;
-    using internal::ParseStringFlag;
+    using internal::ParseFlag;
 
     bool remove_flag = false;
     if (ParseGoogleTestFlag(arg)) {
       remove_flag = true;
-#if GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
-      LoadFlagsFromFile(GTEST_FLAG(flagfile));
+#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
+    } else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
+      GTEST_FLAG_SET(flagfile, flagfile_value);
+      LoadFlagsFromFile(flagfile_value);
       remove_flag = true;
-#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
-    } else if (arg_string == "--help" || arg_string == "-h" ||
-               arg_string == "-?" || arg_string == "/?" ||
-               HasGoogleTestFlagPrefix(arg)) {
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
+    } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
       // Both help flag and unrecognized Google Test flags (excluding
       // internal ones) trigger help display.
       g_help_flag = true;
@@ -6631,7 +6677,27 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 // Parses the command line for Google Test flags, without initializing
 // other parts of Google Test.
 void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
+#if GTEST_HAS_ABSL
+  if (*argc > 0) {
+    // absl::ParseCommandLine() requires *argc > 0.
+    auto positional_args = absl::flags_internal::ParseCommandLineImpl(
+        *argc, argv, absl::flags_internal::ArgvListAction::kRemoveParsedArgs,
+        absl::flags_internal::UsageFlagsAction::kHandleUsage,
+        absl::flags_internal::OnUndefinedFlag::kReportUndefined);
+    // Any command-line positional arguments not part of any command-line flag
+    // (or arguments to a flag) are copied back out to argv, with the program
+    // invocation name at position 0, and argc is resized. This includes
+    // positional arguments after the flag-terminating delimiter '--'.
+    // See https://abseil.io/docs/cpp/guides/flags.
+    std::copy(positional_args.begin(), positional_args.end(), argv);
+    if (static_cast<int>(positional_args.size()) < *argc) {
+      argv[positional_args.size()] = nullptr;
+      *argc = static_cast<int>(positional_args.size());
+    }
+  }
+#else
   ParseGoogleTestFlagsOnlyImpl(argc, argv);
+#endif
 
   // Fix the value of *_NSGetArgc() on macOS, but if and only if
   // *_NSGetArgv() == argv
@@ -6666,6 +6732,12 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
 
 #if GTEST_HAS_ABSL
   absl::InitializeSymbolizer(g_argvs[0].c_str());
+
+  // When using the Abseil Flags library, set the program usage message to the
+  // help message, but remove the color-encoding from the message first.
+  absl::SetProgramUsageMessage(absl::StrReplaceAll(
+      kColorEncodedHelpMessage,
+      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
 #endif  // GTEST_HAS_ABSL
 
   ParseGoogleTestFlagsOnly(argc, argv);
@@ -6686,7 +6758,7 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
 void InitGoogleTest(int* argc, char** argv) {
 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   internal::InitGoogleTestImpl(argc, argv);
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }
@@ -6696,7 +6768,7 @@ void InitGoogleTest(int* argc, char** argv) {
 void InitGoogleTest(int* argc, wchar_t** argv) {
 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   internal::InitGoogleTestImpl(argc, argv);
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }
@@ -6712,42 +6784,67 @@ void InitGoogleTest() {
 
 #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
   internal::InitGoogleTestImpl(&argc, argv);
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }
 
+#if !defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) || \
+    !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
+// Returns the value of the first environment variable that is set and contains
+// a non-empty string. If there are none, returns the "fallback" string. Adds
+// the director-separator character as a suffix if not provided in the
+// environment variable value.
+static std::string GetDirFromEnv(
+    std::initializer_list<const char*> environment_variables,
+    const char* fallback, char separator) {
+  for (const char* variable_name : environment_variables) {
+    const char* value = internal::posix::GetEnv(variable_name);
+    if (value != nullptr && value[0] != '\0') {
+      if (value[strlen(value) - 1] != separator) {
+        return std::string(value).append(1, separator);
+      }
+      return value;
+    }
+  }
+  return fallback;
+}
+#endif
+
 std::string TempDir() {
 #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
   return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
-#elif GTEST_OS_WINDOWS_MOBILE
-  return "\\temp\\";
-#elif GTEST_OS_WINDOWS
-  const char* temp_dir = internal::posix::GetEnv("TEMP");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "\\temp\\";
-  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
-    return temp_dir;
-  } else {
-    return std::string(temp_dir) + "\\";
-  }
+#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE
+  return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
 #elif GTEST_OS_LINUX_ANDROID
-  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "/data/local/tmp/";
-  } else {
-    return temp_dir;
-  }
-#elif GTEST_OS_LINUX
-  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "/tmp/";
-  } else {
-    return temp_dir;
-  }
+  return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/');
 #else
-  return "/tmp/";
-#endif  // GTEST_OS_WINDOWS_MOBILE
+  return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/');
+#endif
+}
+
+#if !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
+// Returns the directory path (including terminating separator) of the current
+// executable as derived from argv[0].
+static std::string GetCurrentExecutableDirectory() {
+  internal::FilePath argv_0(internal::GetArgvs()[0]);
+  return argv_0.RemoveFileName().string();
+}
+#endif
+
+std::string SrcDir() {
+#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
+  return GTEST_CUSTOM_SRCDIR_FUNCTION_();
+#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE
+  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
+                       '\\');
+#elif GTEST_OS_LINUX_ANDROID
+  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
+                       '/');
+#else
+  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
+                       '/');
+#endif
 }
 
 // Class ScopedTrace
@@ -6764,8 +6861,7 @@ void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
 }
 
 // Pops the info pushed by the c'tor.
-ScopedTrace::~ScopedTrace()
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+ScopedTrace::~ScopedTrace() GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
   UnitTest::GetInstance()->PopGTestTrace();
 }
 
diff --git a/googletest/googletest/src/gtest_main.cc b/googletest/googletest/src/gtest_main.cc
index eb6eab0d8eac7fb8389402b15fef951faa6ed081..965e16577449264f621c78133fe38a8af8a79184 100644
--- a/googletest/googletest/src/gtest_main.cc
+++ b/googletest/googletest/src/gtest_main.cc
@@ -28,15 +28,17 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <cstdio>
+
 #include "gtest/gtest.h"
 
 #if GTEST_OS_ESP8266 || GTEST_OS_ESP32
+// Arduino-like platforms: program entry points are setup/loop instead of main.
+
 #if GTEST_OS_ESP8266
 extern "C" {
 #endif
-void setup() {
-  testing::InitGoogleTest();
-}
+
+void setup() { testing::InitGoogleTest(); }
 
 void loop() { RUN_ALL_TESTS(); }
 
@@ -44,7 +46,16 @@ void loop() { RUN_ALL_TESTS(); }
 }
 #endif
 
+#elif GTEST_OS_QURT
+// QuRT: program entry point is main, but argc/argv are unusable.
+
+GTEST_API_ int main() {
+  printf("Running main() from %s\n", __FILE__);
+  testing::InitGoogleTest();
+  return RUN_ALL_TESTS();
+}
 #else
+// Normal platforms: program entry point is main, argc/argv are initialized.
 
 GTEST_API_ int main(int argc, char **argv) {
   printf("Running main() from %s\n", __FILE__);
diff --git a/googletest/googletest/src/hwext/gtest-filter.cc b/googletest/googletest/src/hwext/gtest-filter.cc
index b9fef40649d72f8cbc5fbbe7957d17dbfac8ba26..0249fc6507735120ec7a4122f0aacfdb1c5d78ce 100644
--- a/googletest/googletest/src/hwext/gtest-filter.cc
+++ b/googletest/googletest/src/hwext/gtest-filter.cc
@@ -26,12 +26,12 @@ namespace testing {
     void TestFilter::printHelp() const 
     {
         printf("\nTest Filtering:\n");
-        const std::vector<const TestFlag*>& tagsets = AllHextTagSets();
+        const std::vector<const TestFlag*>& tagSets = AllHextTagSets();
         // help message line indents
         const char* indents[] = { "  ", "      " };
 
-        for (unsigned int i = 0; i < tagsets.size(); i++) {
-            tagsets.at(i)->printHelp(indents);
+        for (unsigned int i = 0; i < tagSets.size(); i++) {
+          tagSets.at(i)->printHelp(indents);
         }
 
         printf("%sSelect tests by test level, may be a list seperated by ',' or ';'.\n", indents[1]);
diff --git a/googletest/googletest/src/hwext/gtest-multithread.cpp b/googletest/googletest/src/hwext/gtest-multithread.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2ca22fa45baa8078e34fc92ecc70f977908f0d44
--- /dev/null
+++ b/googletest/googletest/src/hwext/gtest-multithread.cpp
@@ -0,0 +1,96 @@
+/*
+* Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.
+* Description:多线程测试框架(GTEST-MULTITHREAD)库，源码移植自CDK
+* Author:
+* Create:2023/2/24
+*/
+
+#include "gtest/hwext/gtest-multithread.h"
+#include <iostream>
+#include <pthread.h>
+#include <utility>
+#include <semaphore.h>
+#include <fcntl.h>
+#include <semaphore.h>
+#include <iostream>
+#include <algorithm>
+
+namespace testing{
+    namespace mt {
+        static inline void doThreadTestTask(ThreadTaskEntry *task)
+        {
+            for (const auto &f : task->funcList){
+                f.m_func();
+            }
+        }
+
+        void MultiThreadTest::run()
+        {
+            int i = 0;
+            for (const auto &_ : randomTasks) {
+                for (const auto &val : _.second) {
+                    auto pid = rand() % 100 + i;
+                    appendTaskToList(pid, val.m_func, val.m_testsuite, val.m_testcase);
+                }
+                i++;
+            }
+            doTest();
+        }
+
+        void MultiThreadTest::doTest()
+        {
+            threadTestEntryList.clear();
+            for (const auto &task : threadTasks){
+                threadTestEntryList.push_back(ThreadTaskEntry(task));
+            }
+            for (auto &test : threadTestEntryList){
+                test.thread = new std::thread(doThreadTestTask, &test);
+            }
+            auto check = [&](ThreadTaskEntry &t) -> void {
+                if (t.thread){
+                    t.thread->join();
+                    delete t.thread;
+                    t.thread = nullptr;
+                }
+            };
+            std::for_each(threadTestEntryList.begin(), threadTestEntryList.end(), check);
+        }
+
+        unsigned MultiThreadTest::runTask(unsigned thread_num, PF func, std::string testsuite, std::string testcase)
+        {
+            MultiThreadFailCaseListener *listener = new MultiThreadFailCaseListener(this);
+            testing::UnitTest::GetInstance()->listeners().Append(listener);
+            if (thread_num == 0){
+                func();
+            }
+            unsigned i = 0;
+            for(; i < thread_num; i++){
+                appendTaskToList(i, func, testsuite, testcase);
+            }
+            i = 0;
+            for (const auto &_ : randomTasks){
+                for (const auto &val : _.second){
+                    auto pid = rand() % 100 + i;
+                    appendTaskToList(pid, val.m_func, val.m_testsuite, val.m_testcase);
+                }
+                i++;
+            }
+            doTest();
+            testing::UnitTest::GetInstance()->listeners().Release(listener);
+            return 0;
+        }
+
+        void MultiThreadTest::appendTaskToList(unsigned thread_id, PF func, std::string testsuite, std::string testcase)
+        {
+            TestTask task(testsuite, testcase, func);
+            if (thread_id == RANDOM_THREAD_ID){
+                randomTasks[testsuite].emplace_back(task);
+                return;
+            }
+            while (thread_id >= threadTasks.size()){
+                threadTasks.push_back(std::vector<TestTask>());
+            }
+            threadTasks[thread_id].push_back(task);
+        }
+    }
+}
\ No newline at end of file
diff --git a/googletest/googletest/test/BUILD.bazel b/googletest/googletest/test/BUILD.bazel
index b06a00a106fdd3f3a1ecf506c59ed3648764ab2d..7754c1303fc00eb606f3ddf9c3eb607f7d608a14 100644
--- a/googletest/googletest/test/BUILD.bazel
+++ b/googletest/googletest/test/BUILD.bazel
@@ -30,7 +30,6 @@
 #
 # Bazel BUILD for The Google C++ Testing Framework (Google Test)
 
-load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
 load("@rules_python//python:defs.bzl", "py_library", "py_test")
 
 licenses(["notice"])
@@ -95,6 +94,7 @@ cc_test(
         "googletest/test",
     ],
     linkopts = select({
+        "//:qnx": [],
         "//:windows": [],
         "//conditions:default": ["-pthread"],
     }),
@@ -174,6 +174,10 @@ py_test(
     name = "gtest_help_test",
     size = "small",
     srcs = ["gtest_help_test.py"],
+    args = select({
+        "//:has_absl": ["--has_absl_flags"],
+        "//conditions:default": [],
+    }),
     data = [":gtest_help_test_"],
     deps = [":gtest_test_utils"],
 )
diff --git a/googletest/googletest/test/googletest-break-on-failure-unittest.py b/googletest/googletest/test/googletest-break-on-failure-unittest.py
index a5dfbc693b43a1b19e3847dcbcab886d2f4d28e6..4eafba3e6bb46dfe5f3b07ce1be7b68325430105 100644
--- a/googletest/googletest/test/googletest-break-on-failure-unittest.py
+++ b/googletest/googletest/test/googletest-break-on-failure-unittest.py
@@ -39,7 +39,7 @@ Google Test) with different environments and command line flags.
 """
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Constants.
 
diff --git a/googletest/googletest/test/googletest-break-on-failure-unittest_.cc b/googletest/googletest/test/googletest-break-on-failure-unittest_.cc
index f84957a2d03b56260c8e2c0ae8f5a27beb6f6378..324294f33ec7a2b8ad8cbcc608e6aa2dea252d58 100644
--- a/googletest/googletest/test/googletest-break-on-failure-unittest_.cc
+++ b/googletest/googletest/test/googletest-break-on-failure-unittest_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Unit test for Google Test's break-on-failure mode.
 //
 // A user can ask Google Test to seg-fault when an assertion fails, using
@@ -41,34 +40,32 @@
 #include "gtest/gtest.h"
 
 #if GTEST_OS_WINDOWS
-# include <windows.h>
-# include <stdlib.h>
+#include <stdlib.h>
+#include <windows.h>
 #endif
 
 namespace {
 
 // A test that's expected to fail.
-TEST(Foo, Bar) {
-  EXPECT_EQ(2, 3);
-}
+TEST(Foo, Bar) { EXPECT_EQ(2, 3); }
 
 #if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
 // On Windows Mobile global exception handlers are not supported.
-LONG WINAPI ExitWithExceptionCode(
-    struct _EXCEPTION_POINTERS* exception_pointers) {
+LONG WINAPI
+ExitWithExceptionCode(struct _EXCEPTION_POINTERS* exception_pointers) {
   exit(exception_pointers->ExceptionRecord->ExceptionCode);
 }
 #endif
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
 #if GTEST_OS_WINDOWS
   // Suppresses display of the Windows error dialog upon encountering
   // a general protection fault (segment violation).
   SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
 
-# if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
+#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE
 
   // The default unhandled exception filter does not always exit
   // with the exception code as exit code - for example it exits with
@@ -78,7 +75,7 @@ int main(int argc, char **argv) {
   // exceptions.
   SetUnhandledExceptionFilter(ExitWithExceptionCode);
 
-# endif
+#endif
 #endif  // GTEST_OS_WINDOWS
   testing::InitGoogleTest(&argc, argv);
 
diff --git a/googletest/googletest/test/googletest-catch-exceptions-test.py b/googletest/googletest/test/googletest-catch-exceptions-test.py
index 94a5b33f2305092593755c3ab86aa5f6c329e2a0..d38d91a62a43cb1a0bce169c4b747dbbf042d6d6 100644
--- a/googletest/googletest/test/googletest-catch-exceptions-test.py
+++ b/googletest/googletest/test/googletest-catch-exceptions-test.py
@@ -35,7 +35,7 @@ googletest-catch-exceptions-ex-test_ (programs written with
 Google Test) and verifies their output.
 """
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Constants.
 FLAG_PREFIX = '--gtest_'
@@ -147,19 +147,19 @@ class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
     self.assertTrue(
         'CxxExceptionInConstructorTest::TearDownTestSuite() '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
-    self.assertTrue(
+    self.assertFalse(
         'CxxExceptionInSetUpTestSuiteTest constructor '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
-    self.assertTrue(
+    self.assertFalse(
         'CxxExceptionInSetUpTestSuiteTest destructor '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
-    self.assertTrue(
+    self.assertFalse(
         'CxxExceptionInSetUpTestSuiteTest::SetUp() '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
-    self.assertTrue(
+    self.assertFalse(
         'CxxExceptionInSetUpTestSuiteTest::TearDown() '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
-    self.assertTrue(
+    self.assertFalse(
         'CxxExceptionInSetUpTestSuiteTest test body '
         'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
 
diff --git a/googletest/googletest/test/googletest-catch-exceptions-test_.cc b/googletest/googletest/test/googletest-catch-exceptions-test_.cc
index 8c127d40b11d4d72a3faae80bafbb746d1aa4128..3c8f4f4b790cf063897c9b9cd1b11806dedd8167 100644
--- a/googletest/googletest/test/googletest-catch-exceptions-test_.cc
+++ b/googletest/googletest/test/googletest-catch-exceptions-test_.cc
@@ -32,18 +32,18 @@
 // exceptions, and the output is verified by
 // googletest-catch-exceptions-test.py.
 
-#include <stdio.h>  // NOLINT
+#include <stdio.h>   // NOLINT
 #include <stdlib.h>  // For exit().
 
 #include "gtest/gtest.h"
 
 #if GTEST_HAS_SEH
-# include <windows.h>
+#include <windows.h>
 #endif
 
 #if GTEST_HAS_EXCEPTIONS
-# include <exception>  // For set_terminate().
-# include <stdexcept>
+#include <exception>  // For set_terminate().
+#include <stdexcept>
 #endif
 
 using testing::Test;
@@ -93,9 +93,7 @@ class SehExceptionInTearDownTest : public Test {
 
 TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {}
 
-TEST(SehExceptionTest, ThrowsSehException) {
-  RaiseException(42, 0, 0, NULL);
-}
+TEST(SehExceptionTest, ThrowsSehException) { RaiseException(42, 0, 0, NULL); }
 
 #endif  // GTEST_HAS_SEH
 
@@ -269,9 +267,7 @@ TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) {
   throw std::runtime_error("Standard C++ exception");
 }
 
-TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
-  throw "C-string";
-}
+TEST(CxxExceptionTest, ThrowsNonStdCxxException) { throw "C-string"; }
 
 // This terminate handler aborts the program using exit() rather than abort().
 // This avoids showing pop-ups on Windows systems and core dumps on Unix-like
diff --git a/googletest/googletest/test/googletest-color-test.py b/googletest/googletest/test/googletest-color-test.py
index f3b7c9990bcf44a65036c253e7a01845af9c3717..f08edf707f1c056ded6542fbd4b21a86f422a9c0 100644
--- a/googletest/googletest/test/googletest-color-test.py
+++ b/googletest/googletest/test/googletest-color-test.py
@@ -32,7 +32,7 @@
 """Verifies that Google Test correctly determines whether to use colors."""
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 IS_WINDOWS = os.name == 'nt'
 
@@ -78,6 +78,7 @@ class GTestColorTest(gtest_test_utils.TestCase):
     self.assert_(UsesColor('cygwin', None, None))
     self.assert_(UsesColor('xterm', None, None))
     self.assert_(UsesColor('xterm-color', None, None))
+    self.assert_(UsesColor('xterm-kitty', None, None))
     self.assert_(UsesColor('xterm-256color', None, None))
 
   def testFlagOnly(self):
diff --git a/googletest/googletest/test/googletest-color-test_.cc b/googletest/googletest/test/googletest-color-test_.cc
index 220a3a00548fdb1e935a3da16df563a50e179a8a..55657b7262b6ba8fd65b76cfe9d8b707304e64a8 100644
--- a/googletest/googletest/test/googletest-color-test_.cc
+++ b/googletest/googletest/test/googletest-color-test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // A helper program for testing how Google Test determines whether to use
 // colors in the output.  It prints "YES" and returns 1 if Google Test
 // decides to use colors, and prints "NO" and returns 0 otherwise.
@@ -43,8 +42,7 @@ using testing::internal::ShouldUseColor;
 // created before main() is entered, and thus that ShouldUseColor()
 // works the same way as in a real Google-Test-based test.  We don't actual
 // run the TEST itself.
-TEST(GTestColorTest, Dummy) {
-}
+TEST(GTestColorTest, Dummy) {}
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/googletest/googletest/test/googletest-death-test-test.cc b/googletest/googletest/test/googletest-death-test-test.cc
index c0b3d1f21d04d3de77803836704cb7f47d2adfe9..4737ff9bfb6b7f8563eb0c23ca564e02b4d0fd45 100644
--- a/googletest/googletest/test/googletest-death-test-test.cc
+++ b/googletest/googletest/test/googletest-death-test-test.cc
@@ -31,7 +31,6 @@
 // Tests for death tests.
 
 #include "gtest/gtest-death-test.h"
-
 #include "gtest/gtest.h"
 #include "gtest/internal/gtest-filepath.h"
 
@@ -40,25 +39,25 @@ using testing::internal::AlwaysTrue;
 
 #if GTEST_HAS_DEATH_TEST
 
-# if GTEST_OS_WINDOWS
-#  include <fcntl.h>           // For O_BINARY
-#  include <direct.h>          // For chdir().
-#  include <io.h>
-# else
-#  include <unistd.h>
-#  include <sys/wait.h>        // For waitpid.
-# endif  // GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
+#include <direct.h>  // For chdir().
+#include <fcntl.h>   // For O_BINARY
+#include <io.h>
+#else
+#include <sys/wait.h>  // For waitpid.
+#include <unistd.h>
+#endif  // GTEST_OS_WINDOWS
 
-# include <limits.h>
-# include <signal.h>
-# include <stdio.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
 
-# if GTEST_OS_LINUX
-#  include <sys/time.h>
-# endif  // GTEST_OS_LINUX
+#if GTEST_OS_LINUX
+#include <sys/time.h>
+#endif  // GTEST_OS_LINUX
 
-# include "gtest/gtest-spi.h"
-# include "src/gtest-internal-inl.h"
+#include "gtest/gtest-spi.h"
+#include "src/gtest-internal-inl.h"
 
 namespace posix = ::testing::internal::posix;
 
@@ -90,6 +89,7 @@ class ReplaceDeathTestFactory {
     unit_test_impl_->death_test_factory_.release();
     unit_test_impl_->death_test_factory_.reset(old_factory_);
   }
+
  private:
   // Prevents copying ReplaceDeathTestFactory objects.
   ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
@@ -116,8 +116,7 @@ void DieWithMessage(const ::std::string& message) {
   // Some compilers can recognize that _exit() never returns and issue the
   // 'unreachable code' warning for code following this function, unless
   // fooled by a fake condition.
-  if (AlwaysTrue())
-    _exit(1);
+  if (AlwaysTrue()) _exit(1);
 }
 
 void DieInside(const ::std::string& function) {
@@ -137,8 +136,7 @@ class TestForDeathTest : public testing::Test {
 
   // A method of the test fixture that may die.
   void MemberFunction() {
-    if (should_die_)
-      DieInside("MemberFunction");
+    if (should_die_) DieInside("MemberFunction");
   }
 
   // True if and only if MemberFunction() should die.
@@ -153,8 +151,7 @@ class MayDie {
 
   // A member function that may die.
   void MemberFunction() const {
-    if (should_die_)
-      DieInside("MayDie::MemberFunction");
+    if (should_die_) DieInside("MayDie::MemberFunction");
   }
 
  private:
@@ -173,8 +170,7 @@ int NonVoidFunction() {
 
 // A unary function that may die.
 void DieIf(bool should_die) {
-  if (should_die)
-    DieInside("DieIf");
+  if (should_die) DieInside("DieIf");
 }
 
 // A binary function that may die.
@@ -195,16 +191,16 @@ void DeathTestSubroutine() {
 int DieInDebugElse12(int* sideeffect) {
   if (sideeffect) *sideeffect = 12;
 
-# ifndef NDEBUG
+#ifndef NDEBUG
 
   DieInside("DieInDebugElse12");
 
-# endif  // NDEBUG
+#endif  // NDEBUG
 
   return 12;
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
 // Death in dbg due to Windows CRT assertion failure, not opt.
 int DieInCRTDebugElse12(int* sideeffect) {
@@ -224,7 +220,7 @@ int DieInCRTDebugElse12(int* sideeffect) {
 
 #endif  // GTEST_OS_WINDOWS
 
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
 // Tests the ExitedWithCode predicate.
 TEST(ExitStatusPredicateTest, ExitedWithCode) {
@@ -237,7 +233,7 @@ TEST(ExitStatusPredicateTest, ExitedWithCode) {
   EXPECT_FALSE(testing::ExitedWithCode(1)(0));
 }
 
-# else
+#else
 
 // Returns the exit status of a process that calls _exit(2) with a
 // given exit code.  This is a helper function for the
@@ -270,14 +266,14 @@ static int KilledExitStatus(int signum) {
 
 // Tests the ExitedWithCode predicate.
 TEST(ExitStatusPredicateTest, ExitedWithCode) {
-  const int status0  = NormalExitStatus(0);
-  const int status1  = NormalExitStatus(1);
+  const int status0 = NormalExitStatus(0);
+  const int status1 = NormalExitStatus(1);
   const int status42 = NormalExitStatus(42);
   const testing::ExitedWithCode pred0(0);
   const testing::ExitedWithCode pred1(1);
   const testing::ExitedWithCode pred42(42);
-  EXPECT_PRED1(pred0,  status0);
-  EXPECT_PRED1(pred1,  status1);
+  EXPECT_PRED1(pred0, status0);
+  EXPECT_PRED1(pred1, status1);
   EXPECT_PRED1(pred42, status42);
   EXPECT_FALSE(pred0(status1));
   EXPECT_FALSE(pred42(status0));
@@ -296,7 +292,7 @@ TEST(ExitStatusPredicateTest, KilledBySignal) {
   EXPECT_FALSE(pred_kill(status_segv));
 }
 
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 
 // The following code intentionally tests a suboptimal syntax.
 #ifdef __GNUC__
@@ -320,8 +316,7 @@ TEST_F(TestForDeathTest, SingleStatement) {
     // doesn't expand into an "if" statement without an "else"
     ;
 
-  if (AlwaysFalse())
-    ASSERT_DEATH(return, "") << "did not die";
+  if (AlwaysFalse()) ASSERT_DEATH(return, "") << "did not die";
 
   if (AlwaysFalse())
     ;
@@ -332,7 +327,7 @@ TEST_F(TestForDeathTest, SingleStatement) {
 #pragma GCC diagnostic pop
 #endif
 
-# if GTEST_USES_PCRE
+#if GTEST_USES_PCRE
 
 void DieWithEmbeddedNul() {
   fprintf(stderr, "Hello%cmy null world.\n", '\0');
@@ -347,7 +342,7 @@ TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
   ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
 }
 
-# endif  // GTEST_USES_PCRE
+#endif  // GTEST_USES_PCRE
 
 // Tests that death test macros expand to code which interacts well with switch
 // statements.
@@ -357,12 +352,12 @@ TEST_F(TestForDeathTest, SwitchStatement) {
   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
 
   switch (0)
-    default:
-      ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
+  default:
+    ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
 
   switch (0)
-    case 0:
-      EXPECT_DEATH(_exit(1), "") << "exit in switch case";
+  case 0:
+    EXPECT_DEATH(_exit(1), "") << "exit in switch case";
 
   GTEST_DISABLE_MSC_WARNINGS_POP_()
 }
@@ -370,14 +365,14 @@ TEST_F(TestForDeathTest, SwitchStatement) {
 // Tests that a static member function can be used in a "fast" style
 // death test.
 TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
 }
 
 // Tests that a method of the test fixture can be used in a "fast"
 // style death test.
 TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   should_die_ = true;
   EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
 }
@@ -387,7 +382,7 @@ void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
 // Tests that death tests work even if the current directory has been
 // changed.
 TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
 
   ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
@@ -396,8 +391,9 @@ TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
   ASSERT_DEATH(_exit(1), "");
 }
 
-# if GTEST_OS_LINUX
-void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
+#if GTEST_OS_LINUX
+void SigprofAction(int, siginfo_t*, void*) { /* no op */
+}
 
 // Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
 void SetSigprofActionAndTimer() {
@@ -432,7 +428,7 @@ void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
 
 // Tests that death tests work when SIGPROF handler and timer are set.
 TEST_F(TestForDeathTest, FastSigprofActionSet) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   SetSigprofActionAndTimer();
   EXPECT_DEATH(_exit(1), "");
   struct sigaction old_signal_action;
@@ -441,37 +437,37 @@ TEST_F(TestForDeathTest, FastSigprofActionSet) {
 }
 
 TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   SetSigprofActionAndTimer();
   EXPECT_DEATH(_exit(1), "");
   struct sigaction old_signal_action;
   DisableSigprofActionAndTimer(&old_signal_action);
   EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
 }
-# endif  // GTEST_OS_LINUX
+#endif  // GTEST_OS_LINUX
 
 // Repeats a representative sample of death tests in the "threadsafe" style:
 
 TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
 }
 
 TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   should_die_ = true;
   EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
 }
 
 TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
 
   for (int i = 0; i < 3; ++i)
     EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
 }
 
 TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
 
   ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
@@ -481,23 +477,21 @@ TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
 }
 
 TEST_F(TestForDeathTest, MixedStyles) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   EXPECT_DEATH(_exit(1), "");
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_DEATH(_exit(1), "");
 }
 
-# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
+#if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
 
 bool pthread_flag;
 
-void SetPthreadFlag() {
-  pthread_flag = true;
-}
+void SetPthreadFlag() { pthread_flag = true; }
 
 TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
-  if (!testing::GTEST_FLAG(death_test_use_fork)) {
-    testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  if (!GTEST_FLAG_GET(death_test_use_fork)) {
+    GTEST_FLAG_SET(death_test_style, "threadsafe");
     pthread_flag = false;
     ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, nullptr, nullptr));
     ASSERT_DEATH(_exit(1), "");
@@ -505,7 +499,7 @@ TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
   }
 }
 
-# endif  // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
+#endif  // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
 
 // Tests that a method of another class can be used in a death test.
 TEST_F(TestForDeathTest, MethodOfAnotherClass) {
@@ -527,7 +521,7 @@ TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
   const testing::internal::RE regex(regex_c_str);
   EXPECT_DEATH(GlobalFunction(), regex);
 
-# if !GTEST_USES_PCRE
+#if !GTEST_USES_PCRE
 
   const ::std::string regex_std_str(regex_c_str);
   EXPECT_DEATH(GlobalFunction(), regex_std_str);
@@ -536,7 +530,7 @@ TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
   // lifetime extension of the pointer is not sufficient.
   EXPECT_DEATH(GlobalFunction(), ::std::string(regex_c_str).c_str());
 
-# endif  // !GTEST_USES_PCRE
+#endif  // !GTEST_USES_PCRE
 }
 
 // Tests that a non-void function can be used in a death test.
@@ -551,9 +545,7 @@ TEST_F(TestForDeathTest, FunctionWithParameter) {
 }
 
 // Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
-TEST_F(TestForDeathTest, OutsideFixture) {
-  DeathTestSubroutine();
-}
+TEST_F(TestForDeathTest, OutsideFixture) { DeathTestSubroutine(); }
 
 // Tests that death tests can be done inside a loop.
 TEST_F(TestForDeathTest, InsideLoop) {
@@ -564,25 +556,28 @@ TEST_F(TestForDeathTest, InsideLoop) {
 
 // Tests that a compound statement can be used in a death test.
 TEST_F(TestForDeathTest, CompoundStatement) {
-  EXPECT_DEATH({  // NOLINT
-    const int x = 2;
-    const int y = x + 1;
-    DieIfLessThan(x, y);
-  },
-  "DieIfLessThan");
+  EXPECT_DEATH(
+      {  // NOLINT
+        const int x = 2;
+        const int y = x + 1;
+        DieIfLessThan(x, y);
+      },
+      "DieIfLessThan");
 }
 
 // Tests that code that doesn't die causes a death test to fail.
 TEST_F(TestForDeathTest, DoesNotDie) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
-                          "failed to die");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"), "failed to die");
 }
 
 // Tests that a death test fails when the error message isn't expected.
 TEST_F(TestForDeathTest, ErrorMessageMismatch) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
-  }, "died but not with expected error");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_DEATH(DieIf(true), "DieIfLessThan")
+            << "End of death test message.";
+      },
+      "died but not with expected error");
 }
 
 // On exit, *aborted will be true if and only if the EXPECT_DEATH()
@@ -596,19 +591,20 @@ void ExpectDeathTestHelper(bool* aborted) {
 // Tests that EXPECT_DEATH doesn't abort the test on failure.
 TEST_F(TestForDeathTest, EXPECT_DEATH) {
   bool aborted = true;
-  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
-                          "failed to die");
+  EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted), "failed to die");
   EXPECT_FALSE(aborted);
 }
 
 // Tests that ASSERT_DEATH does abort the test on failure.
 TEST_F(TestForDeathTest, ASSERT_DEATH) {
   static bool aborted;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    aborted = true;
-    ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
-    aborted = false;
-  }, "failed to die");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        aborted = true;
+        ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
+        aborted = false;
+      },
+      "failed to die");
   EXPECT_TRUE(aborted);
 }
 
@@ -653,52 +649,36 @@ TEST_F(TestForDeathTest, TestExpectDebugDeath) {
   EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), regex)
       << "Must accept a streamed message";
 
-# ifdef NDEBUG
+#ifdef NDEBUG
 
   // Checks that the assignment occurs in opt mode (sideeffect).
   EXPECT_EQ(12, sideeffect);
 
-# else
+#else
 
   // Checks that the assignment does not occur in dbg mode (no sideeffect).
   EXPECT_EQ(0, sideeffect);
 
-# endif
+#endif
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
-// Tests that EXPECT_DEBUG_DEATH works as expected when in debug mode
-// the Windows CRT crashes the process with an assertion failure.
+// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/crtsetreportmode
+// In debug mode, the calls to _CrtSetReportMode and _CrtSetReportFile enable
+// the dumping of assertions to stderr. Tests that EXPECT_DEATH works as
+// expected when in CRT debug mode (compiled with /MTd or /MDd, which defines
+// _DEBUG) the Windows CRT crashes the process with an assertion failure.
 // 1. Asserts on death.
 // 2. Has no side effect (doesn't pop up a window or wait for user input).
-//
-// And in opt mode, it:
-// 1.  Has side effects but does not assert.
+#ifdef _DEBUG
 TEST_F(TestForDeathTest, CRTDebugDeath) {
-  int sideeffect = 0;
-
-  // Put the regex in a local variable to make sure we don't get an "unused"
-  // warning in opt mode.
-  const char* regex = "dup.* : Assertion failed";
-
-  EXPECT_DEBUG_DEATH(DieInCRTDebugElse12(&sideeffect), regex)
+  EXPECT_DEATH(DieInCRTDebugElse12(nullptr), "dup.* : Assertion failed")
       << "Must accept a streamed message";
-
-# ifdef NDEBUG
-
-  // Checks that the assignment occurs in opt mode (sideeffect).
-  EXPECT_EQ(12, sideeffect);
-
-# else
-
-  // Checks that the assignment does not occur in dbg mode (no sideeffect).
-  EXPECT_EQ(0, sideeffect);
-
-# endif
 }
+#endif  // _DEBUG
 
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 // Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
 // message to it, and in debug mode it:
@@ -713,20 +693,20 @@ TEST_F(TestForDeathTest, TestAssertDebugDeath) {
   ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
       << "Must accept a streamed message";
 
-# ifdef NDEBUG
+#ifdef NDEBUG
 
   // Checks that the assignment occurs in opt mode (sideeffect).
   EXPECT_EQ(12, sideeffect);
 
-# else
+#else
 
   // Checks that the assignment does not occur in dbg mode (no sideeffect).
   EXPECT_EQ(0, sideeffect);
 
-# endif
+#endif
 }
 
-# ifndef NDEBUG
+#ifndef NDEBUG
 
 void ExpectDebugDeathHelper(bool* aborted) {
   *aborted = true;
@@ -734,18 +714,21 @@ void ExpectDebugDeathHelper(bool* aborted) {
   *aborted = false;
 }
 
-#  if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
-  printf("This test should be considered failing if it shows "
-         "any pop-up dialogs.\n");
+  printf(
+      "This test should be considered failing if it shows "
+      "any pop-up dialogs.\n");
   fflush(stdout);
 
-  EXPECT_DEATH({
-    testing::GTEST_FLAG(catch_exceptions) = false;
-    abort();
-  }, "");
+  EXPECT_DEATH(
+      {
+        GTEST_FLAG_SET(catch_exceptions, false);
+        abort();
+      },
+      "");
 }
-#  endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 // Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
 // the function.
@@ -836,83 +819,86 @@ TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
   EXPECT_TRUE(aborted);
 }
 
-# endif  // _NDEBUG
+#endif  // _NDEBUG
 
 // Tests the *_EXIT family of macros, using a variety of predicates.
 static void TestExitMacros() {
-  EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
   ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 
   // Of all signals effects on the process exit code, only those of SIGABRT
   // are documented on Windows.
   // See https://msdn.microsoft.com/en-us/query-bi/m/dwwzkt4c.
   EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
 
-# elif !GTEST_OS_FUCHSIA
+#elif !GTEST_OS_FUCHSIA
 
   // Fuchsia has no unix signals.
   EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
   ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
 
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
-      << "This failure is expected, too.";
-  }, "This failure is expected, too.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
+            << "This failure is expected, too.";
+      },
+      "This failure is expected, too.");
 
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
-      << "This failure is expected.";
-  }, "This failure is expected.");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
+            << "This failure is expected.";
+      },
+      "This failure is expected.");
 }
 
-TEST_F(TestForDeathTest, ExitMacros) {
-  TestExitMacros();
-}
+TEST_F(TestForDeathTest, ExitMacros) { TestExitMacros(); }
 
 TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
-  testing::GTEST_FLAG(death_test_use_fork) = true;
+  GTEST_FLAG_SET(death_test_use_fork, true);
   TestExitMacros();
 }
 
 TEST_F(TestForDeathTest, InvalidStyle) {
-  testing::GTEST_FLAG(death_test_style) = "rococo";
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
-  }, "This failure is expected.");
+  GTEST_FLAG_SET(death_test_style, "rococo");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
+      },
+      "This failure is expected.");
 }
 
 TEST_F(TestForDeathTest, DeathTestFailedOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_NONFATAL_FAILURE(
-      EXPECT_DEATH(DieWithMessage("death\n"),
-                   "expected message"),
+      EXPECT_DEATH(DieWithMessage("death\n"), "expected message"),
       "Actual msg:\n"
       "[  DEATH   ] death\n");
 }
 
 TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_DEATH({
-          fprintf(stderr, "returning\n");
-          fflush(stderr);
-          return;
-        }, ""),
-      "    Result: illegal return in test statement.\n"
-      " Error msg:\n"
-      "[  DEATH   ] returning\n");
+  GTEST_FLAG_SET(death_test_style, "fast");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(
+                              {
+                                fprintf(stderr, "returning\n");
+                                fflush(stderr);
+                                return;
+                              },
+                              ""),
+                          "    Result: illegal return in test statement.\n"
+                          " Error msg:\n"
+                          "[  DEATH   ] returning\n");
 }
 
 TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_NONFATAL_FAILURE(
       EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"),
-                  testing::ExitedWithCode(3),
-                  "expected message"),
+                  testing::ExitedWithCode(3), "expected message"),
       "    Result: died but not with expected exit code:\n"
       "            Exited with exit status 1\n"
       "Actual msg:\n"
@@ -920,7 +906,7 @@ TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
 }
 
 TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_NONFATAL_FAILURE(
       EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
                    "line 1\nxyz\nline 3\n"),
@@ -931,7 +917,7 @@ TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
 }
 
 TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
                "line 1\nline 2\nline 3\n");
 }
@@ -945,8 +931,8 @@ class MockDeathTestFactory : public DeathTestFactory {
               int line, DeathTest** test) override;
 
   // Sets the parameters for subsequent calls to Create.
-  void SetParameters(bool create, DeathTest::TestRole role,
-                     int status, bool passed);
+  void SetParameters(bool create, DeathTest::TestRole role, int status,
+                     bool passed);
 
   // Accessors.
   int AssumeRoleCalls() const { return assume_role_calls_; }
@@ -988,17 +974,15 @@ class MockDeathTestFactory : public DeathTestFactory {
   bool test_deleted_;
 };
 
-
 // A DeathTest implementation useful in testing.  It returns values set
 // at its creation from its various inherited DeathTest methods, and
 // reports calls to those methods to its parent MockDeathTestFactory
 // object.
 class MockDeathTest : public DeathTest {
  public:
-  MockDeathTest(MockDeathTestFactory *parent,
-                TestRole role, int status, bool passed) :
-      parent_(parent), role_(role), status_(status), passed_(passed) {
-  }
+  MockDeathTest(MockDeathTestFactory* parent, TestRole role, int status,
+                bool passed)
+      : parent_(parent), role_(role), status_(status), passed_(passed) {}
   ~MockDeathTest() override { parent_->test_deleted_ = true; }
   TestRole AssumeRole() override {
     ++parent_->assume_role_calls_;
@@ -1023,7 +1007,6 @@ class MockDeathTest : public DeathTest {
   const bool passed_;
 };
 
-
 // MockDeathTestFactory constructor.
 MockDeathTestFactory::MockDeathTestFactory()
     : create_(true),
@@ -1033,13 +1016,10 @@ MockDeathTestFactory::MockDeathTestFactory()
       assume_role_calls_(0),
       wait_calls_(0),
       passed_args_(),
-      abort_args_() {
-}
-
+      abort_args_() {}
 
 // Sets the parameters for subsequent calls to Create.
-void MockDeathTestFactory::SetParameters(bool create,
-                                         DeathTest::TestRole role,
+void MockDeathTestFactory::SetParameters(bool create, DeathTest::TestRole role,
                                          int status, bool passed) {
   create_ = create;
   role_ = role;
@@ -1052,7 +1032,6 @@ void MockDeathTestFactory::SetParameters(bool create,
   abort_args_.clear();
 }
 
-
 // Sets test to NULL (if create_ is false) or to the address of a new
 // MockDeathTest object with parameters taken from the last call
 // to SetParameters (if create_ is true).  Always returns true.
@@ -1092,10 +1071,12 @@ class MacroLogicDeathTest : public testing::Test {
   // test cannot be run directly from a test routine that uses a
   // MockDeathTest, or the remainder of the routine will not be executed.
   static void RunReturningDeathTest(bool* flag) {
-    ASSERT_DEATH({  // NOLINT
-      *flag = true;
-      return;
-    }, "");
+    ASSERT_DEATH(
+        {  // NOLINT
+          *flag = true;
+          return;
+        },
+        "");
   }
 };
 
@@ -1180,8 +1161,7 @@ TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
   // _exit(2) is called in that case by ForkingDeathTest, but not by
   // our MockDeathTest.
   ASSERT_EQ(2U, factory_->AbortCalls());
-  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
-            factory_->AbortArgument(0));
+  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, factory_->AbortArgument(0));
   EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
             factory_->AbortArgument(1));
   EXPECT_TRUE(factory_->TestDeleted());
@@ -1197,12 +1177,16 @@ TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
 TEST(StreamingAssertionsDeathTest, DeathTest) {
   EXPECT_DEATH(_exit(1), "") << "unexpected failure";
   ASSERT_DEATH(_exit(1), "") << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_DEATH(_exit(0), "") << "expected failure";
-  }, "expected failure");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_DEATH(_exit(0), "") << "expected failure";
-  }, "expected failure");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_DEATH(_exit(0), "") << "expected failure";
+      },
+      "expected failure");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_DEATH(_exit(0), "") << "expected failure";
+      },
+      "expected failure");
 }
 
 // Tests that GetLastErrnoDescription returns an empty string when the
@@ -1214,7 +1198,7 @@ TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
   EXPECT_STREQ("", GetLastErrnoDescription().c_str());
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 TEST(AutoHandleTest, AutoHandleWorks) {
   HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
   ASSERT_NE(INVALID_HANDLE_VALUE, handle);
@@ -1239,15 +1223,15 @@ TEST(AutoHandleTest, AutoHandleWorks) {
   testing::internal::AutoHandle auto_handle2;
   EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
 }
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 typedef unsigned __int64 BiggestParsable;
 typedef signed __int64 BiggestSignedParsable;
-# else
+#else
 typedef unsigned long long BiggestParsable;
 typedef signed long long BiggestSignedParsable;
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 // We cannot use std::numeric_limits<T>::max() as it clashes with the
 // max() macro defined by <windows.h>.
@@ -1338,11 +1322,11 @@ TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
   EXPECT_EQ(123, char_result);
 }
 
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
 TEST(EnvironmentTest, HandleFitsIntoSizeT) {
   ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
 }
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 // Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
 // failures when death tests are available on the system.
@@ -1358,23 +1342,27 @@ TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
 }
 
 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
-  testing::GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_FALSE(InDeathTestChild());
-  EXPECT_DEATH({
-    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
-    fflush(stderr);
-    _exit(1);
-  }, "Inside");
+  EXPECT_DEATH(
+      {
+        fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+        fflush(stderr);
+        _exit(1);
+      },
+      "Inside");
 }
 
 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
-  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   EXPECT_FALSE(InDeathTestChild());
-  EXPECT_DEATH({
-    fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
-    fflush(stderr);
-    _exit(1);
-  }, "Inside");
+  EXPECT_DEATH(
+      {
+        fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+        fflush(stderr);
+        _exit(1);
+      },
+      "Inside");
 }
 
 void DieWithMessage(const char* message) {
@@ -1502,8 +1490,7 @@ TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
     // doesn't expand into an "if" statement without an "else"
     ;  // NOLINT
 
-  if (AlwaysFalse())
-    ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
+  if (AlwaysFalse()) ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
 
   if (AlwaysFalse())
     ;  // NOLINT
@@ -1522,21 +1509,18 @@ TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
 
   switch (0)
-    default:
-      ASSERT_DEATH_IF_SUPPORTED(_exit(1), "")
-          << "exit in default switch handler";
+  default:
+    ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in default switch handler";
 
   switch (0)
-    case 0:
-      EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
+  case 0:
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
 
   GTEST_DISABLE_MSC_WARNINGS_POP_()
 }
 
 // Tests that a test case whose name ends with "DeathTest" works fine
 // on Windows.
-TEST(NotADeathTest, Test) {
-  SUCCEED();
-}
+TEST(NotADeathTest, Test) { SUCCEED(); }
 
 }  // namespace
diff --git a/googletest/googletest/test/googletest-death-test_ex_test.cc b/googletest/googletest/test/googletest-death-test_ex_test.cc
index 7219680d0749777784f645147b50395db09ba95d..f2515e377e4c7f4210325a730cc5ed6a56e23e4a 100644
--- a/googletest/googletest/test/googletest-death-test_ex_test.cc
+++ b/googletest/googletest/test/googletest-death-test_ex_test.cc
@@ -35,15 +35,15 @@
 
 #if GTEST_HAS_DEATH_TEST
 
-# if GTEST_HAS_SEH
-#  include <windows.h>          // For RaiseException().
-# endif
+#if GTEST_HAS_SEH
+#include <windows.h>  // For RaiseException().
+#endif
 
-# include "gtest/gtest-spi.h"
+#include "gtest/gtest-spi.h"
 
-# if GTEST_HAS_EXCEPTIONS
+#if GTEST_HAS_EXCEPTIONS
 
-#  include <exception>  // For std::exception.
+#include <exception>  // For std::exception.
 
 // Tests that death tests report thrown exceptions as failures and that the
 // exceptions do not escape death test macros.
@@ -53,7 +53,7 @@ TEST(CxxExceptionDeathTest, ExceptionIsFailure) {
   } catch (...) {  // NOLINT
     FAIL() << "An exception escaped a death test macro invocation "
            << "with catch_exceptions "
-           << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
+           << (GTEST_FLAG_GET(catch_exceptions) ? "enabled" : "disabled");
   }
 }
 
@@ -67,26 +67,25 @@ TEST(CxxExceptionDeathTest, PrintsMessageForStdExceptions) {
   EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
                           "exceptional message");
   // Verifies that the location is mentioned in the failure text.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""),
-                          __FILE__);
+  EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(throw TestException(), ""), __FILE__);
 }
-# endif  // GTEST_HAS_EXCEPTIONS
+#endif  // GTEST_HAS_EXCEPTIONS
 
-# if GTEST_HAS_SEH
+#if GTEST_HAS_SEH
 // Tests that enabling interception of SEH exceptions with the
 // catch_exceptions flag does not interfere with SEH exceptions being
 // treated as death by death tests.
 TEST(SehExceptionDeasTest, CatchExceptionsDoesNotInterfere) {
   EXPECT_DEATH(RaiseException(42, 0x0, 0, NULL), "")
       << "with catch_exceptions "
-      << (testing::GTEST_FLAG(catch_exceptions) ? "enabled" : "disabled");
+      << (GTEST_FLAG_GET(catch_exceptions) ? "enabled" : "disabled");
 }
-# endif
+#endif
 
 #endif  // GTEST_HAS_DEATH_TEST
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
-  testing::GTEST_FLAG(catch_exceptions) = GTEST_ENABLE_CATCH_EXCEPTIONS_ != 0;
+  GTEST_FLAG_SET(catch_exceptions, GTEST_ENABLE_CATCH_EXCEPTIONS_ != 0);
   return RUN_ALL_TESTS();
 }
diff --git a/googletest/googletest/test/googletest-env-var-test.py b/googletest/googletest/test/googletest-env-var-test.py
index 02c3655c398268965a2851623523175219bac56c..bc4d87d93841aa725377a10cd29cb0e3032c5939 100644
--- a/googletest/googletest/test/googletest-env-var-test.py
+++ b/googletest/googletest/test/googletest-env-var-test.py
@@ -32,7 +32,7 @@
 """Verifies that Google Test correctly parses environment variables."""
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 
 IS_WINDOWS = os.name == 'nt'
diff --git a/googletest/googletest/test/googletest-env-var-test_.cc b/googletest/googletest/test/googletest-env-var-test_.cc
index 52f95864e1e5ff4bd8f1c7e99e15310694181776..365337508027e99689bda1206dfaa380df4e7ce4 100644
--- a/googletest/googletest/test/googletest-env-var-test_.cc
+++ b/googletest/googletest/test/googletest-env-var-test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // A helper program for testing that Google Test parses the environment
 // variables correctly.
 
@@ -43,72 +42,71 @@ namespace testing {
 // The purpose of this is to make the test more realistic by ensuring
 // that the UnitTest singleton is created before main() is entered.
 // We don't actual run the TEST itself.
-TEST(GTestEnvVarTest, Dummy) {
-}
+TEST(GTestEnvVarTest, Dummy) {}
 
 void PrintFlag(const char* flag) {
   if (strcmp(flag, "break_on_failure") == 0) {
-    cout << GTEST_FLAG(break_on_failure);
+    cout << GTEST_FLAG_GET(break_on_failure);
     return;
   }
 
   if (strcmp(flag, "catch_exceptions") == 0) {
-    cout << GTEST_FLAG(catch_exceptions);
+    cout << GTEST_FLAG_GET(catch_exceptions);
     return;
   }
 
   if (strcmp(flag, "color") == 0) {
-    cout << GTEST_FLAG(color);
+    cout << GTEST_FLAG_GET(color);
     return;
   }
 
   if (strcmp(flag, "death_test_style") == 0) {
-    cout << GTEST_FLAG(death_test_style);
+    cout << GTEST_FLAG_GET(death_test_style);
     return;
   }
 
   if (strcmp(flag, "death_test_use_fork") == 0) {
-    cout << GTEST_FLAG(death_test_use_fork);
+    cout << GTEST_FLAG_GET(death_test_use_fork);
     return;
   }
 
   if (strcmp(flag, "fail_fast") == 0) {
-    cout << GTEST_FLAG(fail_fast);
+    cout << GTEST_FLAG_GET(fail_fast);
     return;
   }
 
   if (strcmp(flag, "filter") == 0) {
-    cout << GTEST_FLAG(filter);
+    cout << GTEST_FLAG_GET(filter);
     return;
   }
 
   if (strcmp(flag, "output") == 0) {
-    cout << GTEST_FLAG(output);
+    cout << GTEST_FLAG_GET(output);
     return;
   }
 
   if (strcmp(flag, "brief") == 0) {
-    cout << GTEST_FLAG(brief);
+    cout << GTEST_FLAG_GET(brief);
     return;
   }
 
   if (strcmp(flag, "print_time") == 0) {
-    cout << GTEST_FLAG(print_time);
+    cout << GTEST_FLAG_GET(print_time);
     return;
   }
 
   if (strcmp(flag, "repeat") == 0) {
-    cout << GTEST_FLAG(repeat);
+    cout << GTEST_FLAG_GET(repeat);
     return;
   }
 
   if (strcmp(flag, "stack_trace_depth") == 0) {
-    cout << GTEST_FLAG(stack_trace_depth);
+    cout << GTEST_FLAG_GET(stack_trace_depth);
     return;
   }
 
   if (strcmp(flag, "throw_on_failure") == 0) {
-    cout << GTEST_FLAG(throw_on_failure);
+    cout << GTEST_FLAG_GET(throw_on_failure);
     return;
   }
 
diff --git a/googletest/googletest/test/googletest-failfast-unittest.py b/googletest/googletest/test/googletest-failfast-unittest.py
index 3aeb2dffeae42fc0338a1eda99cd4d435b79a7b3..1356d4f8b5b7fcb288e403f14ce5082bc5038a66 100644
--- a/googletest/googletest/test/googletest-failfast-unittest.py
+++ b/googletest/googletest/test/googletest-failfast-unittest.py
@@ -41,7 +41,7 @@ line flags.
 """
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Constants.
 
diff --git a/googletest/googletest/test/googletest-failfast-unittest_.cc b/googletest/googletest/test/googletest-failfast-unittest_.cc
index 0b2c951bc0083994b066c2d86ae92be32281c685..3bd05a8eb293259862fe7d137db70601ea1f63fd 100644
--- a/googletest/googletest/test/googletest-failfast-unittest_.cc
+++ b/googletest/googletest/test/googletest-failfast-unittest_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Unit test for Google Test test filters.
 //
 // A user can specify which test(s) in a Google Test program to run via
@@ -160,7 +159,7 @@ TEST(HasSkipTest, Test4) { FAIL() << "Expected failure."; }
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   ::testing::UnitTest::GetInstance()->listeners().Append(new MyTestListener());
   return RUN_ALL_TESTS();
diff --git a/googletest/googletest/test/googletest-filepath-test.cc b/googletest/googletest/test/googletest-filepath-test.cc
index aafad36f3fef449f46ba77db20ecc966b5720b77..5f0c9c2fb8bfbb3920a4ad07ece104af2c8dab1c 100644
--- a/googletest/googletest/test/googletest-filepath-test.cc
+++ b/googletest/googletest/test/googletest-filepath-test.cc
@@ -35,15 +35,17 @@
 // This file is #included from gtest-internal.h.
 // Do not #include this file anywhere else!
 
-#include "gtest/internal/gtest-filepath.h"
+#include <string>
+
 #include "gtest/gtest.h"
+#include "gtest/internal/gtest-filepath.h"
 #include "src/gtest-internal-inl.h"
 
 #if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>  // NOLINT
+#include <windows.h>  // NOLINT
 #elif GTEST_OS_WINDOWS
-# include <direct.h>  // NOLINT
-#endif  // GTEST_OS_WINDOWS_MOBILE
+#include <direct.h>  // NOLINT
+#endif               // GTEST_OS_WINDOWS_MOBILE
 
 namespace testing {
 namespace internal {
@@ -55,16 +57,16 @@ namespace {
 int remove(const char* path) {
   LPCWSTR wpath = String::AnsiToUtf16(path);
   int ret = DeleteFile(wpath) ? 0 : -1;
-  delete [] wpath;
+  delete[] wpath;
   return ret;
 }
 // Windows CE doesn't have the _rmdir C function.
 int _rmdir(const char* path) {
   FilePath filepath(path);
-  LPCWSTR wpath = String::AnsiToUtf16(
-      filepath.RemoveTrailingPathSeparator().c_str());
+  LPCWSTR wpath =
+      String::AnsiToUtf16(filepath.RemoveTrailingPathSeparator().c_str());
   int ret = RemoveDirectory(wpath) ? 0 : -1;
-  delete [] wpath;
+  delete[] wpath;
   return ret;
 }
 
@@ -78,18 +80,18 @@ TEST(GetCurrentDirTest, ReturnsCurrentDir) {
   const FilePath cwd = FilePath::GetCurrentDir();
   posix::ChDir(original_dir.c_str());
 
-# if GTEST_OS_WINDOWS || GTEST_OS_OS2
+#if GTEST_OS_WINDOWS || GTEST_OS_OS2
 
   // Skips the ":".
   const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
   ASSERT_TRUE(cwd_without_drive != NULL);
   EXPECT_STREQ(GTEST_PATH_SEP_, cwd_without_drive + 1);
 
-# else
+#else
 
   EXPECT_EQ(GTEST_PATH_SEP_, cwd.string());
 
-# endif
+#endif
 }
 
 #endif  // GTEST_OS_WINDOWS_MOBILE
@@ -112,33 +114,34 @@ TEST(RemoveDirectoryNameTest, WhenEmptyName) {
 
 // RemoveDirectoryName "afile" -> "afile"
 TEST(RemoveDirectoryNameTest, ButNoDirectory) {
-  EXPECT_EQ("afile",
-      FilePath("afile").RemoveDirectoryName().string());
+  EXPECT_EQ("afile", FilePath("afile").RemoveDirectoryName().string());
 }
 
 // RemoveDirectoryName "/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, RootFileShouldGiveFileName) {
   EXPECT_EQ("afile",
-      FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
+            FilePath(GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
 }
 
 // RemoveDirectoryName "adir/" -> ""
 TEST(RemoveDirectoryNameTest, WhereThereIsNoFileName) {
   EXPECT_EQ("",
-      FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().string());
+            FilePath("adir" GTEST_PATH_SEP_).RemoveDirectoryName().string());
 }
 
 // RemoveDirectoryName "adir/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, ShouldGiveFileName) {
-  EXPECT_EQ("afile",
+  EXPECT_EQ(
+      "afile",
       FilePath("adir" GTEST_PATH_SEP_ "afile").RemoveDirectoryName().string());
 }
 
 // RemoveDirectoryName "adir/subdir/afile" -> "afile"
 TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileName) {
   EXPECT_EQ("afile",
-      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
-      .RemoveDirectoryName().string());
+            FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
+                .RemoveDirectoryName()
+                .string());
 }
 
 #if GTEST_HAS_ALT_PATH_SEP_
@@ -182,7 +185,7 @@ TEST(RemoveFileNameTest, EmptyName) {
 // RemoveFileName "adir/" -> "adir/"
 TEST(RemoveFileNameTest, ButNoFile) {
   EXPECT_EQ("adir" GTEST_PATH_SEP_,
-      FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().string());
+            FilePath("adir" GTEST_PATH_SEP_).RemoveFileName().string());
 }
 
 // RemoveFileName "adir/afile" -> "adir/"
@@ -194,14 +197,15 @@ TEST(RemoveFileNameTest, GivesDirName) {
 // RemoveFileName "adir/subdir/afile" -> "adir/subdir/"
 TEST(RemoveFileNameTest, GivesDirAndSubDirName) {
   EXPECT_EQ("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_,
-      FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
-      .RemoveFileName().string());
+            FilePath("adir" GTEST_PATH_SEP_ "subdir" GTEST_PATH_SEP_ "afile")
+                .RemoveFileName()
+                .string());
 }
 
 // RemoveFileName "/afile" -> "/"
 TEST(RemoveFileNameTest, GivesRootDir) {
   EXPECT_EQ(GTEST_PATH_SEP_,
-      FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().string());
+            FilePath(GTEST_PATH_SEP_ "afile").RemoveFileName().string());
 }
 
 #if GTEST_HAS_ALT_PATH_SEP_
@@ -235,44 +239,43 @@ TEST(RemoveFileNameTest, GivesRootDirForAlternateSeparator) {
 #endif
 
 TEST(MakeFileNameTest, GenerateWhenNumberIsZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
-      0, "xml");
+  FilePath actual =
+      FilePath::MakeFileName(FilePath("foo"), FilePath("bar"), 0, "xml");
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameNumberGtZero) {
-  FilePath actual = FilePath::MakeFileName(FilePath("foo"), FilePath("bar"),
-      12, "xml");
+  FilePath actual =
+      FilePath::MakeFileName(FilePath("foo"), FilePath("bar"), 12, "xml");
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberIsZero) {
   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar"), 0, "xml");
+                                           FilePath("bar"), 0, "xml");
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
 }
 
 TEST(MakeFileNameTest, GenerateFileNameWithSlashNumberGtZero) {
   FilePath actual = FilePath::MakeFileName(FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar"), 12, "xml");
+                                           FilePath("bar"), 12, "xml");
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar_12.xml", actual.string());
 }
 
 TEST(MakeFileNameTest, GenerateWhenNumberIsZeroAndDirIsEmpty) {
-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
-      0, "xml");
+  FilePath actual =
+      FilePath::MakeFileName(FilePath(""), FilePath("bar"), 0, "xml");
   EXPECT_EQ("bar.xml", actual.string());
 }
 
 TEST(MakeFileNameTest, GenerateWhenNumberIsNotZeroAndDirIsEmpty) {
-  FilePath actual = FilePath::MakeFileName(FilePath(""), FilePath("bar"),
-      14, "xml");
+  FilePath actual =
+      FilePath::MakeFileName(FilePath(""), FilePath("bar"), 14, "xml");
   EXPECT_EQ("bar_14.xml", actual.string());
 }
 
 TEST(ConcatPathsTest, WorksWhenDirDoesNotEndWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
-                                          FilePath("bar.xml"));
+  FilePath actual = FilePath::ConcatPaths(FilePath("foo"), FilePath("bar.xml"));
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar.xml", actual.string());
 }
 
@@ -283,8 +286,7 @@ TEST(ConcatPathsTest, WorksWhenPath1EndsWithPathSep) {
 }
 
 TEST(ConcatPathsTest, Path1BeingEmpty) {
-  FilePath actual = FilePath::ConcatPaths(FilePath(""),
-                                          FilePath("bar.xml"));
+  FilePath actual = FilePath::ConcatPaths(FilePath(""), FilePath("bar.xml"));
   EXPECT_EQ("bar.xml", actual.string());
 }
 
@@ -294,8 +296,7 @@ TEST(ConcatPathsTest, Path2BeingEmpty) {
 }
 
 TEST(ConcatPathsTest, BothPathBeingEmpty) {
-  FilePath actual = FilePath::ConcatPaths(FilePath(""),
-                                          FilePath(""));
+  FilePath actual = FilePath::ConcatPaths(FilePath(""), FilePath(""));
   EXPECT_EQ("", actual.string());
 }
 
@@ -307,16 +308,16 @@ TEST(ConcatPathsTest, Path1ContainsPathSep) {
 }
 
 TEST(ConcatPathsTest, Path2ContainsPathSep) {
-  FilePath actual = FilePath::ConcatPaths(
-      FilePath("foo" GTEST_PATH_SEP_),
-      FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
+  FilePath actual =
+      FilePath::ConcatPaths(FilePath("foo" GTEST_PATH_SEP_),
+                            FilePath("bar" GTEST_PATH_SEP_ "bar.xml"));
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_ "bar.xml",
             actual.string());
 }
 
 TEST(ConcatPathsTest, Path2EndsWithPathSep) {
-  FilePath actual = FilePath::ConcatPaths(FilePath("foo"),
-                                          FilePath("bar" GTEST_PATH_SEP_));
+  FilePath actual =
+      FilePath::ConcatPaths(FilePath("foo"), FilePath("bar" GTEST_PATH_SEP_));
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_, actual.string());
 }
 
@@ -332,7 +333,8 @@ TEST(RemoveTrailingPathSeparatorTest, FileNoSlashString) {
 
 // RemoveTrailingPathSeparator "foo/" -> "foo"
 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
-  EXPECT_EQ("foo",
+  EXPECT_EQ(
+      "foo",
       FilePath("foo" GTEST_PATH_SEP_).RemoveTrailingPathSeparator().string());
 #if GTEST_HAS_ALT_PATH_SEP_
   EXPECT_EQ("foo", FilePath("foo/").RemoveTrailingPathSeparator().string());
@@ -343,18 +345,19 @@ TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveTrailingSeparator) {
 TEST(RemoveTrailingPathSeparatorTest, ShouldRemoveLastSeparator) {
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
             FilePath("foo" GTEST_PATH_SEP_ "bar" GTEST_PATH_SEP_)
-                .RemoveTrailingPathSeparator().string());
+                .RemoveTrailingPathSeparator()
+                .string());
 }
 
 // RemoveTrailingPathSeparator "foo/bar" -> "foo/bar"
 TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ "bar")
-                .RemoveTrailingPathSeparator().string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar", FilePath("foo" GTEST_PATH_SEP_ "bar")
+                                             .RemoveTrailingPathSeparator()
+                                             .string());
 }
 
 TEST(DirectoryTest, RootDirectoryExists) {
-#if GTEST_OS_WINDOWS  // We are on Windows.
+#if GTEST_OS_WINDOWS              // We are on Windows.
   char current_drive[_MAX_PATH];  // NOLINT
   current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
   current_drive[1] = ':';
@@ -393,12 +396,12 @@ TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
 
 TEST(DirectoryTest, CurrentDirectoryExists) {
 #if GTEST_OS_WINDOWS  // We are on Windows.
-# ifndef _WIN32_CE  // Windows CE doesn't have a current directory.
+#ifndef _WIN32_CE     // Windows CE doesn't have a current directory.
 
   EXPECT_TRUE(FilePath(".").DirectoryExists());
   EXPECT_TRUE(FilePath(".\\").DirectoryExists());
 
-# endif  // _WIN32_CE
+#endif  // _WIN32_CE
 #else
   EXPECT_TRUE(FilePath(".").DirectoryExists());
   EXPECT_TRUE(FilePath("./").DirectoryExists());
@@ -406,34 +409,40 @@ TEST(DirectoryTest, CurrentDirectoryExists) {
 }
 
 // "foo/bar" == foo//bar" == "foo///bar"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsInMidstring) {
+TEST(NormalizeTest, MultipleConsecutiveSeparatorsInMidstring) {
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
             FilePath("foo" GTEST_PATH_SEP_ "bar").string());
   EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
             FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_ "bar",
-            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_
-                     GTEST_PATH_SEP_ "bar").string());
+  EXPECT_EQ(
+      "foo" GTEST_PATH_SEP_ "bar",
+      FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar")
+          .string());
 }
 
 // "/bar" == //bar" == "///bar"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringStart) {
-  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ "bar").string());
-  EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringStart) {
+  EXPECT_EQ(GTEST_PATH_SEP_ "bar", FilePath(GTEST_PATH_SEP_ "bar").string());
+#if GTEST_OS_WINDOWS
+  EXPECT_EQ(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar",
+            FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+#else
   EXPECT_EQ(GTEST_PATH_SEP_ "bar",
-    FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+            FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
+#endif
+  EXPECT_EQ(
+      GTEST_PATH_SEP_ "bar",
+      FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
 }
 
 // "foo/" == foo//" == "foo///"
-TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
+TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringEnd) {
+  EXPECT_EQ("foo" GTEST_PATH_SEP_, FilePath("foo" GTEST_PATH_SEP_).string());
   EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_).string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-    FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
+            FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
+  EXPECT_EQ(
+      "foo" GTEST_PATH_SEP_,
+      FilePath("foo" GTEST_PATH_SEP_ GTEST_PATH_SEP_ GTEST_PATH_SEP_).string());
 }
 
 #if GTEST_HAS_ALT_PATH_SEP_
@@ -442,12 +451,10 @@ TEST(NormalizeTest, MultipleConsecutiveSepaparatorsAtStringEnd) {
 // regardless of their combination (e.g. "foo\" =="foo/\" ==
 // "foo\\/").
 TEST(NormalizeTest, MixAlternateSeparatorAtStringEnd) {
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-            FilePath("foo/").string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_, FilePath("foo/").string());
   EXPECT_EQ("foo" GTEST_PATH_SEP_,
             FilePath("foo" GTEST_PATH_SEP_ "/").string());
-  EXPECT_EQ("foo" GTEST_PATH_SEP_,
-            FilePath("foo//" GTEST_PATH_SEP_).string());
+  EXPECT_EQ("foo" GTEST_PATH_SEP_, FilePath("foo//" GTEST_PATH_SEP_).string());
 }
 
 #endif
@@ -478,15 +485,15 @@ TEST(AssignmentOperatorTest, ConstAssignedToNonConst) {
 class DirectoryCreationTest : public Test {
  protected:
   void SetUp() override {
-    testdata_path_.Set(FilePath(
-        TempDir() + GetCurrentExecutableName().string() +
-        "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_));
+    testdata_path_.Set(
+        FilePath(TempDir() + GetCurrentExecutableName().string() +
+                 "_directory_creation" GTEST_PATH_SEP_ "test" GTEST_PATH_SEP_));
     testdata_file_.Set(testdata_path_.RemoveTrailingPathSeparator());
 
-    unique_file0_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
-        0, "txt"));
-    unique_file1_.Set(FilePath::MakeFileName(testdata_path_, FilePath("unique"),
-        1, "txt"));
+    unique_file0_.Set(
+        FilePath::MakeFileName(testdata_path_, FilePath("unique"), 0, "txt"));
+    unique_file1_.Set(
+        FilePath::MakeFileName(testdata_path_, FilePath("unique"), 1, "txt"));
 
     remove(testdata_file_.c_str());
     remove(unique_file0_.c_str());
@@ -512,8 +519,8 @@ class DirectoryCreationTest : public Test {
   // a directory named 'test' from a file named 'test'. Example names:
   FilePath testdata_path_;  // "/tmp/directory_creation/test/"
   FilePath testdata_file_;  // "/tmp/directory_creation/test"
-  FilePath unique_file0_;  // "/tmp/directory_creation/test/unique.txt"
-  FilePath unique_file1_;  // "/tmp/directory_creation/test/unique_1.txt"
+  FilePath unique_file0_;   // "/tmp/directory_creation/test/unique.txt"
+  FilePath unique_file1_;   // "/tmp/directory_creation/test/unique_1.txt"
 };
 
 TEST_F(DirectoryCreationTest, CreateDirectoriesRecursively) {
@@ -530,8 +537,8 @@ TEST_F(DirectoryCreationTest, CreateDirectoriesForAlreadyExistingPath) {
 }
 
 TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
-  FilePath file_path(FilePath::GenerateUniqueFileName(testdata_path_,
-      FilePath("unique"), "txt"));
+  FilePath file_path(FilePath::GenerateUniqueFileName(
+      testdata_path_, FilePath("unique"), "txt"));
   EXPECT_EQ(unique_file0_.string(), file_path.string());
   EXPECT_FALSE(file_path.FileOrDirectoryExists());  // file not there
 
@@ -540,8 +547,8 @@ TEST_F(DirectoryCreationTest, CreateDirectoriesAndUniqueFilename) {
   CreateTextFile(file_path.c_str());
   EXPECT_TRUE(file_path.FileOrDirectoryExists());
 
-  FilePath file_path2(FilePath::GenerateUniqueFileName(testdata_path_,
-      FilePath("unique"), "txt"));
+  FilePath file_path2(FilePath::GenerateUniqueFileName(
+      testdata_path_, FilePath("unique"), "txt"));
   EXPECT_EQ(unique_file1_.string(), file_path2.string());
   EXPECT_FALSE(file_path2.FileOrDirectoryExists());  // file not there
   CreateTextFile(file_path2.c_str());
@@ -614,14 +621,19 @@ TEST(FilePathTest, IsAbsolutePath) {
   EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
   EXPECT_FALSE(FilePath("").IsAbsolutePath());
 #if GTEST_OS_WINDOWS
-  EXPECT_TRUE(FilePath("c:\\" GTEST_PATH_SEP_ "is_not"
-                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_TRUE(
+      FilePath("c:\\" GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
+          .IsAbsolutePath());
   EXPECT_FALSE(FilePath("c:foo" GTEST_PATH_SEP_ "bar").IsAbsolutePath());
-  EXPECT_TRUE(FilePath("c:/" GTEST_PATH_SEP_ "is_not"
-                       GTEST_PATH_SEP_ "relative").IsAbsolutePath());
+  EXPECT_TRUE(
+      FilePath("c:/" GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
+          .IsAbsolutePath());
+  EXPECT_TRUE(FilePath("d:/Windows").IsAbsolutePath());
+  EXPECT_TRUE(FilePath("\\\\Host\\Share").IsAbsolutePath());
+  EXPECT_TRUE(FilePath("\\\\Host\\Share\\Folder").IsAbsolutePath());
 #else
   EXPECT_TRUE(FilePath(GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
-              .IsAbsolutePath());
+                  .IsAbsolutePath());
 #endif  // GTEST_OS_WINDOWS
 }
 
@@ -635,6 +647,16 @@ TEST(FilePathTest, IsRootDirectory) {
   EXPECT_FALSE(FilePath("b:a").IsRootDirectory());
   EXPECT_FALSE(FilePath("8:/").IsRootDirectory());
   EXPECT_FALSE(FilePath("c|/").IsRootDirectory());
+  EXPECT_TRUE(FilePath("c:/").IsRootDirectory());
+  EXPECT_FALSE(FilePath("d:/Windows").IsRootDirectory());
+
+  // This is for backward compatibility, since callers (even in this library)
+  // have assumed IsRootDirectory() implies a trailing directory separator.
+  EXPECT_FALSE(FilePath("\\\\Host\\Share").IsRootDirectory());
+
+  EXPECT_TRUE(FilePath("\\\\Host\\Share\\").IsRootDirectory());
+  EXPECT_FALSE(FilePath("\\\\Host\\Share\\.").IsRootDirectory());
+  EXPECT_FALSE(FilePath("\\\\Host\\Share\\C$\\").IsRootDirectory());
 #else
   EXPECT_TRUE(FilePath("/").IsRootDirectory());
   EXPECT_TRUE(FilePath("//").IsRootDirectory());
diff --git a/googletest/googletest/test/googletest-filter-unittest.py b/googletest/googletest/test/googletest-filter-unittest.py
index 6b32f2d21997189a3cd9eaf313d470bdd84fcc11..2c4a1b18a113dcd690a09b3fb4d65f9db183fea0 100644
--- a/googletest/googletest/test/googletest-filter-unittest.py
+++ b/googletest/googletest/test/googletest-filter-unittest.py
@@ -47,7 +47,7 @@ try:
 except ImportError:
   pass
 import sys
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Constants.
 
@@ -113,6 +113,9 @@ TEST_CASE_REGEX = re.compile(r'^\[\-+\] \d+ tests? from (\w+(/\w+)?)')
 # Regex for parsing test names from Google Test's output.
 TEST_REGEX = re.compile(r'^\[\s*RUN\s*\].*\.(\w+(/\w+)?)')
 
+# Regex for parsing disabled banner from Google Test's output
+DISABLED_BANNER_REGEX = re.compile(r'^\[\s*DISABLED\s*\] (.*)')
+
 # The command line flag to tell Google Test to output the list of tests it
 # will run.
 LIST_TESTS_FLAG = '--gtest_list_tests'
@@ -206,6 +209,17 @@ def RunAndExtractTestList(args = None):
   return (tests_run, p.exit_code)
 
 
+def RunAndExtractDisabledBannerList(args=None):
+  """Runs the test program and returns tests that printed a disabled banner."""
+  p = gtest_test_utils.Subprocess([COMMAND] + (args or []), env=environ)
+  banners_printed = []
+  for line in p.output.split('\n'):
+    match = DISABLED_BANNER_REGEX.match(line)
+    if match is not None:
+      banners_printed.append(match.group(1))
+  return banners_printed
+
+
 def InvokeWithModifiedEnv(extra_env, function, *args, **kwargs):
   """Runs the given function and arguments in a modified environment."""
   try:
@@ -613,6 +627,23 @@ class GTestFilterUnitTest(gtest_test_utils.TestCase):
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 
+  def testDisabledBanner(self):
+    """Tests that the disabled banner prints only tests that match filter."""
+    make_filter = lambda s: ['--%s=%s' % (FILTER_FLAG, s)]
+
+    banners = RunAndExtractDisabledBannerList(make_filter('*'))
+    self.AssertSetEqual(banners, [
+        'BarTest.DISABLED_TestFour', 'BarTest.DISABLED_TestFive',
+        'BazTest.DISABLED_TestC'
+    ])
+
+    banners = RunAndExtractDisabledBannerList(make_filter('Bar*'))
+    self.AssertSetEqual(
+        banners, ['BarTest.DISABLED_TestFour', 'BarTest.DISABLED_TestFive'])
+
+    banners = RunAndExtractDisabledBannerList(make_filter('*-Bar*'))
+    self.AssertSetEqual(banners, ['BazTest.DISABLED_TestC'])
+
   if SUPPORTS_DEATH_TESTS:
     def testShardingWorksWithDeathTests(self):
       """Tests integration with death tests and sharding."""
diff --git a/googletest/googletest/test/googletest-filter-unittest_.cc b/googletest/googletest/test/googletest-filter-unittest_.cc
index d30ec9c78b565d8e8180173d8fc4e8aefad88aea..bc7aa59408371334fdbb7593dde95f2802cc1955 100644
--- a/googletest/googletest/test/googletest-filter-unittest_.cc
+++ b/googletest/googletest/test/googletest-filter-unittest_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Unit test for Google Test test filters.
 //
 // A user can specify which test(s) in a Google Test program to run via
@@ -43,87 +42,57 @@ namespace {
 
 // Test case FooTest.
 
-class FooTest : public testing::Test {
-};
+class FooTest : public testing::Test {};
 
-TEST_F(FooTest, Abc) {
-}
+TEST_F(FooTest, Abc) {}
 
-TEST_F(FooTest, Xyz) {
-  FAIL() << "Expected failure.";
-}
+TEST_F(FooTest, Xyz) { FAIL() << "Expected failure."; }
 
 // Test case BarTest.
 
-TEST(BarTest, TestOne) {
-}
+TEST(BarTest, TestOne) {}
 
-TEST(BarTest, TestTwo) {
-}
+TEST(BarTest, TestTwo) {}
 
-TEST(BarTest, TestThree) {
-}
+TEST(BarTest, TestThree) {}
 
-TEST(BarTest, DISABLED_TestFour) {
-  FAIL() << "Expected failure.";
-}
+TEST(BarTest, DISABLED_TestFour) { FAIL() << "Expected failure."; }
 
-TEST(BarTest, DISABLED_TestFive) {
-  FAIL() << "Expected failure.";
-}
+TEST(BarTest, DISABLED_TestFive) { FAIL() << "Expected failure."; }
 
 // Test case BazTest.
 
-TEST(BazTest, TestOne) {
-  FAIL() << "Expected failure.";
-}
+TEST(BazTest, TestOne) { FAIL() << "Expected failure."; }
 
-TEST(BazTest, TestA) {
-}
+TEST(BazTest, TestA) {}
 
-TEST(BazTest, TestB) {
-}
+TEST(BazTest, TestB) {}
 
-TEST(BazTest, DISABLED_TestC) {
-  FAIL() << "Expected failure.";
-}
+TEST(BazTest, DISABLED_TestC) { FAIL() << "Expected failure."; }
 
 // Test case HasDeathTest
 
-TEST(HasDeathTest, Test1) {
-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
-}
+TEST(HasDeathTest, Test1) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
 
 // We need at least two death tests to make sure that the all death tests
 // aren't on the first shard.
-TEST(HasDeathTest, Test2) {
-  EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*");
-}
+TEST(HasDeathTest, Test2) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
 
 // Test case FoobarTest
 
-TEST(DISABLED_FoobarTest, Test1) {
-  FAIL() << "Expected failure.";
-}
+TEST(DISABLED_FoobarTest, Test1) { FAIL() << "Expected failure."; }
 
-TEST(DISABLED_FoobarTest, DISABLED_Test2) {
-  FAIL() << "Expected failure.";
-}
+TEST(DISABLED_FoobarTest, DISABLED_Test2) { FAIL() << "Expected failure."; }
 
 // Test case FoobarbazTest
 
-TEST(DISABLED_FoobarbazTest, TestA) {
-  FAIL() << "Expected failure.";
-}
+TEST(DISABLED_FoobarbazTest, TestA) { FAIL() << "Expected failure."; }
 
-class ParamTest : public testing::TestWithParam<int> {
-};
+class ParamTest : public testing::TestWithParam<int> {};
 
-TEST_P(ParamTest, TestX) {
-}
+TEST_P(ParamTest, TestX) {}
 
-TEST_P(ParamTest, TestY) {
-}
+TEST_P(ParamTest, TestY) {}
 
 INSTANTIATE_TEST_SUITE_P(SeqP, ParamTest, testing::Values(1, 2));
 INSTANTIATE_TEST_SUITE_P(SeqQ, ParamTest, testing::Values(5, 6));
diff --git a/googletest/googletest/test/googletest-global-environment-unittest.py b/googletest/googletest/test/googletest-global-environment-unittest.py
index 32ba628535ce32dd44faf1d5fc47e8a2fbf25392..265793442f97758b28fb2732cced44575a185fd0 100644
--- a/googletest/googletest/test/googletest-global-environment-unittest.py
+++ b/googletest/googletest/test/googletest-global-environment-unittest.py
@@ -35,16 +35,17 @@ This script tests such functionality by invoking
 googletest-global-environment-unittest_ (a program written with Google Test).
 """
 
-import gtest_test_utils
+import re
+from googletest.test import gtest_test_utils
 
 
-def RunAndReturnOutput():
+def RunAndReturnOutput(args=None):
   """Runs the test program and returns its output."""
 
   return gtest_test_utils.Subprocess([
       gtest_test_utils.GetTestExecutablePath(
           'googletest-global-environment-unittest_')
-  ]).output
+  ] + (args or [])).output
 
 
 class GTestGlobalEnvironmentUnitTest(gtest_test_utils.TestCase):
@@ -67,6 +68,63 @@ class GTestGlobalEnvironmentUnitTest(gtest_test_utils.TestCase):
     # The test case shouldn't have been run.
     self.assertNotIn('Unexpected call', txt)
 
+  def testEnvironmentSetUpAndTornDownForEachRepeat(self):
+    """Tests the behavior of test environments and gtest_repeat."""
+
+    # When --gtest_recreate_environments_when_repeating is true, the global test
+    # environment should be set up and torn down for each iteration.
+    txt = RunAndReturnOutput([
+        '--gtest_repeat=2',
+        '--gtest_recreate_environments_when_repeating=true',
+    ])
+
+    expected_pattern = ('(.|\n)*'
+                        r'Repeating all tests \(iteration 1\)'
+                        '(.|\n)*'
+                        'Global test environment set-up.'
+                        '(.|\n)*'
+                        'SomeTest.DoesFoo'
+                        '(.|\n)*'
+                        'Global test environment tear-down'
+                        '(.|\n)*'
+                        r'Repeating all tests \(iteration 2\)'
+                        '(.|\n)*'
+                        'Global test environment set-up.'
+                        '(.|\n)*'
+                        'SomeTest.DoesFoo'
+                        '(.|\n)*'
+                        'Global test environment tear-down'
+                        '(.|\n)*')
+    self.assertRegex(txt, expected_pattern)
+
+  def testEnvironmentSetUpAndTornDownOnce(self):
+    """Tests environment and --gtest_recreate_environments_when_repeating."""
+
+    # By default the environment should only be set up and torn down once, at
+    # the start and end of the test respectively.
+    txt = RunAndReturnOutput([
+        '--gtest_repeat=2',
+    ])
+
+    expected_pattern = ('(.|\n)*'
+                        r'Repeating all tests \(iteration 1\)'
+                        '(.|\n)*'
+                        'Global test environment set-up.'
+                        '(.|\n)*'
+                        'SomeTest.DoesFoo'
+                        '(.|\n)*'
+                        r'Repeating all tests \(iteration 2\)'
+                        '(.|\n)*'
+                        'SomeTest.DoesFoo'
+                        '(.|\n)*'
+                        'Global test environment tear-down'
+                        '(.|\n)*')
+    self.assertRegex(txt, expected_pattern)
+
+    self.assertEqual(len(re.findall('Global test environment set-up', txt)), 1)
+    self.assertEqual(
+        len(re.findall('Global test environment tear-down', txt)), 1)
+
 
 if __name__ == '__main__':
   gtest_test_utils.Main()
diff --git a/googletest/googletest/test/googletest-json-outfiles-test.py b/googletest/googletest/test/googletest-json-outfiles-test.py
index 8ef47b8f97463c2e3ad44225479d3bc06338792c..179283b85334f04a2cc99c1e6c082a6702627cac 100644
--- a/googletest/googletest/test/googletest-json-outfiles-test.py
+++ b/googletest/googletest/test/googletest-json-outfiles-test.py
@@ -32,8 +32,8 @@
 
 import json
 import os
-import gtest_json_test_utils
-import gtest_test_utils
+from googletest.test import gtest_json_test_utils
+from googletest.test import gtest_test_utils
 
 GTEST_OUTPUT_SUBDIR = 'json_outfiles'
 GTEST_OUTPUT_1_TEST = 'gtest_xml_outfile1_test_'
@@ -71,6 +71,8 @@ EXPECTED_1 = {
             u'*',
         u'testsuite': [{
             u'name': u'TestSomeProperties',
+            u'file': u'gtest_xml_outfile1_test_.cc',
+            u'line': 41,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -115,6 +117,8 @@ EXPECTED_2 = {
             u'*',
         u'testsuite': [{
             u'name': u'TestSomeProperties',
+            u'file': u'gtest_xml_outfile2_test_.cc',
+            u'line': 41,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'timestamp': u'*',
diff --git a/googletest/googletest/test/googletest-json-output-unittest.py b/googletest/googletest/test/googletest-json-output-unittest.py
index 41c85651449984a7b1418db2ed58b51fd36a0559..e0fbe465092195c5e497ea4c56b1a1289faa5970 100644
--- a/googletest/googletest/test/googletest-json-output-unittest.py
+++ b/googletest/googletest/test/googletest-json-output-unittest.py
@@ -37,8 +37,8 @@ import os
 import re
 import sys
 
-import gtest_json_test_utils
-import gtest_test_utils
+from googletest.test import gtest_json_test_utils
+from googletest.test import gtest_test_utils
 
 GTEST_FILTER_FLAG = '--gtest_filter'
 GTEST_LIST_TESTS_FLAG = '--gtest_list_tests'
@@ -90,6 +90,8 @@ EXPECTED_NON_EMPTY = {
             u'*',
         u'testsuite': [{
             u'name': u'Succeeds',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 51,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -114,6 +116,10 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name':
                 u'Fails',
+            u'file':
+                u'gtest_xml_output_unittest_.cc',
+            u'line':
+                59,
             u'status':
                 u'RUN',
             u'result':
@@ -148,6 +154,8 @@ EXPECTED_NON_EMPTY = {
             u'*',
         u'testsuite': [{
             u'name': u'DISABLED_test_not_run',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 66,
             u'status': u'NOTRUN',
             u'result': u'SUPPRESSED',
             u'time': u'*',
@@ -171,6 +179,8 @@ EXPECTED_NON_EMPTY = {
             u'*',
         u'testsuite': [{
             u'name': u'Skipped',
+            u'file': 'gtest_xml_output_unittest_.cc',
+            u'line': 73,
             u'status': u'RUN',
             u'result': u'SKIPPED',
             u'time': u'*',
@@ -178,6 +188,8 @@ EXPECTED_NON_EMPTY = {
             u'classname': u'SkippedTest'
         }, {
             u'name': u'SkippedWithMessage',
+            u'file': 'gtest_xml_output_unittest_.cc',
+            u'line': 77,
             u'status': u'RUN',
             u'result': u'SKIPPED',
             u'time': u'*',
@@ -186,6 +198,10 @@ EXPECTED_NON_EMPTY = {
         }, {
             u'name':
                 u'SkippedAfterFailure',
+            u'file':
+                'gtest_xml_output_unittest_.cc',
+            u'line':
+                81,
             u'status':
                 u'RUN',
             u'result':
@@ -220,6 +236,8 @@ EXPECTED_NON_EMPTY = {
             u'*',
         u'testsuite': [{
             u'name': u'Succeeds',
+            u'file': 'gtest_xml_output_unittest_.cc',
+            u'line': 86,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -228,6 +246,10 @@ EXPECTED_NON_EMPTY = {
         }, {
             u'name':
                 u'Fails',
+            u'file':
+                u'gtest_xml_output_unittest_.cc',
+            u'line':
+                91,
             u'status':
                 u'RUN',
             u'result':
@@ -251,6 +273,8 @@ EXPECTED_NON_EMPTY = {
             }]
         }, {
             u'name': u'DISABLED_test',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 96,
             u'status': u'NOTRUN',
             u'result': u'SUPPRESSED',
             u'time': u'*',
@@ -275,6 +299,10 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name':
                 u'OutputsCData',
+            u'file':
+                u'gtest_xml_output_unittest_.cc',
+            u'line':
+                100,
             u'status':
                 u'RUN',
             u'result':
@@ -311,6 +339,10 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name':
                 u'InvalidCharactersInMessage',
+            u'file':
+                u'gtest_xml_output_unittest_.cc',
+            u'line':
+                107,
             u'status':
                 u'RUN',
             u'result':
@@ -349,6 +381,8 @@ EXPECTED_NON_EMPTY = {
             u'aye',
         u'testsuite': [{
             u'name': u'OneProperty',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 119,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -357,6 +391,8 @@ EXPECTED_NON_EMPTY = {
             u'key_1': u'1'
         }, {
             u'name': u'IntValuedProperty',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 123,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -365,6 +401,8 @@ EXPECTED_NON_EMPTY = {
             u'key_int': u'1'
         }, {
             u'name': u'ThreeProperties',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 127,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -375,6 +413,8 @@ EXPECTED_NON_EMPTY = {
             u'key_3': u'3'
         }, {
             u'name': u'TwoValuesForOneKeyUsesLastValue',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 133,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -399,6 +439,8 @@ EXPECTED_NON_EMPTY = {
             u'*',
         u'testsuite': [{
             u'name': u'RecordProperty',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 138,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -407,6 +449,8 @@ EXPECTED_NON_EMPTY = {
             u'key': u'1'
         }, {
             u'name': u'ExternalUtilityThatCallsRecordIntValuedProperty',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 151,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -415,6 +459,8 @@ EXPECTED_NON_EMPTY = {
             u'key_for_utility_int': u'1'
         }, {
             u'name': u'ExternalUtilityThatCallsRecordStringValuedProperty',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 155,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -440,6 +486,8 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name': u'HasTypeParamAttribute',
             u'type_param': u'int',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 171,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -464,6 +512,8 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name': u'HasTypeParamAttribute',
             u'type_param': u'long',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 171,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -488,6 +538,8 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name': u'HasTypeParamAttribute',
             u'type_param': u'int',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 178,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -512,6 +564,8 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name': u'HasTypeParamAttribute',
             u'type_param': u'long',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 178,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -536,6 +590,8 @@ EXPECTED_NON_EMPTY = {
         u'testsuite': [{
             u'name': u'HasValueParamAttribute/0',
             u'value_param': u'33',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 162,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -544,6 +600,8 @@ EXPECTED_NON_EMPTY = {
         }, {
             u'name': u'HasValueParamAttribute/1',
             u'value_param': u'42',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 162,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -552,6 +610,8 @@ EXPECTED_NON_EMPTY = {
         }, {
             u'name': u'AnotherTestThatHasValueParamAttribute/0',
             u'value_param': u'33',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 163,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -560,6 +620,8 @@ EXPECTED_NON_EMPTY = {
         }, {
             u'name': u'AnotherTestThatHasValueParamAttribute/1',
             u'value_param': u'42',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 163,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
@@ -603,6 +665,8 @@ EXPECTED_FILTERED = {
             u'*',
         u'testsuite': [{
             u'name': u'Succeeds',
+            u'file': u'gtest_xml_output_unittest_.cc',
+            u'line': 51,
             u'status': u'RUN',
             u'result': u'COMPLETED',
             u'time': u'*',
diff --git a/googletest/googletest/test/googletest-list-tests-unittest.py b/googletest/googletest/test/googletest-list-tests-unittest.py
index 81423a339e8fd28aa2b4253013b3c23ce3533749..9d56883d741d80d7bad8301e20620fca6b156002 100644
--- a/googletest/googletest/test/googletest-list-tests-unittest.py
+++ b/googletest/googletest/test/googletest-list-tests-unittest.py
@@ -38,7 +38,7 @@ Google Test) the command line flags.
 """
 
 import re
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Constants.
 
diff --git a/googletest/googletest/test/googletest-list-tests-unittest_.cc b/googletest/googletest/test/googletest-list-tests-unittest_.cc
index 493c6f00464a90d635d8df096bffec5173e6e44d..5577e8961cdc2b3190bb11aada789ec9376b11be 100644
--- a/googletest/googletest/test/googletest-list-tests-unittest_.cc
+++ b/googletest/googletest/test/googletest-list-tests-unittest_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Unit test for Google Test's --gtest_list_tests flag.
 //
 // A user can ask Google Test to list all tests that will run
@@ -40,38 +39,27 @@
 #include "gtest/gtest.h"
 
 // Several different test cases and tests that will be listed.
-TEST(Foo, Bar1) {
-}
+TEST(Foo, Bar1) {}
 
-TEST(Foo, Bar2) {
-}
+TEST(Foo, Bar2) {}
 
-TEST(Foo, DISABLED_Bar3) {
-}
+TEST(Foo, DISABLED_Bar3) {}
 
-TEST(Abc, Xyz) {
-}
+TEST(Abc, Xyz) {}
 
-TEST(Abc, Def) {
-}
+TEST(Abc, Def) {}
 
-TEST(FooBar, Baz) {
-}
+TEST(FooBar, Baz) {}
 
-class FooTest : public testing::Test {
-};
+class FooTest : public testing::Test {};
 
-TEST_F(FooTest, Test1) {
-}
+TEST_F(FooTest, Test1) {}
 
-TEST_F(FooTest, DISABLED_Test2) {
-}
+TEST_F(FooTest, DISABLED_Test2) {}
 
-TEST_F(FooTest, Test3) {
-}
+TEST_F(FooTest, Test3) {}
 
-TEST(FooDeathTest, Test1) {
-}
+TEST(FooDeathTest, Test1) {}
 
 // A group of value-parameterized tests.
 
@@ -86,70 +74,66 @@ class MyType {
 };
 
 // Teaches Google Test how to print a MyType.
-void PrintTo(const MyType& x, std::ostream* os) {
-  *os << x.value();
-}
+void PrintTo(const MyType& x, std::ostream* os) { *os << x.value(); }
 
-class ValueParamTest : public testing::TestWithParam<MyType> {
-};
+class ValueParamTest : public testing::TestWithParam<MyType> {};
 
-TEST_P(ValueParamTest, TestA) {
-}
+TEST_P(ValueParamTest, TestA) {}
 
-TEST_P(ValueParamTest, TestB) {
-}
+TEST_P(ValueParamTest, TestB) {}
 
 INSTANTIATE_TEST_SUITE_P(
     MyInstantiation, ValueParamTest,
-    testing::Values(MyType("one line"),
-                    MyType("two\nlines"),
-                    MyType("a very\nloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong line")));  // NOLINT
+    testing::Values(
+        MyType("one line"), MyType("two\nlines"),
+        MyType("a "
+               "very\nloooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
+               "ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
+               "ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
+               "ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"
+               "ooooong line")));  // NOLINT
 
 // A group of typed tests.
 
 // A deliberately long type name for testing the line-truncating
 // behavior when printing a type parameter.
-class VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName {  // NOLINT
+class
+    VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName {  // NOLINT
 };
 
 template <typename T>
-class TypedTest : public testing::Test {
-};
+class TypedTest : public testing::Test {};
 
 template <typename T, int kSize>
-class MyArray {
-};
+class MyArray {};
 
-typedef testing::Types<VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName,  // NOLINT
-                       int*, MyArray<bool, 42> > MyTypes;
+typedef testing::Types<
+    VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName,  // NOLINT
+    int*, MyArray<bool, 42> >
+    MyTypes;
 
 TYPED_TEST_SUITE(TypedTest, MyTypes);
 
-TYPED_TEST(TypedTest, TestA) {
-}
+TYPED_TEST(TypedTest, TestA) {}
 
-TYPED_TEST(TypedTest, TestB) {
-}
+TYPED_TEST(TypedTest, TestB) {}
 
 // A group of type-parameterized tests.
 
 template <typename T>
-class TypeParamTest : public testing::Test {
-};
+class TypeParamTest : public testing::Test {};
 
 TYPED_TEST_SUITE_P(TypeParamTest);
 
-TYPED_TEST_P(TypeParamTest, TestA) {
-}
+TYPED_TEST_P(TypeParamTest, TestA) {}
 
-TYPED_TEST_P(TypeParamTest, TestB) {
-}
+TYPED_TEST_P(TypeParamTest, TestB) {}
 
 REGISTER_TYPED_TEST_SUITE_P(TypeParamTest, TestA, TestB);
 
 INSTANTIATE_TYPED_TEST_SUITE_P(My, TypeParamTest, MyTypes);
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
 
   return RUN_ALL_TESTS();
diff --git a/googletest/googletest/test/googletest-listener-test.cc b/googletest/googletest/test/googletest-listener-test.cc
index 10457afe39a7dbd1fa0f733928678728dcd1b955..89d01b37ff403107e53c7e455a0d4cce3488c0de 100644
--- a/googletest/googletest/test/googletest-listener-test.cc
+++ b/googletest/googletest/test/googletest-listener-test.cc
@@ -41,10 +41,10 @@ using ::testing::AddGlobalTestEnvironment;
 using ::testing::Environment;
 using ::testing::InitGoogleTest;
 using ::testing::Test;
-using ::testing::TestSuite;
 using ::testing::TestEventListener;
 using ::testing::TestInfo;
 using ::testing::TestPartResult;
+using ::testing::TestSuite;
 using ::testing::UnitTest;
 
 // Used by tests to register their events.
@@ -65,8 +65,8 @@ class EventRecordingListener : public TestEventListener {
   void OnTestIterationStart(const UnitTest& /*unit_test*/,
                             int iteration) override {
     Message message;
-    message << GetFullMethodName("OnTestIterationStart")
-            << "(" << iteration << ")";
+    message << GetFullMethodName("OnTestIterationStart") << "(" << iteration
+            << ")";
     g_events->push_back(message.GetString());
   }
 
@@ -112,8 +112,8 @@ class EventRecordingListener : public TestEventListener {
   void OnTestIterationEnd(const UnitTest& /*unit_test*/,
                           int iteration) override {
     Message message;
-    message << GetFullMethodName("OnTestIterationEnd")
-            << "("  << iteration << ")";
+    message << GetFullMethodName("OnTestIterationEnd") << "(" << iteration
+            << ")";
     g_events->push_back(message.GetString());
   }
 
@@ -122,9 +122,7 @@ class EventRecordingListener : public TestEventListener {
   }
 
  private:
-  std::string GetFullMethodName(const char* name) {
-    return name_ + "." + name;
-  }
+  std::string GetFullMethodName(const char* name) { return name_ + "." + name; }
 
   std::string name_;
 };
@@ -252,22 +250,21 @@ void VerifyResults(const std::vector<std::string>& data,
   EXPECT_EQ(expected_data_size, actual_size);
 
   // Compares the common prefix.
-  const size_t shorter_size = expected_data_size <= actual_size ?
-      expected_data_size : actual_size;
+  const size_t shorter_size =
+      expected_data_size <= actual_size ? expected_data_size : actual_size;
   size_t i = 0;
   for (; i < shorter_size; ++i) {
-    ASSERT_STREQ(expected_data[i], data[i].c_str())
-        << "at position " << i;
+    ASSERT_STREQ(expected_data[i], data[i].c_str()) << "at position " << i;
   }
 
   // Prints extra elements in the actual data.
   for (; i < actual_size; ++i) {
-    printf("  Actual event #%lu: %s\n",
-        static_cast<unsigned long>(i), data[i].c_str());
+    printf("  Actual event #%lu: %s\n", static_cast<unsigned long>(i),
+           data[i].c_str());
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   std::vector<std::string> events;
   g_events = &events;
   InitGoogleTest(&argc, argv);
@@ -284,7 +281,8 @@ int main(int argc, char **argv) {
   GTEST_CHECK_(events.size() == 0)
       << "AddGlobalTestEnvironment should not generate any events itself.";
 
-  ::testing::GTEST_FLAG(repeat) = 2;
+  GTEST_FLAG_SET(repeat, 2);
+  GTEST_FLAG_SET(recreate_environments_when_repeating, true);
   int ret_val = RUN_ALL_TESTS();
 
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@@ -505,14 +503,12 @@ int main(int argc, char **argv) {
                                          "1st.OnTestProgramEnd"};
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
-  VerifyResults(events,
-                expected_events,
-                sizeof(expected_events)/sizeof(expected_events[0]));
+  VerifyResults(events, expected_events,
+                sizeof(expected_events) / sizeof(expected_events[0]));
 
   // We need to check manually for ad hoc test failures that happen after
   // RUN_ALL_TESTS finishes.
-  if (UnitTest::GetInstance()->Failed())
-    ret_val = 1;
+  if (UnitTest::GetInstance()->Failed()) ret_val = 1;
 
   return ret_val;
 }
diff --git a/googletest/googletest/test/googletest-message-test.cc b/googletest/googletest/test/googletest-message-test.cc
index 962d519114e6e4e3dc3df19fde7545571bc031bc..54e9d43c9208e441aeb1a9672732e300831c4e56 100644
--- a/googletest/googletest/test/googletest-message-test.cc
+++ b/googletest/googletest/test/googletest-message-test.cc
@@ -30,8 +30,10 @@
 //
 // Tests for the Message class.
 
-#include "gtest/gtest-message.h"
+#include <sstream>
+#include <string>
 
+#include "gtest/gtest-message.h"
 #include "gtest/gtest.h"
 
 namespace {
@@ -69,8 +71,9 @@ TEST(MessageTest, StreamsFloat) {
 
 // Tests streaming a double.
 TEST(MessageTest, StreamsDouble) {
-  const std::string s = (Message() << 1260570880.4555497 << " "
-                                  << 1260572265.1954534).GetString();
+  const std::string s =
+      (Message() << 1260570880.4555497 << " " << 1260572265.1954534)
+          .GetString();
   // Both numbers should be printed with enough precision.
   EXPECT_PRED_FORMAT2(testing::IsSubstring, "1260570880.45", s.c_str());
   EXPECT_PRED_FORMAT2(testing::IsSubstring, " 1260572265.19", s.c_str());
@@ -108,8 +111,7 @@ TEST(MessageTest, StreamsString) {
 
 // Tests that we can output strings containing embedded NULs.
 TEST(MessageTest, StreamsStringWithEmbeddedNUL) {
-  const char char_array_with_nul[] =
-      "Here's a NUL\0 and some more string";
+  const char char_array_with_nul[] = "Here's a NUL\0 and some more string";
   const ::std::string string_with_nul(char_array_with_nul,
                                       sizeof(char_array_with_nul) - 1);
   EXPECT_EQ("Here's a NUL\\0 and some more string",
@@ -129,10 +131,11 @@ TEST(MessageTest, StreamsInt) {
 // Tests that basic IO manipulators (endl, ends, and flush) can be
 // streamed to Message.
 TEST(MessageTest, StreamsBasicIoManip) {
-  EXPECT_EQ("Line 1.\nA NUL char \\0 in line 2.",
-               (Message() << "Line 1." << std::endl
-                         << "A NUL char " << std::ends << std::flush
-                         << " in line 2.").GetString());
+  EXPECT_EQ(
+      "Line 1.\nA NUL char \\0 in line 2.",
+      (Message() << "Line 1." << std::endl
+                 << "A NUL char " << std::ends << std::flush << " in line 2.")
+          .GetString());
 }
 
 // Tests Message::GetString()
diff --git a/googletest/googletest/test/googletest-options-test.cc b/googletest/googletest/test/googletest-options-test.cc
index 11fb1f224629a125521923fc68e13edd9242dc4e..8746320985ac2412b367c2932d18b63d1a3846bb 100644
--- a/googletest/googletest/test/googletest-options-test.cc
+++ b/googletest/googletest/test/googletest-options-test.cc
@@ -36,12 +36,14 @@
 // make-files on Windows and other platforms. Do not #include this file
 // anywhere else!
 
+#include <string>
+
 #include "gtest/gtest.h"
 
 #if GTEST_OS_WINDOWS_MOBILE
-# include <windows.h>
+#include <windows.h>
 #elif GTEST_OS_WINDOWS
-# include <direct.h>
+#include <direct.h>
 #elif GTEST_OS_OS2
 // For strcasecmp on OS/2
 #include <strings.h>
@@ -61,33 +63,33 @@ FilePath GetAbsolutePathOf(const FilePath& relative_path) {
 // Testing UnitTestOptions::GetOutputFormat/GetOutputFile.
 
 TEST(XmlOutputTest, GetOutputFormatDefault) {
-  GTEST_FLAG(output) = "";
+  GTEST_FLAG_SET(output, "");
   EXPECT_STREQ("", UnitTestOptions::GetOutputFormat().c_str());
 }
 
 TEST(XmlOutputTest, GetOutputFormat) {
-  GTEST_FLAG(output) = "xml:filename";
+  GTEST_FLAG_SET(output, "xml:filename");
   EXPECT_STREQ("xml", UnitTestOptions::GetOutputFormat().c_str());
 }
 
 TEST(XmlOutputTest, GetOutputFileDefault) {
-  GTEST_FLAG(output) = "";
+  GTEST_FLAG_SET(output, "");
   EXPECT_EQ(GetAbsolutePathOf(FilePath("test_detail.xml")).string(),
             UnitTestOptions::GetAbsolutePathToOutputFile());
 }
 
 TEST(XmlOutputTest, GetOutputFileSingleFile) {
-  GTEST_FLAG(output) = "xml:filename.abc";
+  GTEST_FLAG_SET(output, "xml:filename.abc");
   EXPECT_EQ(GetAbsolutePathOf(FilePath("filename.abc")).string(),
             UnitTestOptions::GetAbsolutePathToOutputFile());
 }
 
 TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
-  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  GTEST_FLAG_SET(output, "xml:path" GTEST_PATH_SEP_);
   const std::string expected_output_file =
-      GetAbsolutePathOf(
-          FilePath(std::string("path") + GTEST_PATH_SEP_ +
-                   GetCurrentExecutableName().string() + ".xml")).string();
+      GetAbsolutePathOf(FilePath(std::string("path") + GTEST_PATH_SEP_ +
+                                 GetCurrentExecutableName().string() + ".xml"))
+          .string();
   const std::string& output_file =
       UnitTestOptions::GetAbsolutePathToOutputFile();
 #if GTEST_OS_WINDOWS
@@ -115,13 +117,10 @@ TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
   const bool success = exe_str == "app";
 #else
   const bool success =
-      exe_str == "googletest-options-test" ||
-      exe_str == "gtest_all_test" ||
-      exe_str == "lt-gtest_all_test" ||
-      exe_str == "gtest_dll_test";
+      exe_str == "googletest-options-test" || exe_str == "gtest_all_test" ||
+      exe_str == "lt-gtest_all_test" || exe_str == "gtest_dll_test";
 #endif  // GTEST_OS_WINDOWS
-  if (!success)
-    FAIL() << "GetCurrentExecutableName() returns " << exe_str;
+  if (!success) FAIL() << "GetCurrentExecutableName() returns " << exe_str;
 }
 
 #if !GTEST_OS_FUCHSIA
@@ -144,33 +143,37 @@ class XmlOutputChangeDirTest : public Test {
 };
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefault) {
-  GTEST_FLAG(output) = "";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("test_detail.xml")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
+  GTEST_FLAG_SET(output, "");
+  EXPECT_EQ(
+      FilePath::ConcatPaths(original_working_dir_, FilePath("test_detail.xml"))
+          .string(),
+      UnitTestOptions::GetAbsolutePathToOutputFile());
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithDefaultXML) {
-  GTEST_FLAG(output) = "xml";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("test_detail.xml")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
+  GTEST_FLAG_SET(output, "xml");
+  EXPECT_EQ(
+      FilePath::ConcatPaths(original_working_dir_, FilePath("test_detail.xml"))
+          .string(),
+      UnitTestOptions::GetAbsolutePathToOutputFile());
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) {
-  GTEST_FLAG(output) = "xml:filename.abc";
-  EXPECT_EQ(FilePath::ConcatPaths(original_working_dir_,
-                                  FilePath("filename.abc")).string(),
-            UnitTestOptions::GetAbsolutePathToOutputFile());
+  GTEST_FLAG_SET(output, "xml:filename.abc");
+  EXPECT_EQ(
+      FilePath::ConcatPaths(original_working_dir_, FilePath("filename.abc"))
+          .string(),
+      UnitTestOptions::GetAbsolutePathToOutputFile());
 }
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
-  GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_;
+  GTEST_FLAG_SET(output, "xml:path" GTEST_PATH_SEP_);
   const std::string expected_output_file =
       FilePath::ConcatPaths(
           original_working_dir_,
           FilePath(std::string("path") + GTEST_PATH_SEP_ +
-                   GetCurrentExecutableName().string() + ".xml")).string();
+                   GetCurrentExecutableName().string() + ".xml"))
+          .string();
   const std::string& output_file =
       UnitTestOptions::GetAbsolutePathToOutputFile();
 #if GTEST_OS_WINDOWS
@@ -182,11 +185,11 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
 
 TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
 #if GTEST_OS_WINDOWS
-  GTEST_FLAG(output) = "xml:c:\\tmp\\filename.abc";
+  GTEST_FLAG_SET(output, "xml:c:\\tmp\\filename.abc");
   EXPECT_EQ(FilePath("c:\\tmp\\filename.abc").string(),
             UnitTestOptions::GetAbsolutePathToOutputFile());
 #else
-  GTEST_FLAG(output) ="xml:/tmp/filename.abc";
+  GTEST_FLAG_SET(output, "xml:/tmp/filename.abc");
   EXPECT_EQ(FilePath("/tmp/filename.abc").string(),
             UnitTestOptions::GetAbsolutePathToOutputFile());
 #endif
@@ -199,7 +202,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
   const std::string path = "/tmp/";
 #endif
 
-  GTEST_FLAG(output) = "xml:" + path;
+  GTEST_FLAG_SET(output, "xml:" + path);
   const std::string expected_output_file =
       path + GetCurrentExecutableName().string() + ".xml";
   const std::string& output_file =
diff --git a/googletest/googletest/test/googletest-output-test-golden-lin.txt b/googletest/googletest/test/googletest-output-test-golden-lin.txt
index 3fab3b97d8f1a22b641d755ab8359e5b03c92209..1f24fb7915394a24b472ce033c71d990cd8cec0d 100644
--- a/googletest/googletest/test/googletest-output-test-golden-lin.txt
+++ b/googletest/googletest/test/googletest-output-test-golden-lin.txt
@@ -12,7 +12,7 @@ Expected equality of these values:
   3
 Stack trace: (omitted)
 
-[==========] Running 88 tests from 41 test suites.
+[==========] Running 89 tests from 42 test suites.
 [----------] Global test environment set-up.
 FooEnvironment::SetUp() called.
 BarEnvironment::SetUp() called.
@@ -956,6 +956,17 @@ Stack trace: (omitted)
 ~DynamicFixture()
 [  FAILED  ] BadDynamicFixture2.Derived
 DynamicFixture::TearDownTestSuite
+[----------] 1 test from TestSuiteThatFailsToSetUp
+googletest-output-test_.cc:#: Failure
+Value of: false
+  Actual: false
+Expected: true
+Stack trace: (omitted)
+
+[ RUN      ] TestSuiteThatFailsToSetUp.ShouldNotRun
+googletest-output-test_.cc:#: Skipped
+
+[  SKIPPED ] TestSuiteThatFailsToSetUp.ShouldNotRun
 [----------] 1 test from PrintingFailingParams/FailingParamTest
 [ RUN      ] PrintingFailingParams/FailingParamTest.Fails/0
 googletest-output-test_.cc:#: Failure
@@ -1032,8 +1043,10 @@ Failed
 Expected fatal failure.
 Stack trace: (omitted)
 
-[==========] 88 tests from 41 test suites ran.
+[==========] 89 tests from 42 test suites ran.
 [  PASSED  ] 31 tests.
+[  SKIPPED ] 1 test, listed below:
+[  SKIPPED ] TestSuiteThatFailsToSetUp.ShouldNotRun
 [  FAILED  ] 57 tests, listed below:
 [  FAILED  ] NonfatalFailureTest.EscapesStringOperands
 [  FAILED  ] NonfatalFailureTest.DiffForLongStrings
@@ -1094,6 +1107,9 @@ Stack trace: (omitted)
 [  FAILED  ] GoogleTestVerification.UninstantiatedTypeParameterizedTestSuite<DetectNotInstantiatedTypesTest>
 
 57 FAILED TESTS
+[  FAILED  ] TestSuiteThatFailsToSetUp: SetUpTestSuite or TearDownTestSuite
+
+ 1 FAILED TEST SUITE
   YOU HAVE 1 DISABLED TEST
 
 Note: Google Test filter = FatalFailureTest.*:LoggingTest.*
diff --git a/googletest/googletest/test/googletest-output-test.py b/googletest/googletest/test/googletest-output-test.py
index 09028f66f90bf2382bb78c79bb4e3c39adc30170..ff44483331fbd420d5f926d9a5406ed870b5b049 100644
--- a/googletest/googletest/test/googletest-output-test.py
+++ b/googletest/googletest/test/googletest-output-test.py
@@ -42,7 +42,7 @@ import difflib
 import os
 import re
 import sys
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 
 # The flag for generating the golden file
diff --git a/googletest/googletest/test/googletest-output-test_.cc b/googletest/googletest/test/googletest-output-test_.cc
index 074f64ef62142e9d151b16c03a50169cb7a5a7cc..c2f96d980d263646dba9ee45037e3ed87eaacbe3 100644
--- a/googletest/googletest/test/googletest-output-test_.cc
+++ b/googletest/googletest/test/googletest-output-test_.cc
@@ -33,12 +33,12 @@
 // desired messages.  Therefore, most tests in this file are MEANT TO
 // FAIL.
 
+#include <stdlib.h>
+
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include "src/gtest-internal-inl.h"
 
-#include <stdlib.h>
-
 #if _MSC_VER
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */)
 #endif  //  _MSC_VER
@@ -56,9 +56,7 @@ namespace posix = ::testing::internal::posix;
 // Tests catching fatal failures.
 
 // A subroutine used by the following test.
-void TestEq1(int x) {
-  ASSERT_EQ(1, x);
-}
+void TestEq1(int x) { ASSERT_EQ(1, x); }
 
 // This function calls a test subroutine, catches the fatal failure it
 // generates, and then returns early.
@@ -76,24 +74,19 @@ void TryTestSubroutine() {
   FAIL() << "This should never be reached.";
 }
 
-TEST(PassingTest, PassingTest1) {
-}
+TEST(PassingTest, PassingTest1) {}
 
-TEST(PassingTest, PassingTest2) {
-}
+TEST(PassingTest, PassingTest2) {}
 
 // Tests that parameters of failing parameterized tests are printed in the
 // failing test summary.
 class FailingParamTest : public testing::TestWithParam<int> {};
 
-TEST_P(FailingParamTest, Fails) {
-  EXPECT_EQ(1, GetParam());
-}
+TEST_P(FailingParamTest, Fails) { EXPECT_EQ(1, GetParam()); }
 
 // This generates a test which will fail. Google Test is expected to print
 // its parameter when it outputs the list of all failed tests.
-INSTANTIATE_TEST_SUITE_P(PrintingFailingParams,
-                         FailingParamTest,
+INSTANTIATE_TEST_SUITE_P(PrintingFailingParams, FailingParamTest,
                          testing::Values(2));
 
 // Tests that an empty value for the test suite basename yields just
@@ -146,18 +139,16 @@ TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {
 // Tests HasFatalFailure() after a failed EXPECT check.
 TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
   printf("(expecting a failure on false)\n");
-  EXPECT_TRUE(false);  // Generates a nonfatal failure
+  EXPECT_TRUE(false);               // Generates a nonfatal failure
   ASSERT_FALSE(HasFatalFailure());  // This should succeed.
 }
 
 // Tests interleaving user logging and Google Test assertions.
 TEST(LoggingTest, InterleavingLoggingAndAssertions) {
-  static const int a[4] = {
-    3, 9, 2, 6
-  };
+  static const int a[4] = {3, 9, 2, 6};
 
   printf("(expecting 2 failures on (3) >= (a[i]))\n");
-  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {
+  for (int i = 0; i < static_cast<int>(sizeof(a) / sizeof(*a)); i++) {
     printf("i == %d\n", i);
     EXPECT_GE(3, a[i]);
   }
@@ -297,16 +288,14 @@ struct CheckPoints {
 static void ThreadWithScopedTrace(CheckPoints* check_points) {
   {
     SCOPED_TRACE("Trace B");
-    ADD_FAILURE()
-        << "Expected failure #1 (in thread B, only trace B alive).";
+    ADD_FAILURE() << "Expected failure #1 (in thread B, only trace B alive).";
     check_points->n1.Notify();
     check_points->n2.WaitForNotification();
 
     ADD_FAILURE()
         << "Expected failure #3 (in thread B, trace A & B both alive).";
   }  // Trace B dies here.
-  ADD_FAILURE()
-      << "Expected failure #4 (in thread B, only trace A alive).";
+  ADD_FAILURE() << "Expected failure #4 (in thread B, only trace A alive).";
   check_points->n3.Notify();
 }
 
@@ -325,11 +314,9 @@ TEST(SCOPED_TRACETest, WorksConcurrently) {
     check_points.n2.Notify();
     check_points.n3.WaitForNotification();
 
-    ADD_FAILURE()
-        << "Expected failure #5 (in thread A, only trace A alive).";
+    ADD_FAILURE() << "Expected failure #5 (in thread A, only trace A alive).";
   }  // Trace A dies here.
-  ADD_FAILURE()
-      << "Expected failure #6 (in thread A, no trace alive).";
+  ADD_FAILURE() << "Expected failure #6 (in thread A, no trace alive).";
   thread.Join();
 }
 #endif  // GTEST_IS_THREADSAFE
@@ -412,9 +399,7 @@ class FatalFailureInFixtureConstructorTest : public testing::Test {
   }
 
  private:
-  void Init() {
-    FAIL() << "Expected failure #1, in the test fixture c'tor.";
-  }
+  void Init() { FAIL() << "Expected failure #1, in the test fixture c'tor."; }
 };
 
 TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
@@ -436,9 +421,7 @@ class NonFatalFailureInSetUpTest : public testing::Test {
   void TearDown() override { FAIL() << "Expected failure #3, in TearDown()."; }
 
  private:
-  void Deinit() {
-    FAIL() << "Expected failure #4, in the test fixture d'tor.";
-  }
+  void Deinit() { FAIL() << "Expected failure #4, in the test fixture d'tor."; }
 };
 
 TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
@@ -458,9 +441,7 @@ class FatalFailureInSetUpTest : public testing::Test {
   void TearDown() override { FAIL() << "Expected failure #2, in TearDown()."; }
 
  private:
-  void Deinit() {
-    FAIL() << "Expected failure #3, in the test fixture d'tor.";
-  }
+  void Deinit() { FAIL() << "Expected failure #3, in the test fixture d'tor."; }
 };
 
 TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
@@ -488,14 +469,12 @@ TEST(GtestFailAtTest, MessageContainsSpecifiedFileAndLineNumber) {
 
 namespace foo {
 
-class MixedUpTestSuiteTest : public testing::Test {
-};
+class MixedUpTestSuiteTest : public testing::Test {};
 
 TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {}
 TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {}
 
-class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {
-};
+class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {};
 
 TEST_F(MixedUpTestSuiteWithSameTestNameTest,
        TheSecondTestWithThisNameShouldFail) {}
@@ -504,16 +483,14 @@ TEST_F(MixedUpTestSuiteWithSameTestNameTest,
 
 namespace bar {
 
-class MixedUpTestSuiteTest : public testing::Test {
-};
+class MixedUpTestSuiteTest : public testing::Test {};
 
 // The following two tests are expected to fail.  We rely on the
 // golden file to check that Google Test generates the right error message.
 TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {}
 TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {}
 
-class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {
-};
+class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {};
 
 // Expected to fail.  We rely on the golden file to check that Google Test
 // generates the right error message.
@@ -527,8 +504,7 @@ TEST_F(MixedUpTestSuiteWithSameTestNameTest,
 // test case checks the scenario where TEST_F appears before TEST, and
 // the second one checks where TEST appears before TEST_F.
 
-class TEST_F_before_TEST_in_same_test_case : public testing::Test {
-};
+class TEST_F_before_TEST_in_same_test_case : public testing::Test {};
 
 TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
 
@@ -536,15 +512,13 @@ TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
 // generates the right error message.
 TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}
 
-class TEST_before_TEST_F_in_same_test_case : public testing::Test {
-};
+class TEST_before_TEST_F_in_same_test_case : public testing::Test {};
 
 TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
 
 // Expected to fail.  We rely on the golden file to check that Google Test
 // generates the right error message.
-TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {
-}
+TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {}
 
 // Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
 int global_integer = 0;
@@ -552,9 +526,9 @@ int global_integer = 0;
 // Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
 TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
   global_integer = 0;
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
+  EXPECT_NONFATAL_FAILURE(
+      { EXPECT_EQ(1, global_integer) << "Expected non-fatal failure."; },
+      "Expected non-fatal failure.");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
@@ -563,53 +537,48 @@ TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
   int m = 0;
   static int n;
   n = 1;
-  EXPECT_NONFATAL_FAILURE({
-    EXPECT_EQ(m, n) << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
+  EXPECT_NONFATAL_FAILURE({ EXPECT_EQ(m, n) << "Expected non-fatal failure."; },
+                          "Expected non-fatal failure.");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
 // one non-fatal failure and no fatal failure.
 TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
-  EXPECT_NONFATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure.";
-  }, "Expected non-fatal failure.");
+  EXPECT_NONFATAL_FAILURE({ ADD_FAILURE() << "Expected non-fatal failure."; },
+                          "Expected non-fatal failure.");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
 // non-fatal failure.
 TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
   printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-  }, "");
+  EXPECT_NONFATAL_FAILURE({}, "");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
 // non-fatal failures.
 TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
   printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure 1.";
-    ADD_FAILURE() << "Expected non-fatal failure 2.";
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {
+        ADD_FAILURE() << "Expected non-fatal failure 1.";
+        ADD_FAILURE() << "Expected non-fatal failure 2.";
+      },
+      "");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
 // failure.
 TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
   printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    FAIL() << "Expected fatal failure.";
-  }, "");
+  EXPECT_NONFATAL_FAILURE({ FAIL() << "Expected fatal failure."; }, "");
 }
 
 // Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
 // tested returns.
 TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
   printf("(expecting a failure)\n");
-  EXPECT_NONFATAL_FAILURE({
-    return;
-  }, "");
+  EXPECT_NONFATAL_FAILURE({ return; }, "");
 }
 
 #if GTEST_HAS_EXCEPTIONS
@@ -619,10 +588,8 @@ TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
 TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
   printf("(expecting a failure)\n");
   try {
-    EXPECT_NONFATAL_FAILURE({
-      throw 0;
-    }, "");
-  } catch(int) {  // NOLINT
+    EXPECT_NONFATAL_FAILURE({ throw 0; }, "");
+  } catch (int) {  // NOLINT
   }
 }
 
@@ -631,9 +598,9 @@ TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
 // Tests that EXPECT_FATAL_FAILURE() can reference global variables.
 TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
   global_integer = 0;
-  EXPECT_FATAL_FAILURE({
-    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";
-  }, "Expected fatal failure.");
+  EXPECT_FATAL_FAILURE(
+      { ASSERT_EQ(1, global_integer) << "Expected fatal failure."; },
+      "Expected fatal failure.");
 }
 
 // Tests that EXPECT_FATAL_FAILURE() can reference local static
@@ -641,58 +608,51 @@ TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
 TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
   static int n;
   n = 1;
-  EXPECT_FATAL_FAILURE({
-    ASSERT_EQ(0, n) << "Expected fatal failure.";
-  }, "Expected fatal failure.");
+  EXPECT_FATAL_FAILURE({ ASSERT_EQ(0, n) << "Expected fatal failure."; },
+                       "Expected fatal failure.");
 }
 
 // Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
 // one fatal failure and no non-fatal failure.
 TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
-  EXPECT_FATAL_FAILURE({
-    FAIL() << "Expected fatal failure.";
-  }, "Expected fatal failure.");
+  EXPECT_FATAL_FAILURE({ FAIL() << "Expected fatal failure."; },
+                       "Expected fatal failure.");
 }
 
 // Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
 // failure.
 TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
   printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-  }, "");
+  EXPECT_FATAL_FAILURE({}, "");
 }
 
 // A helper for generating a fatal failure.
-void FatalFailure() {
-  FAIL() << "Expected fatal failure.";
-}
+void FatalFailure() { FAIL() << "Expected fatal failure."; }
 
 // Tests that EXPECT_FATAL_FAILURE() fails when there are two
 // fatal failures.
 TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
   printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    FatalFailure();
-    FatalFailure();
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {
+        FatalFailure();
+        FatalFailure();
+      },
+      "");
 }
 
 // Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
 // failure.
 TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
   printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    ADD_FAILURE() << "Expected non-fatal failure.";
-  }, "");
+  EXPECT_FATAL_FAILURE({ ADD_FAILURE() << "Expected non-fatal failure."; }, "");
 }
 
 // Tests that EXPECT_FATAL_FAILURE() fails when the statement being
 // tested returns.
 TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
   printf("(expecting a failure)\n");
-  EXPECT_FATAL_FAILURE({
-    return;
-  }, "");
+  EXPECT_FATAL_FAILURE({ return; }, "");
 }
 
 #if GTEST_HAS_EXCEPTIONS
@@ -702,10 +662,8 @@ TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
 TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
   printf("(expecting a failure)\n");
   try {
-    EXPECT_FATAL_FAILURE({
-      throw 0;
-    }, "");
-  } catch(int) {  // NOLINT
+    EXPECT_FATAL_FAILURE({ throw 0; }, "");
+  } catch (int) {  // NOLINT
   }
 }
 
@@ -717,21 +675,14 @@ std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {
   return info.param;
 }
 
-class ParamTest : public testing::TestWithParam<std::string> {
-};
+class ParamTest : public testing::TestWithParam<std::string> {};
 
-TEST_P(ParamTest, Success) {
-  EXPECT_EQ("a", GetParam());
-}
+TEST_P(ParamTest, Success) { EXPECT_EQ("a", GetParam()); }
 
-TEST_P(ParamTest, Failure) {
-  EXPECT_EQ("b", GetParam()) << "Expected failure";
-}
+TEST_P(ParamTest, Failure) { EXPECT_EQ("b", GetParam()) << "Expected failure"; }
 
-INSTANTIATE_TEST_SUITE_P(PrintingStrings,
-                         ParamTest,
-                         testing::Values(std::string("a")),
-                         ParamNameFunc);
+INSTANTIATE_TEST_SUITE_P(PrintingStrings, ParamTest,
+                         testing::Values(std::string("a")), ParamNameFunc);
 
 // The case where a suite has INSTANTIATE_TEST_SUITE_P but not TEST_P.
 using NoTests = ParamTest;
@@ -739,20 +690,17 @@ INSTANTIATE_TEST_SUITE_P(ThisIsOdd, NoTests, ::testing::Values("Hello"));
 
 // fails under kErrorOnUninstantiatedParameterizedTest=true
 class DetectNotInstantiatedTest : public testing::TestWithParam<int> {};
-TEST_P(DetectNotInstantiatedTest, Used) { }
+TEST_P(DetectNotInstantiatedTest, Used) {}
 
 // This would make the test failure from the above go away.
 // INSTANTIATE_TEST_SUITE_P(Fix, DetectNotInstantiatedTest, testing::Values(1));
 
 template <typename T>
-class TypedTest : public testing::Test {
-};
+class TypedTest : public testing::Test {};
 
 TYPED_TEST_SUITE(TypedTest, testing::Types<int>);
 
-TYPED_TEST(TypedTest, Success) {
-  EXPECT_EQ(0, TypeParam());
-}
+TYPED_TEST(TypedTest, Success) { EXPECT_EQ(0, TypeParam()); }
 
 TYPED_TEST(TypedTest, Failure) {
   EXPECT_EQ(1, TypeParam()) << "Expected failure";
@@ -781,14 +729,11 @@ TYPED_TEST(TypedTestWithNames, Success) {}
 TYPED_TEST(TypedTestWithNames, Failure) { FAIL(); }
 
 template <typename T>
-class TypedTestP : public testing::Test {
-};
+class TypedTestP : public testing::Test {};
 
 TYPED_TEST_SUITE_P(TypedTestP);
 
-TYPED_TEST_P(TypedTestP, Success) {
-  EXPECT_EQ(0U, TypeParam());
-}
+TYPED_TEST_P(TypedTestP, Success) { EXPECT_EQ(0U, TypeParam()); }
 
 TYPED_TEST_P(TypedTestP, Failure) {
   EXPECT_EQ(1U, TypeParam()) << "Expected failure";
@@ -813,7 +758,7 @@ class TypedTestPNames {
 };
 
 INSTANTIATE_TYPED_TEST_SUITE_P(UnsignedCustomName, TypedTestP, UnsignedTypes,
-                              TypedTestPNames);
+                               TypedTestPNames);
 
 template <typename T>
 class DetectNotInstantiatedTypesTest : public testing::Test {};
@@ -835,34 +780,28 @@ REGISTER_TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest, Used);
 // We rely on the golden file to verify that tests whose test case
 // name ends with DeathTest are run first.
 
-TEST(ADeathTest, ShouldRunFirst) {
-}
+TEST(ADeathTest, ShouldRunFirst) {}
 
 // We rely on the golden file to verify that typed tests whose test
 // case name ends with DeathTest are run first.
 
 template <typename T>
-class ATypedDeathTest : public testing::Test {
-};
+class ATypedDeathTest : public testing::Test {};
 
 typedef testing::Types<int, double> NumericTypes;
 TYPED_TEST_SUITE(ATypedDeathTest, NumericTypes);
 
-TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
-}
-
+TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {}
 
 // We rely on the golden file to verify that type-parameterized tests
 // whose test case name ends with DeathTest are run first.
 
 template <typename T>
-class ATypeParamDeathTest : public testing::Test {
-};
+class ATypeParamDeathTest : public testing::Test {};
 
 TYPED_TEST_SUITE_P(ATypeParamDeathTest);
 
-TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {
-}
+TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {}
 
 REGISTER_TYPED_TEST_SUITE_P(ATypeParamDeathTest, ShouldRunFirst);
 
@@ -874,10 +813,7 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, ATypeParamDeathTest, NumericTypes);
 // EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
 class ExpectFailureTest : public testing::Test {
  public:  // Must be public and not protected due to a bug in g++ 3.4.2.
-  enum FailureMode {
-    FATAL_FAILURE,
-    NONFATAL_FAILURE
-  };
+  enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE };
   static void AddFailure(FailureMode failure) {
     if (failure == FATAL_FAILURE) {
       FAIL() << "Expected fatal failure.";
@@ -893,11 +829,13 @@ TEST_F(ExpectFailureTest, ExpectFatalFailure) {
   EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
   // Expected fatal failure, but got a non-fatal failure.
   printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "
+  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE),
+                       "Expected non-fatal "
                        "failure.");
   // Wrong message.
   printf("(expecting 1 failure)\n");
-  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "
+  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE),
+                       "Some other fatal failure "
                        "expected.");
 }
 
@@ -910,7 +848,8 @@ TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
   EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
   // Wrong message.
   printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "
+  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE),
+                          "Some other non-fatal "
                           "failure.");
 }
 
@@ -975,7 +914,8 @@ TEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) {
 TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
   // Expected non-fatal failure, but succeeds.
   printf("(expecting 1 failure)\n");
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(),
+                                         "Expected non-fatal "
                                          "failure.");
   // Expected non-fatal failure, but got a fatal failure.
   printf("(expecting 1 failure)\n");
@@ -1060,20 +1000,26 @@ class BarEnvironment : public testing::Environment {
   }
 };
 
+class TestSuiteThatFailsToSetUp : public testing::Test {
+ public:
+  static void SetUpTestSuite() { EXPECT_TRUE(false); }
+};
+TEST_F(TestSuiteThatFailsToSetUp, ShouldNotRun) { std::abort(); }
+
 // The main function.
 //
 // The idea is to use Google Test to run all the tests we have defined (some
 // of them are intended to fail), and then compare the test results
 // with the "golden" file.
-int main(int argc, char **argv) {
-  testing::GTEST_FLAG(print_time) = false;
+int main(int argc, char** argv) {
+  GTEST_FLAG_SET(print_time, false);
 
   // We just run the tests, knowing some of them are intended to fail.
   // We will use a separate Python script to compare the output of
   // this program with the golden file.
 
   // It's hard to test InitGoogleTest() directly, as it has many
-  // global side effects.  The following line serves as a sanity test
+  // global side effects.  The following line serves as a test
   // for it.
   testing::InitGoogleTest(&argc, argv);
   bool internal_skip_environment_and_ad_hoc_tests =
@@ -1081,20 +1027,19 @@ int main(int argc, char **argv) {
                  std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
 
 #if GTEST_HAS_DEATH_TEST
-  if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {
+  if (GTEST_FLAG_GET(internal_run_death_test) != "") {
     // Skip the usual output capturing if we're running as the child
     // process of an threadsafe-style death test.
-# if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS
     posix::FReopen("nul:", "w", stdout);
-# else
+#else
     posix::FReopen("/dev/null", "w", stdout);
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
     return RUN_ALL_TESTS();
   }
 #endif  // GTEST_HAS_DEATH_TEST
 
-  if (internal_skip_environment_and_ad_hoc_tests)
-    return RUN_ALL_TESTS();
+  if (internal_skip_environment_and_ad_hoc_tests) return RUN_ALL_TESTS();
 
   // Registers two global test environments.
   // The golden file verifies that they are set up in the order they
@@ -1102,7 +1047,7 @@ int main(int argc, char **argv) {
   testing::AddGlobalTestEnvironment(new FooEnvironment);
   testing::AddGlobalTestEnvironment(new BarEnvironment);
 #if _MSC_VER
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4127
-#endif  //  _MSC_VER
+  GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4127
+#endif                               //  _MSC_VER
   return RunAllTests();
 }
diff --git a/googletest/googletest/test/googletest-param-test-invalid-name1-test.py b/googletest/googletest/test/googletest-param-test-invalid-name1-test.py
index 2a08477a77ebdf0aa55f23444abd6b839d90ba43..b8d609a700c85a283cd30b2c2b3c83623851dab8 100644
--- a/googletest/googletest/test/googletest-param-test-invalid-name1-test.py
+++ b/googletest/googletest/test/googletest-param-test-invalid-name1-test.py
@@ -30,7 +30,7 @@
 
 """Verifies that Google Test warns the user when not initialized properly."""
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 binary_name = 'googletest-param-test-invalid-name1-test_'
 COMMAND = gtest_test_utils.GetTestExecutablePath(binary_name)
diff --git a/googletest/googletest/test/googletest-param-test-invalid-name1-test_.cc b/googletest/googletest/test/googletest-param-test-invalid-name1-test_.cc
index 955d699900d8cd8eb19b251d35d6d5f7ee82e604..004733a12c5007da354da92474e17b17fefd842b 100644
--- a/googletest/googletest/test/googletest-param-test-invalid-name1-test_.cc
+++ b/googletest/googletest/test/googletest-param-test-invalid-name1-test_.cc
@@ -27,17 +27,14 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest.h"
 
 namespace {
 class DummyTest : public ::testing::TestWithParam<const char *> {};
 
-TEST_P(DummyTest, Dummy) {
-}
+TEST_P(DummyTest, Dummy) {}
 
-INSTANTIATE_TEST_SUITE_P(InvalidTestName,
-                         DummyTest,
+INSTANTIATE_TEST_SUITE_P(InvalidTestName, DummyTest,
                          ::testing::Values("InvalidWithQuotes"),
                          ::testing::PrintToStringParamName());
 
@@ -47,4 +44,3 @@ int main(int argc, char *argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-
diff --git a/googletest/googletest/test/googletest-param-test-invalid-name2-test.py b/googletest/googletest/test/googletest-param-test-invalid-name2-test.py
index ab838f4632291d1cb78e4a11ec3ab0c773b94d5c..d92fa065ae2312bf9ea63272b22612cf372e3ada 100644
--- a/googletest/googletest/test/googletest-param-test-invalid-name2-test.py
+++ b/googletest/googletest/test/googletest-param-test-invalid-name2-test.py
@@ -30,7 +30,7 @@
 
 """Verifies that Google Test warns the user when not initialized properly."""
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 binary_name = 'googletest-param-test-invalid-name2-test_'
 COMMAND = gtest_test_utils.GetTestExecutablePath(binary_name)
diff --git a/googletest/googletest/test/googletest-param-test-invalid-name2-test_.cc b/googletest/googletest/test/googletest-param-test-invalid-name2-test_.cc
index 76371df54f0b3e2f277364dd8a22d02823c2eecc..d0c44da544594949c10ad632fe132f9aa629e85e 100644
--- a/googletest/googletest/test/googletest-param-test-invalid-name2-test_.cc
+++ b/googletest/googletest/test/googletest-param-test-invalid-name2-test_.cc
@@ -27,22 +27,19 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest.h"
 
 namespace {
 class DummyTest : public ::testing::TestWithParam<const char *> {};
 
 std::string StringParamTestSuffix(
-    const testing::TestParamInfo<const char*>& info) {
+    const testing::TestParamInfo<const char *> &info) {
   return std::string(info.param);
 }
 
-TEST_P(DummyTest, Dummy) {
-}
+TEST_P(DummyTest, Dummy) {}
 
-INSTANTIATE_TEST_SUITE_P(DuplicateTestNames,
-                         DummyTest,
+INSTANTIATE_TEST_SUITE_P(DuplicateTestNames, DummyTest,
                          ::testing::Values("a", "b", "a", "c"),
                          StringParamTestSuffix);
 }  // namespace
@@ -51,5 +48,3 @@ int main(int argc, char *argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-
-
diff --git a/googletest/googletest/test/googletest-param-test-test.cc b/googletest/googletest/test/googletest-param-test-test.cc
index 023aa46d69f939cfa853ca022725982cbf14d55f..63db2860739247ed7c5ccb51a2604171587f45d8 100644
--- a/googletest/googletest/test/googletest-param-test-test.cc
+++ b/googletest/googletest/test/googletest-param-test-test.cc
@@ -32,25 +32,27 @@
 // generators objects produce correct parameter sequences and that
 // Google Test runtime instantiates correct tests from those sequences.
 
-#include "gtest/gtest.h"
+#include "test/googletest-param-test-test.h"
 
-# include <algorithm>
-# include <iostream>
-# include <list>
-# include <set>
-# include <sstream>
-# include <string>
-# include <vector>
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <set>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <vector>
 
-# include "src/gtest-internal-inl.h"  // for UnitTestOptions
-# include "test/googletest-param-test-test.h"
+#include "gtest/gtest.h"
+#include "src/gtest-internal-inl.h"  // for UnitTestOptions
 
-using ::std::vector;
 using ::std::sort;
+using ::std::vector;
 
 using ::testing::AddGlobalTestEnvironment;
 using ::testing::Bool;
 using ::testing::Combine;
+using ::testing::ConvertGenerator;
 using ::testing::Message;
 using ::testing::Range;
 using ::testing::TestWithParam;
@@ -85,15 +87,14 @@ void VerifyGenerator(const ParamGenerator<T>& generator,
     // We cannot use EXPECT_EQ() here as the values may be tuples,
     // which don't support <<.
     EXPECT_TRUE(expected_values[i] == *it)
-        << "where i is " << i
-        << ", expected_values[i] is " << PrintValue(expected_values[i])
-        << ", *it is " << PrintValue(*it)
+        << "where i is " << i << ", expected_values[i] is "
+        << PrintValue(expected_values[i]) << ", *it is " << PrintValue(*it)
         << ", and 'it' is an iterator created with the copy constructor.\n";
     ++it;
   }
   EXPECT_TRUE(it == generator.end())
-        << "At the presumed end of sequence when accessing via an iterator "
-        << "created with the copy constructor.\n";
+      << "At the presumed end of sequence when accessing via an iterator "
+      << "created with the copy constructor.\n";
 
   // Test the iterator assignment. The following lines verify that
   // the sequence accessed via an iterator initialized via the
@@ -105,15 +106,14 @@ void VerifyGenerator(const ParamGenerator<T>& generator,
         << "At element " << i << " when accessing via an iterator "
         << "created with the assignment operator.\n";
     EXPECT_TRUE(expected_values[i] == *it)
-        << "where i is " << i
-        << ", expected_values[i] is " << PrintValue(expected_values[i])
-        << ", *it is " << PrintValue(*it)
+        << "where i is " << i << ", expected_values[i] is "
+        << PrintValue(expected_values[i]) << ", *it is " << PrintValue(*it)
         << ", and 'it' is an iterator created with the copy constructor.\n";
     ++it;
   }
   EXPECT_TRUE(it == generator.end())
-        << "At the presumed end of sequence when accessing via an iterator "
-        << "created with the assignment operator.\n";
+      << "At the presumed end of sequence when accessing via an iterator "
+      << "created with the assignment operator.\n";
 }
 
 template <typename T>
@@ -216,8 +216,7 @@ class DogAdder {
   DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
 
   DogAdder operator=(const DogAdder& other) {
-    if (this != &other)
-      value_ = other.value_;
+    if (this != &other) value_ = other.value_;
     return *this;
   }
   DogAdder operator+(const DogAdder& other) const {
@@ -225,9 +224,7 @@ class DogAdder {
     msg << value_.c_str() << other.value_.c_str();
     return DogAdder(msg.GetString().c_str());
   }
-  bool operator<(const DogAdder& other) const {
-    return value_ < other.value_;
-  }
+  bool operator<(const DogAdder& other) const { return value_ < other.value_; }
   const std::string& value() const { return value_; }
 
  private:
@@ -372,19 +369,17 @@ TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
 }
 
 TEST(ValuesTest, ValuesWorksForMaxLengthList) {
-  const ParamGenerator<int> gen = Values(
-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
+  const ParamGenerator<int> gen =
+      Values(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150,
+             160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280,
+             290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 410,
+             420, 430, 440, 450, 460, 470, 480, 490, 500);
 
   const int expected_values[] = {
-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
-      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
-      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
-      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
-      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
+      10,  20,  30,  40,  50,  60,  70,  80,  90,  100, 110, 120, 130,
+      140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260,
+      270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390,
+      400, 410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
   VerifyGenerator(gen, expected_values);
 }
 
@@ -409,7 +404,7 @@ TEST(BoolTest, BoolWorks) {
 TEST(CombineTest, CombineWithTwoParameters) {
   const char* foo = "foo";
   const char* bar = "bar";
-  const ParamGenerator<std::tuple<const char*, int> > gen =
+  const ParamGenerator<std::tuple<const char*, int>> gen =
       Combine(Values(foo, bar), Values(3, 4));
 
   std::tuple<const char*, int> expected_values[] = {
@@ -420,7 +415,7 @@ TEST(CombineTest, CombineWithTwoParameters) {
 
 // Tests that Combine() with three parameters generates the expected sequence.
 TEST(CombineTest, CombineWithThreeParameters) {
-  const ParamGenerator<std::tuple<int, int, int> > gen =
+  const ParamGenerator<std::tuple<int, int, int>> gen =
       Combine(Values(0, 1), Values(3, 4), Values(5, 6));
   std::tuple<int, int, int> expected_values[] = {
       std::make_tuple(0, 3, 5), std::make_tuple(0, 3, 6),
@@ -434,7 +429,7 @@ TEST(CombineTest, CombineWithThreeParameters) {
 // sequence generates a sequence with the number of elements equal to the
 // number of elements in the sequence generated by the second parameter.
 TEST(CombineTest, CombineWithFirstParameterSingleValue) {
-  const ParamGenerator<std::tuple<int, int> > gen =
+  const ParamGenerator<std::tuple<int, int>> gen =
       Combine(Values(42), Values(0, 1));
 
   std::tuple<int, int> expected_values[] = {std::make_tuple(42, 0),
@@ -446,7 +441,7 @@ TEST(CombineTest, CombineWithFirstParameterSingleValue) {
 // sequence generates a sequence with the number of elements equal to the
 // number of elements in the sequence generated by the first parameter.
 TEST(CombineTest, CombineWithSecondParameterSingleValue) {
-  const ParamGenerator<std::tuple<int, int> > gen =
+  const ParamGenerator<std::tuple<int, int>> gen =
       Combine(Values(0, 1), Values(42));
 
   std::tuple<int, int> expected_values[] = {std::make_tuple(0, 42),
@@ -457,7 +452,7 @@ TEST(CombineTest, CombineWithSecondParameterSingleValue) {
 // Tests that when the first parameter produces an empty sequence,
 // Combine() produces an empty sequence, too.
 TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
-  const ParamGenerator<std::tuple<int, int> > gen =
+  const ParamGenerator<std::tuple<int, int>> gen =
       Combine(Range(0, 0), Values(0, 1));
   VerifyGeneratorIsEmpty(gen);
 }
@@ -465,7 +460,7 @@ TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
 // Tests that when the second parameter produces an empty sequence,
 // Combine() produces an empty sequence, too.
 TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
-  const ParamGenerator<std::tuple<int, int> > gen =
+  const ParamGenerator<std::tuple<int, int>> gen =
       Combine(Values(0, 1), Range(1, 1));
   VerifyGeneratorIsEmpty(gen);
 }
@@ -476,7 +471,7 @@ TEST(CombineTest, CombineWithMaxNumberOfParameters) {
   const char* foo = "foo";
   const char* bar = "bar";
   const ParamGenerator<
-      std::tuple<const char*, int, int, int, int, int, int, int, int, int> >
+      std::tuple<const char*, int, int, int, int, int, int, int, int, int>>
       gen =
           Combine(Values(foo, bar), Values(1), Values(2), Values(3), Values(4),
                   Values(5), Values(6), Values(7), Values(8), Values(9));
@@ -504,11 +499,11 @@ class NonDefaultConstructAssignString {
 };
 
 TEST(CombineTest, NonDefaultConstructAssign) {
-  const ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> > gen =
+  const ParamGenerator<std::tuple<int, NonDefaultConstructAssignString>> gen =
       Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
                                    NonDefaultConstructAssignString("B")));
 
-  ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> >::iterator
+  ParamGenerator<std::tuple<int, NonDefaultConstructAssignString>>::iterator
       it = gen.begin();
 
   EXPECT_EQ(0, std::get<0>(*it));
@@ -530,6 +525,63 @@ TEST(CombineTest, NonDefaultConstructAssign) {
   EXPECT_TRUE(it == gen.end());
 }
 
+template <typename T>
+class ConstructFromT {
+ public:
+  explicit ConstructFromT(const T& t) : t_(t) {}
+  template <typename... Args,
+            typename std::enable_if<sizeof...(Args) != 1, int>::type = 0>
+  ConstructFromT(Args&&... args) : t_(std::forward<Args>(args)...) {}
+
+  bool operator==(const ConstructFromT& other) const { return other.t_ == t_; }
+
+  const T& get() const { return t_; }
+
+ private:
+  T t_;
+};
+
+TEST(ConvertTest, CombineWithTwoParameters) {
+  const char* foo = "foo";
+  const char* bar = "bar";
+  const ParamGenerator<ConstructFromT<std::tuple<const char*, int>>> gen =
+      ConvertGenerator<std::tuple<const char*, int>>(
+          Combine(Values(foo, bar), Values(3, 4)));
+
+  ConstructFromT<std::tuple<const char*, int>> expected_values[] = {
+      {foo, 3}, {foo, 4}, {bar, 3}, {bar, 4}};
+  VerifyGenerator(gen, expected_values);
+}
+
+TEST(ConvertTest, NonDefaultConstructAssign) {
+  const ParamGenerator<
+      ConstructFromT<std::tuple<int, NonDefaultConstructAssignString>>>
+      gen = ConvertGenerator<std::tuple<int, NonDefaultConstructAssignString>>(
+          Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
+                                       NonDefaultConstructAssignString("B"))));
+
+  ParamGenerator<ConstructFromT<
+      std::tuple<int, NonDefaultConstructAssignString>>>::iterator it =
+      gen.begin();
+
+  EXPECT_EQ(0, std::get<0>(it->get()));
+  EXPECT_EQ("A", std::get<1>(it->get()).str());
+  ++it;
+
+  EXPECT_EQ(0, std::get<0>(it->get()));
+  EXPECT_EQ("B", std::get<1>(it->get()).str());
+  ++it;
+
+  EXPECT_EQ(1, std::get<0>(it->get()));
+  EXPECT_EQ("A", std::get<1>(it->get()).str());
+  ++it;
+
+  EXPECT_EQ(1, std::get<0>(it->get()));
+  EXPECT_EQ("B", std::get<1>(it->get()).str());
+  ++it;
+
+  EXPECT_TRUE(it == gen.end());
+}
 
 // Tests that an generator produces correct sequence after being
 // assigned from another generator.
@@ -573,7 +625,7 @@ class TestGenerationEnvironment : public ::testing::Environment {
       Message msg;
       msg << "TestsExpandedAndRun/" << i;
       if (UnitTestOptions::FilterMatchesTest(
-             "TestExpansionModule/MultipleTestGenerationTest",
+              "TestExpansionModule/MultipleTestGenerationTest",
               msg.GetString().c_str())) {
         perform_check = true;
       }
@@ -595,15 +647,20 @@ class TestGenerationEnvironment : public ::testing::Environment {
   }
 
  private:
-  TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
-                                tear_down_count_(0), test_body_count_(0) {}
+  TestGenerationEnvironment()
+      : fixture_constructor_count_(0),
+        set_up_count_(0),
+        tear_down_count_(0),
+        test_body_count_(0) {}
 
   int fixture_constructor_count_;
   int set_up_count_;
   int tear_down_count_;
   int test_body_count_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
+  TestGenerationEnvironment(const TestGenerationEnvironment&) = delete;
+  TestGenerationEnvironment& operator=(const TestGenerationEnvironment&) =
+      delete;
 };
 
 const int test_generation_params[] = {36, 42, 72};
@@ -612,7 +669,7 @@ class TestGenerationTest : public TestWithParam<int> {
  public:
   enum {
     PARAMETER_COUNT =
-        sizeof(test_generation_params)/sizeof(test_generation_params[0])
+        sizeof(test_generation_params) / sizeof(test_generation_params[0])
   };
 
   typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
@@ -636,9 +693,9 @@ class TestGenerationTest : public TestWithParam<int> {
     for (int i = 0; i < PARAMETER_COUNT; ++i) {
       Message test_name;
       test_name << "TestsExpandedAndRun/" << i;
-      if ( !UnitTestOptions::FilterMatchesTest(
-                "TestExpansionModule/MultipleTestGenerationTest",
-                test_name.GetString())) {
+      if (!UnitTestOptions::FilterMatchesTest(
+              "TestExpansionModule/MultipleTestGenerationTest",
+              test_name.GetString())) {
         all_tests_in_test_case_selected = false;
       }
     }
@@ -668,7 +725,8 @@ class TestGenerationTest : public TestWithParam<int> {
   static vector<int> collected_parameters_;
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
+  TestGenerationTest(const TestGenerationTest&) = delete;
+  TestGenerationTest& operator=(const TestGenerationTest&) = delete;
 };
 vector<int> TestGenerationTest::collected_parameters_;
 
@@ -729,8 +787,7 @@ TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
 // Tests that a parameterized test case can be instantiated with multiple
 // generators.
 class MultipleInstantiationTest : public TestWithParam<int> {};
-TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
-}
+TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {}
 INSTANTIATE_TEST_SUITE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
 INSTANTIATE_TEST_SUITE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
 
@@ -780,7 +837,7 @@ class NamingTest : public TestWithParam<int> {};
 
 TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
 
   EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_suite_name());
 
@@ -801,7 +858,7 @@ class MacroNamingTest : public TestWithParam<int> {};
 
 TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
 
   EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_suite_name());
   EXPECT_STREQ("FooSomeTestName/0", test_info->name());
@@ -815,7 +872,7 @@ class MacroNamingTestNonParametrized : public ::testing::Test {};
 TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),
        PREFIX_WITH_FOO(SomeTestName)) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
 
   EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_suite_name());
   EXPECT_STREQ("FooSomeTestName", test_info->name());
@@ -824,7 +881,7 @@ TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),
 TEST(MacroNameing, LookupNames) {
   std::set<std::string> know_suite_names, know_test_names;
 
-  auto ins = testing::UnitTest::GetInstance();
+  const auto& ins = testing::UnitTest::GetInstance();
   int ts = 0;
   while (const testing::TestSuite* suite = ins->GetTestSuite(ts++)) {
     know_suite_names.insert(suite->name());
@@ -839,9 +896,8 @@ TEST(MacroNameing, LookupNames) {
   EXPECT_NE(  //
       know_suite_names.find("FortyTwo/MacroNamingTest"),
       know_suite_names.end());
-  EXPECT_NE(
-      know_suite_names.find("MacroNamingTestNonParametrized"),
-      know_suite_names.end());
+  EXPECT_NE(know_suite_names.find("MacroNamingTestNonParametrized"),
+            know_suite_names.end());
   // Check that the expected form of the test name actually exists.
   EXPECT_NE(  //
       know_test_names.find("FortyTwo/MacroNamingTest.FooSomeTestName/0"),
@@ -901,7 +957,7 @@ INSTANTIATE_TEST_SUITE_P(CustomParamNameLambda, CustomLambdaNamingTest,
                          });
 
 TEST(CustomNamingTest, CheckNameRegistry) {
-  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
+  const auto& unit_test = ::testing::UnitTest::GetInstance();
   std::set<std::string> test_names;
   for (int suite_num = 0; suite_num < unit_test->total_test_suite_count();
        ++suite_num) {
@@ -924,7 +980,7 @@ class CustomIntegerNamingTest : public TestWithParam<int> {};
 
 TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
   Message test_name_stream;
   test_name_stream << "TestsReportCorrectNames/" << GetParam();
   EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
@@ -949,7 +1005,7 @@ class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
 
 TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
   Message test_name_stream;
   test_name_stream << "TestsReportCorrectNames/" << GetParam();
   EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
@@ -979,7 +1035,7 @@ class StatefulNamingTest : public ::testing::TestWithParam<int> {
 
 TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
   sum_ += GetParam();
   Message test_name_stream;
   test_name_stream << "TestsReportCorrectNames/" << sum_;
@@ -1007,7 +1063,7 @@ class CommentTest : public TestWithParam<Unstreamable> {};
 
 TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
   const ::testing::TestInfo* const test_info =
-     ::testing::UnitTest::GetInstance()->current_test_info();
+      ::testing::UnitTest::GetInstance()->current_test_info();
 
   EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
 }
@@ -1021,7 +1077,8 @@ INSTANTIATE_TEST_SUITE_P(InstantiationWithComments, CommentTest,
 // perform simple tests on both.
 class NonParameterizedBaseTest : public ::testing::Test {
  public:
-  NonParameterizedBaseTest() : n_(17) { }
+  NonParameterizedBaseTest() : n_(17) {}
+
  protected:
   int n_;
 };
@@ -1029,16 +1086,14 @@ class NonParameterizedBaseTest : public ::testing::Test {
 class ParameterizedDerivedTest : public NonParameterizedBaseTest,
                                  public ::testing::WithParamInterface<int> {
  protected:
-  ParameterizedDerivedTest() : count_(0) { }
+  ParameterizedDerivedTest() : count_(0) {}
   int count_;
   static int global_count_;
 };
 
 int ParameterizedDerivedTest::global_count_ = 0;
 
-TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
-  EXPECT_EQ(17, n_);
-}
+TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) { EXPECT_EQ(17, n_); }
 
 TEST_P(ParameterizedDerivedTest, SeesSequence) {
   EXPECT_EQ(17, n_);
@@ -1046,11 +1101,10 @@ TEST_P(ParameterizedDerivedTest, SeesSequence) {
   EXPECT_EQ(GetParam(), global_count_++);
 }
 
-class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
+class ParameterizedDeathTest : public ::testing::TestWithParam<int> {};
 
 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
-  EXPECT_DEATH_IF_SUPPORTED(GetParam(),
-                            ".* value-parameterized test .*");
+  EXPECT_DEATH_IF_SUPPORTED(GetParam(), ".* value-parameterized test .*");
 }
 
 INSTANTIATE_TEST_SUITE_P(RangeZeroToFive, ParameterizedDerivedTest,
@@ -1084,11 +1138,11 @@ class NotInstantiatedTest : public testing::TestWithParam<int> {};
 // ... we mark is as allowed.
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTest);
 
-TEST_P(NotInstantiatedTest, Used) { }
+TEST_P(NotInstantiatedTest, Used) {}
 
 using OtherName = NotInstantiatedTest;
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OtherName);
-TEST_P(OtherName, Used) { }
+TEST_P(OtherName, Used) {}
 
 // Used but not instantiated, this would fail. but...
 template <typename T>
@@ -1097,11 +1151,11 @@ TYPED_TEST_SUITE_P(NotInstantiatedTypeTest);
 // ... we mark is as allowed.
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTypeTest);
 
-TYPED_TEST_P(NotInstantiatedTypeTest, Used) { }
+TYPED_TEST_P(NotInstantiatedTypeTest, Used) {}
 REGISTER_TYPED_TEST_SUITE_P(NotInstantiatedTypeTest, Used);
 }  // namespace works_here
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   // Used in TestGenerationTest test suite.
   AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
   // Used in GeneratorEvaluationTest test suite. Tests that the updated value
diff --git a/googletest/googletest/test/googletest-param-test-test.h b/googletest/googletest/test/googletest-param-test-test.h
index 891937538d0126e94cd3d947adec31a56134afc2..6d77e1049abc83906546e950be3f778474a440d3 100644
--- a/googletest/googletest/test/googletest-param-test-test.h
+++ b/googletest/googletest/test/googletest-param-test-test.h
@@ -39,13 +39,11 @@
 
 // Test fixture for testing definition and instantiation of a test
 // in separate translation units.
-class ExternalInstantiationTest : public ::testing::TestWithParam<int> {
-};
+class ExternalInstantiationTest : public ::testing::TestWithParam<int> {};
 
 // Test fixture for testing instantiation of a test in multiple
 // translation units.
 class InstantiationInMultipleTranslationUnitsTest
-    : public ::testing::TestWithParam<int> {
-};
+    : public ::testing::TestWithParam<int> {};
 
 #endif  // GOOGLETEST_TEST_GOOGLETEST_PARAM_TEST_TEST_H_
diff --git a/googletest/googletest/test/googletest-param-test2-test.cc b/googletest/googletest/test/googletest-param-test2-test.cc
index 2a29fb1d0686e2a4ec7c67c8912ff6a38f89ccd0..71727a674f099d11f26a1d00a4af6c6135fb3509 100644
--- a/googletest/googletest/test/googletest-param-test2-test.cc
+++ b/googletest/googletest/test/googletest-param-test2-test.cc
@@ -46,8 +46,7 @@ ParamGenerator<int> extern_gen = Values(33);
 // and instantiated in another. The test is defined in
 // googletest-param-test-test.cc and ExternalInstantiationTest fixture class is
 // defined in gtest-param-test_test.h.
-INSTANTIATE_TEST_SUITE_P(MultiplesOf33,
-                         ExternalInstantiationTest,
+INSTANTIATE_TEST_SUITE_P(MultiplesOf33, ExternalInstantiationTest,
                          Values(33, 66));
 
 // Tests that a parameterized test case can be instantiated
@@ -55,7 +54,5 @@ INSTANTIATE_TEST_SUITE_P(MultiplesOf33,
 // in googletest-param-test-test.cc and
 // InstantiationInMultipleTranslationUnitsTest fixture is defined in
 // gtest-param-test_test.h
-INSTANTIATE_TEST_SUITE_P(Sequence2,
-                         InstantiationInMultipleTranslationUnitsTest,
-                         Values(42*3, 42*4, 42*5));
-
+INSTANTIATE_TEST_SUITE_P(Sequence2, InstantiationInMultipleTranslationUnitsTest,
+                         Values(42 * 3, 42 * 4, 42 * 5));
diff --git a/googletest/googletest/test/googletest-port-test.cc b/googletest/googletest/test/googletest-port-test.cc
index 1e0c8616322a727e90dab4ef194ccbb035c120ab..bb536ac546652668d64d8326125b65b935989d73 100644
--- a/googletest/googletest/test/googletest-port-test.cc
+++ b/googletest/googletest/test/googletest-port-test.cc
@@ -33,16 +33,19 @@
 #include "gtest/internal/gtest-port.h"
 
 #if GTEST_OS_MAC
-# include <time.h>
+#include <time.h>
 #endif  // GTEST_OS_MAC
 
+#include <chrono>  // NOLINT
 #include <list>
 #include <memory>
+#include <string>
+#include <thread>   // NOLINT
 #include <utility>  // For std::pair and std::make_pair.
 #include <vector>
 
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 #include "src/gtest-internal-inl.h"
 
 using std::make_pair;
@@ -236,8 +239,8 @@ TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
   }
 
   switch (0)
-    case 0:
-      GTEST_CHECK_(true) << "Check failed in switch case";
+  case 0:
+    GTEST_CHECK_(true) << "Check failed in switch case";
 }
 
 // Verifies behavior of FormatFileLocation.
@@ -279,8 +282,8 @@ TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
 }
 
 #if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX || GTEST_OS_FUCHSIA || \
-    GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+    GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD ||    \
+    GTEST_OS_NETBSD || GTEST_OS_OPENBSD || GTEST_OS_GNU_HURD
 void* ThreadFunc(void* data) {
   internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
   mutex->Lock();
@@ -289,36 +292,61 @@ void* ThreadFunc(void* data) {
 }
 
 TEST(GetThreadCountTest, ReturnsCorrectValue) {
-  const size_t starting_count = GetThreadCount();
-  pthread_t       thread_id;
+  size_t starting_count;
+  size_t thread_count_after_create;
+  size_t thread_count_after_join;
+
+  // We can't guarantee that no other thread was created or destroyed between
+  // any two calls to GetThreadCount(). We make multiple attempts, hoping that
+  // background noise is not constant and we would see the "right" values at
+  // some point.
+  for (int attempt = 0; attempt < 20; ++attempt) {
+    starting_count = GetThreadCount();
+    pthread_t thread_id;
+
+    internal::Mutex mutex;
+    {
+      internal::MutexLock lock(&mutex);
+      pthread_attr_t attr;
+      ASSERT_EQ(0, pthread_attr_init(&attr));
+      ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
+
+      const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
+      ASSERT_EQ(0, pthread_attr_destroy(&attr));
+      ASSERT_EQ(0, status);
+    }
 
-  internal::Mutex mutex;
-  {
-    internal::MutexLock lock(&mutex);
-    pthread_attr_t  attr;
-    ASSERT_EQ(0, pthread_attr_init(&attr));
-    ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
-
-    const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
-    ASSERT_EQ(0, pthread_attr_destroy(&attr));
-    ASSERT_EQ(0, status);
-    EXPECT_EQ(starting_count + 1, GetThreadCount());
-  }
+    thread_count_after_create = GetThreadCount();
 
-  void* dummy;
-  ASSERT_EQ(0, pthread_join(thread_id, &dummy));
+    void* dummy;
+    ASSERT_EQ(0, pthread_join(thread_id, &dummy));
 
-  // The OS may not immediately report the updated thread count after
-  // joining a thread, causing flakiness in this test. To counter that, we
-  // wait for up to .5 seconds for the OS to report the correct value.
-  for (int i = 0; i < 5; ++i) {
-    if (GetThreadCount() == starting_count)
-      break;
+    // Join before we decide whether we need to retry the test. Retry if an
+    // arbitrary other thread was created or destroyed in the meantime.
+    if (thread_count_after_create != starting_count + 1) continue;
+
+    // The OS may not immediately report the updated thread count after
+    // joining a thread, causing flakiness in this test. To counter that, we
+    // wait for up to .5 seconds for the OS to report the correct value.
+    bool thread_count_matches = false;
+    for (int i = 0; i < 5; ++i) {
+      thread_count_after_join = GetThreadCount();
+      if (thread_count_after_join == starting_count) {
+        thread_count_matches = true;
+        break;
+      }
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
+    // Retry if an arbitrary other thread was created or destroyed.
+    if (!thread_count_matches) continue;
 
-    SleepMilliseconds(100);
+    break;
   }
 
-  EXPECT_EQ(starting_count, GetThreadCount());
+  EXPECT_EQ(thread_count_after_create, starting_count + 1);
+  EXPECT_EQ(thread_count_after_join, starting_count);
 }
 #else
 TEST(GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads) {
@@ -330,13 +358,13 @@ TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
   const bool a_false_condition = false;
   const char regex[] =
 #ifdef _MSC_VER
-     "googletest-port-test\\.cc\\(\\d+\\):"
+      "googletest-port-test\\.cc\\(\\d+\\):"
 #elif GTEST_USES_POSIX_RE
-     "googletest-port-test\\.cc:[0-9]+"
+      "googletest-port-test\\.cc:[0-9]+"
 #else
-     "googletest-port-test\\.cc:\\d+"
+      "googletest-port-test\\.cc:\\d+"
 #endif  // _MSC_VER
-     ".*a_false_condition.*Extra info.*";
+      ".*a_false_condition.*Extra info.*";
 
   EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
                             regex);
@@ -345,10 +373,12 @@ TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
 #if GTEST_HAS_DEATH_TEST
 
 TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
-  EXPECT_EXIT({
-      GTEST_CHECK_(true) << "Extra info";
-      ::std::cerr << "Success\n";
-      exit(0); },
+  EXPECT_EXIT(
+      {
+        GTEST_CHECK_(true) << "Extra info";
+        ::std::cerr << "Success\n";
+        exit(0);
+      },
       ::testing::ExitedWithCode(0), "Success");
 }
 
@@ -358,17 +388,13 @@ TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
 // the platform. The test will produce compiler errors in case of failure.
 // For simplicity, we only cover the most important platforms here.
 TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
-#if !GTEST_USES_PCRE
-# if GTEST_HAS_POSIX_RE
-
+#if GTEST_HAS_ABSL
+  EXPECT_TRUE(GTEST_USES_RE2);
+#elif GTEST_HAS_POSIX_RE
   EXPECT_TRUE(GTEST_USES_POSIX_RE);
-
-# else
-
+#else
   EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
-
-# endif
-#endif  // !GTEST_USES_PCRE
+#endif
 }
 
 #if GTEST_USES_POSIX_RE
@@ -396,9 +422,9 @@ TYPED_TEST(RETest, ImplicitConstructorWorks) {
 
 // Tests that RE's constructors reject invalid regular expressions.
 TYPED_TEST(RETest, RejectsInvalidRegex) {
-  EXPECT_NONFATAL_FAILURE({
-    const RE invalid(TypeParam("?"));
-  }, "\"?\" is not a valid POSIX Extended regular expression.");
+  EXPECT_NONFATAL_FAILURE(
+      { const RE invalid(TypeParam("?")); },
+      "\"?\" is not a valid POSIX Extended regular expression.");
 }
 
 // Tests RE::FullMatch().
@@ -792,8 +818,7 @@ TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetition) {
   EXPECT_TRUE(MatchRegexAtHead("a?b", "ab"));
 }
 
-TEST(MatchRegexAtHeadTest,
-     WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
+TEST(MatchRegexAtHeadTest, WorksWhenRegexStartsWithRepetionOfEscapeSequence) {
   EXPECT_FALSE(MatchRegexAtHead("\\.+a", "abc"));
   EXPECT_FALSE(MatchRegexAtHead("\\s?b", "  b"));
 
@@ -849,17 +874,14 @@ TEST(RETest, ImplicitConstructorWorks) {
 
 // Tests that RE's constructors reject invalid regular expressions.
 TEST(RETest, RejectsInvalidRegex) {
-  EXPECT_NONFATAL_FAILURE({
-    const RE normal(NULL);
-  }, "NULL is not a valid simple regular expression");
+  EXPECT_NONFATAL_FAILURE({ const RE normal(NULL); },
+                          "NULL is not a valid simple regular expression");
 
-  EXPECT_NONFATAL_FAILURE({
-    const RE normal(".*(\\w+");
-  }, "'(' is unsupported");
+  EXPECT_NONFATAL_FAILURE({ const RE normal(".*(\\w+"); },
+                          "'(' is unsupported");
 
-  EXPECT_NONFATAL_FAILURE({
-    const RE invalid("^?");
-  }, "'?' can only follow a repeatable token");
+  EXPECT_NONFATAL_FAILURE({ const RE invalid("^?"); },
+                          "'?' can only follow a repeatable token");
 }
 
 // Tests RE::FullMatch().
@@ -1001,12 +1023,13 @@ TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
 TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
   // AssertHeld() is flaky only in the presence of multiple threads accessing
   // the lock. In this case, the test is robust.
-  EXPECT_DEATH_IF_SUPPORTED({
-    Mutex m;
-    { MutexLock lock(&m); }
-    m.AssertHeld();
-  },
-  "thread .*hold");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        Mutex m;
+        { MutexLock lock(&m); }
+        m.AssertHeld();
+      },
+      "thread .*hold");
 }
 
 TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
@@ -1017,15 +1040,15 @@ TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
 
 class AtomicCounterWithMutex {
  public:
-  explicit AtomicCounterWithMutex(Mutex* mutex) :
-    value_(0), mutex_(mutex), random_(42) {}
+  explicit AtomicCounterWithMutex(Mutex* mutex)
+      : value_(0), mutex_(mutex), random_(42) {}
 
   void Increment() {
     MutexLock lock(mutex_);
     int temp = value_;
     {
       // We need to put up a memory barrier to prevent reads and writes to
-      // value_ rearranged with the call to SleepMilliseconds when observed
+      // value_ rearranged with the call to sleep_for when observed
       // from other threads.
 #if GTEST_HAS_PTHREAD
       // On POSIX, locking a mutex puts up a memory barrier.  We cannot use
@@ -1036,7 +1059,8 @@ class AtomicCounterWithMutex {
           pthread_mutex_init(&memory_barrier_mutex, nullptr));
       GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
 
-      SleepMilliseconds(static_cast<int>(random_.Generate(30)));
+      std::this_thread::sleep_for(
+          std::chrono::milliseconds(random_.Generate(30)));
 
       GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
       GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex));
@@ -1044,10 +1068,11 @@ class AtomicCounterWithMutex {
       // On Windows, performing an interlocked access puts up a memory barrier.
       volatile LONG dummy = 0;
       ::InterlockedIncrement(&dummy);
-      SleepMilliseconds(static_cast<int>(random_.Generate(30)));
+      std::this_thread::sleep_for(
+          std::chrono::milliseconds(random_.Generate(30)));
       ::InterlockedIncrement(&dummy);
 #else
-# error "Memory barrier not implemented on this platform."
+#error "Memory barrier not implemented on this platform."
 #endif  // GTEST_HAS_PTHREAD
     }
     value_ = temp + 1;
@@ -1057,12 +1082,11 @@ class AtomicCounterWithMutex {
  private:
   volatile int value_;
   Mutex* const mutex_;  // Protects value_.
-  Random       random_;
+  Random random_;
 };
 
 void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
-  for (int i = 0; i < param.second; ++i)
-      param.first->Increment();
+  for (int i = 0; i < param.second; ++i) param.first->Increment();
 }
 
 // Tests that the mutex only lets one thread at a time to lock it.
@@ -1078,14 +1102,12 @@ TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
   // Creates and runs kThreadCount threads that increment locked_counter
   // kCycleCount times each.
   for (int i = 0; i < kThreadCount; ++i) {
-    counting_threads[i].reset(new ThreadType(&CountingThreadFunc,
-                                             make_pair(&locked_counter,
-                                                       kCycleCount),
-                                             &threads_can_start));
+    counting_threads[i].reset(new ThreadType(
+        &CountingThreadFunc, make_pair(&locked_counter, kCycleCount),
+        &threads_can_start));
   }
   threads_can_start.Notify();
-  for (int i = 0; i < kThreadCount; ++i)
-    counting_threads[i]->Join();
+  for (int i = 0; i < kThreadCount; ++i) counting_threads[i]->Join();
 
   // If the mutex lets more than one thread to increment the counter at a
   // time, they are likely to encounter a race condition and have some
@@ -1095,7 +1117,7 @@ TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
 }
 
 template <typename T>
-void RunFromThread(void (func)(T), T param) {
+void RunFromThread(void(func)(T), T param) {
   ThreadWithParam<T> thread(func, param, nullptr);
   thread.Join();
 }
@@ -1161,7 +1183,8 @@ class DestructorCall {
 #endif
   static std::vector<DestructorCall*>* const list_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DestructorCall);
+  DestructorCall(const DestructorCall&) = delete;
+  DestructorCall& operator=(const DestructorCall&) = delete;
 };
 
 std::vector<DestructorCall*>* const DestructorCall::list_ =
diff --git a/googletest/googletest/test/googletest-printers-test.cc b/googletest/googletest/test/googletest-printers-test.cc
index e1e8e1c7a083bb956572ff74f5589a16090571a3..8a7db25b0c8fdf273b696666fc8fe4c7bccec567 100644
--- a/googletest/googletest/test/googletest-printers-test.cc
+++ b/googletest/googletest/test/googletest-printers-test.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Test - The Google C++ Testing and Mocking Framework
 //
 // This file tests the universal value printer.
@@ -38,6 +37,7 @@
 #include <cstring>
 #include <deque>
 #include <forward_list>
+#include <functional>
 #include <limits>
 #include <list>
 #include <map>
@@ -56,30 +56,20 @@
 // Some user-defined types for testing the universal value printer.
 
 // An anonymous enum type.
-enum AnonymousEnum {
-  kAE1 = -1,
-  kAE2 = 1
-};
+enum AnonymousEnum { kAE1 = -1, kAE2 = 1 };
 
 // An enum without a user-defined printer.
-enum EnumWithoutPrinter {
-  kEWP1 = -2,
-  kEWP2 = 42
-};
+enum EnumWithoutPrinter { kEWP1 = -2, kEWP2 = 42 };
 
 // An enum with a << operator.
-enum EnumWithStreaming {
-  kEWS1 = 10
-};
+enum EnumWithStreaming { kEWS1 = 10 };
 
 std::ostream& operator<<(std::ostream& os, EnumWithStreaming e) {
   return os << (e == kEWS1 ? "kEWS1" : "invalid");
 }
 
 // An enum with a PrintTo() function.
-enum EnumWithPrintTo {
-  kEWPT1 = 1
-};
+enum EnumWithPrintTo { kEWPT1 = 1 };
 
 void PrintTo(EnumWithPrintTo e, std::ostream* os) {
   *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
@@ -108,6 +98,7 @@ template <typename T>
 class UnprintableTemplateInGlobal {
  public:
   UnprintableTemplateInGlobal() : value_() {}
+
  private:
   T value_;
 };
@@ -133,6 +124,7 @@ class UnprintableInFoo {
  public:
   UnprintableInFoo() : z_(0) { memcpy(xy_, "\xEF\x12\x0\x0\x34\xAB\x0\x0", 8); }
   double z() const { return z_; }
+
  private:
   char xy_[8];
   double z_;
@@ -149,8 +141,7 @@ void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
 }
 
 // A type with a user-defined << for printing its pointer.
-struct PointerPrintable {
-};
+struct PointerPrintable {};
 
 ::std::ostream& operator<<(::std::ostream& os,
                            const PointerPrintable* /* x */) {
@@ -164,6 +155,7 @@ class PrintableViaPrintToTemplate {
   explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
 
   const T& value() const { return value_; }
+
  private:
   T value_;
 };
@@ -180,6 +172,7 @@ class StreamableTemplateInFoo {
   StreamableTemplateInFoo() : value_() {}
 
   const T& value() const { return value_; }
+
  private:
   T value_;
 };
@@ -201,6 +194,11 @@ OutputStream& operator<<(OutputStream& os,
   return os;
 }
 
+struct StreamableInLocal {};
+void operator<<(::std::ostream& os, const StreamableInLocal& /* x */) {
+  os << "StreamableInLocal";
+}
+
 // A user-defined streamable but recursively-defined container type in
 // a user namespace, it mimics therefore std::filesystem::path or
 // boost::filesystem::path.
@@ -255,7 +253,6 @@ class UniversalPrinter<Wrapper<T>> {
 };
 }  // namespace internal
 
-
 namespace gtest_printers_test {
 
 using ::std::deque;
@@ -350,29 +347,21 @@ TEST(PrintCharTest, PlainChar) {
 // signed char.
 TEST(PrintCharTest, SignedChar) {
   EXPECT_EQ("'\\0'", Print(static_cast<signed char>('\0')));
-  EXPECT_EQ("'\\xCE' (-50)",
-            Print(static_cast<signed char>(-50)));
+  EXPECT_EQ("'\\xCE' (-50)", Print(static_cast<signed char>(-50)));
 }
 
 // unsigned char.
 TEST(PrintCharTest, UnsignedChar) {
   EXPECT_EQ("'\\0'", Print(static_cast<unsigned char>('\0')));
-  EXPECT_EQ("'b' (98, 0x62)",
-            Print(static_cast<unsigned char>('b')));
+  EXPECT_EQ("'b' (98, 0x62)", Print(static_cast<unsigned char>('b')));
 }
 
-TEST(PrintCharTest, Char16) {
-  EXPECT_EQ("U+0041", Print(u'A'));
-}
+TEST(PrintCharTest, Char16) { EXPECT_EQ("U+0041", Print(u'A')); }
 
-TEST(PrintCharTest, Char32) {
-  EXPECT_EQ("U+0041", Print(U'A'));
-}
+TEST(PrintCharTest, Char32) { EXPECT_EQ("U+0041", Print(U'A')); }
 
 #ifdef __cpp_char8_t
-TEST(PrintCharTest, Char8) {
-  EXPECT_EQ("U+0041", Print(u8'A'));
-}
+TEST(PrintCharTest, Char8) { EXPECT_EQ("U+0041", Print(u8'A')); }
 #endif
 
 // Tests printing other simple, built-in types.
@@ -414,8 +403,8 @@ TEST(PrintTypeSizeTest, Wchar_t) {
 TEST(PrintBuiltInTypeTest, Integer) {
   EXPECT_EQ("'\\xFF' (255)", Print(static_cast<unsigned char>(255)));  // uint8
   EXPECT_EQ("'\\x80' (-128)", Print(static_cast<signed char>(-128)));  // int8
-  EXPECT_EQ("65535", Print(std::numeric_limits<uint16_t>::max()));  // uint16
-  EXPECT_EQ("-32768", Print(std::numeric_limits<int16_t>::min()));  // int16
+  EXPECT_EQ("65535", Print(std::numeric_limits<uint16_t>::max()));     // uint16
+  EXPECT_EQ("-32768", Print(std::numeric_limits<int16_t>::min()));     // int16
   EXPECT_EQ("4294967295",
             Print(std::numeric_limits<uint32_t>::max()));  // uint32
   EXPECT_EQ("-2147483648",
@@ -446,15 +435,51 @@ TEST(PrintBuiltInTypeTest, Size_t) {
 #if !GTEST_OS_WINDOWS
   // Windows has no ssize_t type.
   EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2)));  // ssize_t.
-#endif  // !GTEST_OS_WINDOWS
+#endif                                               // !GTEST_OS_WINDOWS
 }
 
+// gcc/clang __{u,}int128_t values.
+#if defined(__SIZEOF_INT128__)
+TEST(PrintBuiltInTypeTest, Int128) {
+  // Small ones
+  EXPECT_EQ("0", Print(__int128_t{0}));
+  EXPECT_EQ("0", Print(__uint128_t{0}));
+  EXPECT_EQ("12345", Print(__int128_t{12345}));
+  EXPECT_EQ("12345", Print(__uint128_t{12345}));
+  EXPECT_EQ("-12345", Print(__int128_t{-12345}));
+
+  // Large ones
+  EXPECT_EQ("340282366920938463463374607431768211455", Print(~__uint128_t{}));
+  __int128_t max_128 = static_cast<__int128_t>(~__uint128_t{} / 2);
+  EXPECT_EQ("-170141183460469231731687303715884105728", Print(~max_128));
+  EXPECT_EQ("170141183460469231731687303715884105727", Print(max_128));
+}
+#endif  // __SIZEOF_INT128__
+
 // Floating-points.
 TEST(PrintBuiltInTypeTest, FloatingPoints) {
-  EXPECT_EQ("1.5", Print(1.5f));   // float
+  // float (32-bit precision)
+  EXPECT_EQ("1.5", Print(1.5f));
+
+  EXPECT_EQ("1.0999999",  Print(1.09999990f));
+  EXPECT_EQ("1.1",        Print(1.10000002f));
+  EXPECT_EQ("1.10000014", Print(1.10000014f));
+  EXPECT_EQ("9e+09",      Print(9e9f));
+
+  // double
   EXPECT_EQ("-2.5", Print(-2.5));  // double
 }
 
+#if GTEST_HAS_RTTI
+TEST(PrintBuiltInTypeTest, TypeInfo) {
+  struct MyStruct {};
+  auto res = Print(typeid(MyStruct{}));
+  // We can't guarantee that we can demangle the name, but either name should
+  // contain the substring "MyStruct".
+  EXPECT_NE(res.find("MyStruct"), res.npos) << res;
+}
+#endif  // GTEST_HAS_RTTI
+
 // Since ::std::stringstream::operator<<(const void *) formats the pointer
 // output differently with different compilers, we have to create the expected
 // output first and use it as our expectation.
@@ -488,8 +513,9 @@ TEST(PrintCStringTest, Null) {
 // Tests that C strings are escaped properly.
 TEST(PrintCStringTest, EscapesProperly) {
   const char* p = "'\"?\\\a\b\f\n\r\t\v\x7F\xFF a";
-  EXPECT_EQ(PrintPointer(p) + " pointing to \"'\\\"?\\\\\\a\\b\\f"
-            "\\n\\r\\t\\v\\x7F\\xFF a\"",
+  EXPECT_EQ(PrintPointer(p) +
+                " pointing to \"'\\\"?\\\\\\a\\b\\f"
+                "\\n\\r\\t\\v\\x7F\\xFF a\"",
             Print(p));
 }
 
@@ -608,10 +634,12 @@ TEST(PrintWideCStringTest, Null) {
 
 // Tests that wide C strings are escaped properly.
 TEST(PrintWideCStringTest, EscapesProperly) {
-  const wchar_t s[] = {'\'', '"', '?', '\\', '\a', '\b', '\f', '\n', '\r',
-                       '\t', '\v', 0xD3, 0x576, 0x8D3, 0xC74D, ' ', 'a', '\0'};
-  EXPECT_EQ(PrintPointer(s) + " pointing to L\"'\\\"?\\\\\\a\\b\\f"
-            "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
+  const wchar_t s[] = {'\'',  '"',   '?',    '\\', '\a', '\b',
+                       '\f',  '\n',  '\r',   '\t', '\v', 0xD3,
+                       0x576, 0x8D3, 0xC74D, ' ',  'a',  '\0'};
+  EXPECT_EQ(PrintPointer(s) +
+                " pointing to L\"'\\\"?\\\\\\a\\b\\f"
+                "\\n\\r\\t\\v\\xD3\\x576\\x8D3\\xC74D a\"",
             Print(static_cast<const wchar_t*>(s)));
 }
 #endif  // native wchar_t
@@ -693,10 +721,9 @@ TEST(PrintPointerTest, NonMemberFunctionPointer) {
   // standard disallows casting between pointers to functions and
   // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
   // this limitation.
-  EXPECT_EQ(
-      PrintPointer(reinterpret_cast<const void*>(
-          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
-      Print(&MyFunction));
+  EXPECT_EQ(PrintPointer(reinterpret_cast<const void*>(
+                reinterpret_cast<internal::BiggestInt>(&MyFunction))),
+            Print(&MyFunction));
   int (*p)(bool) = NULL;  // NOLINT
   EXPECT_EQ("NULL", Print(p));
 }
@@ -705,14 +732,13 @@ TEST(PrintPointerTest, NonMemberFunctionPointer) {
 // another.
 template <typename StringType>
 AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {
-  if (str.find(prefix, 0) == 0)
-    return AssertionSuccess();
+  if (str.find(prefix, 0) == 0) return AssertionSuccess();
 
   const bool is_wide_string = sizeof(prefix[0]) > 1;
   const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
   return AssertionFailure()
-      << begin_string_quote << prefix << "\" is not a prefix of "
-      << begin_string_quote << str << "\"\n";
+         << begin_string_quote << prefix << "\" is not a prefix of "
+         << begin_string_quote << str << "\"\n";
 }
 
 // Tests printing member variable pointers.  Although they are called
@@ -733,8 +759,7 @@ TEST(PrintPointerTest, MemberVariablePointer) {
   EXPECT_TRUE(HasPrefix(Print(&Foo::value),
                         Print(sizeof(&Foo::value)) + "-byte object "));
   int Foo::*p = NULL;  // NOLINT
-  EXPECT_TRUE(HasPrefix(Print(p),
-                        Print(sizeof(p)) + "-byte object "));
+  EXPECT_TRUE(HasPrefix(Print(p), Print(sizeof(p)) + "-byte object "));
 }
 
 // Tests printing member function pointers.  Although they are called
@@ -748,8 +773,7 @@ TEST(PrintPointerTest, MemberFunctionPointer) {
       HasPrefix(Print(&Foo::MyVirtualMethod),
                 Print(sizeof((&Foo::MyVirtualMethod))) + "-byte object "));
   int (Foo::*p)(char) = NULL;  // NOLINT
-  EXPECT_TRUE(HasPrefix(Print(p),
-                        Print(sizeof(p)) + "-byte object "));
+  EXPECT_TRUE(HasPrefix(Print(p), Print(sizeof(p)) + "-byte object "));
 }
 
 // Tests printing C arrays.
@@ -763,29 +787,26 @@ std::string PrintArrayHelper(T (&a)[N]) {
 
 // One-dimensional array.
 TEST(PrintArrayTest, OneDimensionalArray) {
-  int a[5] = { 1, 2, 3, 4, 5 };
+  int a[5] = {1, 2, 3, 4, 5};
   EXPECT_EQ("{ 1, 2, 3, 4, 5 }", PrintArrayHelper(a));
 }
 
 // Two-dimensional array.
 TEST(PrintArrayTest, TwoDimensionalArray) {
-  int a[2][5] = {
-    { 1, 2, 3, 4, 5 },
-    { 6, 7, 8, 9, 0 }
-  };
+  int a[2][5] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 0}};
   EXPECT_EQ("{ { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 0 } }", PrintArrayHelper(a));
 }
 
 // Array of const elements.
 TEST(PrintArrayTest, ConstArray) {
-  const bool a[1] = { false };
+  const bool a[1] = {false};
   EXPECT_EQ("{ false }", PrintArrayHelper(a));
 }
 
 // char array without terminating NUL.
 TEST(PrintArrayTest, CharArrayWithNoTerminatingNul) {
   // Array a contains '\0' in the middle and doesn't end with '\0'.
-  char a[] = { 'H', '\0', 'i' };
+  char a[] = {'H', '\0', 'i'};
   EXPECT_EQ("\"H\\0i\" (no terminating NUL)", PrintArrayHelper(a));
 }
 
@@ -806,9 +827,7 @@ TEST(PrintArrayTest, Char8ArrayWithNoTerminatingNul) {
 // char8_t array with terminating NUL.
 TEST(PrintArrayTest, Char8ArrayWithTerminatingNul) {
   const char8_t a[] = u8"\0世界";
-  EXPECT_EQ(
-      "u8\"\\0\\xE4\\xB8\\x96\\xE7\\x95\\x8C\"",
-      PrintArrayHelper(a));
+  EXPECT_EQ("u8\"\\0\\xE4\\xB8\\x96\\xE7\\x95\\x8C\"", PrintArrayHelper(a));
 }
 #endif
 
@@ -861,7 +880,7 @@ TEST(PrintArrayTest, ObjectArray) {
 
 // Array with many elements.
 TEST(PrintArrayTest, BigArray) {
-  int a[100] = { 1, 2, 3 };
+  int a[100] = {1, 2, 3};
   EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0 }",
             PrintArrayHelper(a));
 }
@@ -881,11 +900,14 @@ TEST(PrintStringTest, StringAmbiguousHex) {
   // '\x6', '\x6B', or '\x6BA'.
 
   // a hex escaping sequence following by a decimal digit
-  EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12" "3")));
+  EXPECT_EQ("\"0\\x12\" \"3\"", Print(::std::string("0\x12"
+                                                    "3")));
   // a hex escaping sequence following by a hex digit (lower-case)
-  EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6" "bananas")));
+  EXPECT_EQ("\"mm\\x6\" \"bananas\"", Print(::std::string("mm\x6"
+                                                          "bananas")));
   // a hex escaping sequence following by a hex digit (upper-case)
-  EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6" "BANANA")));
+  EXPECT_EQ("\"NOM\\x6\" \"BANANA\"", Print(::std::string("NOM\x6"
+                                                          "BANANA")));
   // a hex escaping sequence following by a non-xdigit
   EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
 }
@@ -895,19 +917,21 @@ TEST(PrintStringTest, StringAmbiguousHex) {
 // ::std::wstring.
 TEST(PrintWideStringTest, StringInStdNamespace) {
   const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
-  const ::std::wstring str(s, sizeof(s)/sizeof(wchar_t));
-  EXPECT_EQ("L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
-            "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
-            Print(str));
+  const ::std::wstring str(s, sizeof(s) / sizeof(wchar_t));
+  EXPECT_EQ(
+      "L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
+      "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
+      Print(str));
 }
 
 TEST(PrintWideStringTest, StringAmbiguousHex) {
   // same for wide strings.
-  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12" L"3")));
-  EXPECT_EQ("L\"mm\\x6\" L\"bananas\"",
-            Print(::std::wstring(L"mm\x6" L"bananas")));
-  EXPECT_EQ("L\"NOM\\x6\" L\"BANANA\"",
-            Print(::std::wstring(L"NOM\x6" L"BANANA")));
+  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12"
+                                                       L"3")));
+  EXPECT_EQ("L\"mm\\x6\" L\"bananas\"", Print(::std::wstring(L"mm\x6"
+                                                             L"bananas")));
+  EXPECT_EQ("L\"NOM\\x6\" L\"BANANA\"", Print(::std::wstring(L"NOM\x6"
+                                                             L"BANANA")));
   EXPECT_EQ("L\"!\\x5-!\"", Print(::std::wstring(L"!\x5-!")));
 }
 #endif  // GTEST_HAS_STD_WSTRING
@@ -1021,7 +1045,6 @@ TEST(PrintStlContainerTest, NonEmptyDeque) {
   EXPECT_EQ("{ 1, 3 }", Print(non_empty));
 }
 
-
 TEST(PrintStlContainerTest, OneElementHashMap) {
   ::std::unordered_map<int, char> map1;
   map1[1] = 'a';
@@ -1037,11 +1060,9 @@ TEST(PrintStlContainerTest, HashMultiMap) {
   const std::string result = Print(map1);
   EXPECT_TRUE(result == "{ (5, true), (5, false) }" ||
               result == "{ (5, false), (5, true) }")
-                  << " where Print(map1) returns \"" << result << "\".";
+      << " where Print(map1) returns \"" << result << "\".";
 }
 
-
-
 TEST(PrintStlContainerTest, HashSet) {
   ::std::unordered_set<int> set1;
   set1.insert(1);
@@ -1050,7 +1071,7 @@ TEST(PrintStlContainerTest, HashSet) {
 
 TEST(PrintStlContainerTest, HashMultiSet) {
   const int kSize = 5;
-  int a[kSize] = { 1, 1, 2, 5, 1 };
+  int a[kSize] = {1, 1, 2, 5, 1};
   ::std::unordered_multiset<int> set1(a, a + kSize);
 
   // Elements of hash_multiset can be printed in any order.
@@ -1066,8 +1087,8 @@ TEST(PrintStlContainerTest, HashMultiSet) {
       ASSERT_NE(isdigit(static_cast<unsigned char>(result[i])), 0);
       numbers.push_back(result[i] - '0');
     } else {
-      EXPECT_EQ(expected_pattern[i], result[i]) << " where result is "
-                                                << result;
+      EXPECT_EQ(expected_pattern[i], result[i])
+          << " where result is " << result;
     }
   }
 
@@ -1077,7 +1098,6 @@ TEST(PrintStlContainerTest, HashMultiSet) {
   EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
 }
 
-
 TEST(PrintStlContainerTest, List) {
   const std::string a[] = {"hello", "world"};
   const list<std::string> strings(a, a + 2);
@@ -1107,20 +1127,19 @@ TEST(PrintStlContainerTest, MultiMap) {
 }
 
 TEST(PrintStlContainerTest, Set) {
-  const unsigned int a[] = { 3, 0, 5 };
+  const unsigned int a[] = {3, 0, 5};
   set<unsigned int> set1(a, a + 3);
   EXPECT_EQ("{ 0, 3, 5 }", Print(set1));
 }
 
 TEST(PrintStlContainerTest, MultiSet) {
-  const int a[] = { 1, 1, 2, 5, 1 };
+  const int a[] = {1, 1, 2, 5, 1};
   multiset<int> set1(a, a + 5);
   EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
 }
 
-
 TEST(PrintStlContainerTest, SinglyLinkedList) {
-  int a[] = { 9, 2, 8 };
+  int a[] = {9, 2, 8};
   const std::forward_list<int> ints(a, a + 3);
   EXPECT_EQ("{ 9, 2, 8 }", Print(ints));
 }
@@ -1138,32 +1157,34 @@ TEST(PrintStlContainerTest, Vector) {
 }
 
 TEST(PrintStlContainerTest, LongSequence) {
-  const int a[100] = { 1, 2, 3 };
+  const int a[100] = {1, 2, 3};
   const vector<int> v(a, a + 100);
-  EXPECT_EQ("{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
-            "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }", Print(v));
+  EXPECT_EQ(
+      "{ 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
+      "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... }",
+      Print(v));
 }
 
 TEST(PrintStlContainerTest, NestedContainer) {
-  const int a1[] = { 1, 2 };
-  const int a2[] = { 3, 4, 5 };
+  const int a1[] = {1, 2};
+  const int a2[] = {3, 4, 5};
   const list<int> l1(a1, a1 + 2);
   const list<int> l2(a2, a2 + 3);
 
-  vector<list<int> > v;
+  vector<list<int>> v;
   v.push_back(l1);
   v.push_back(l2);
   EXPECT_EQ("{ { 1, 2 }, { 3, 4, 5 } }", Print(v));
 }
 
 TEST(PrintStlContainerTest, OneDimensionalNativeArray) {
-  const int a[3] = { 1, 2, 3 };
+  const int a[3] = {1, 2, 3};
   NativeArray<int> b(a, 3, RelationToSourceReference());
   EXPECT_EQ("{ 1, 2, 3 }", Print(b));
 }
 
 TEST(PrintStlContainerTest, TwoDimensionalNativeArray) {
-  const int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
+  const int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
   NativeArray<int[3]> b(a, 2, RelationToSourceReference());
   EXPECT_EQ("{ { 1, 2, 3 }, { 4, 5, 6 } }", Print(b));
 }
@@ -1215,20 +1236,18 @@ TEST(PrintStdTupleTest, VariousSizes) {
       t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,  // NOLINT
           nullptr, "10");
   EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
-            " pointing to \"8\", NULL, \"10\")",
+                " pointing to \"8\", NULL, \"10\")",
             Print(t10));
 }
 
 // Nested tuples.
 TEST(PrintStdTupleTest, NestedTuple) {
-  ::std::tuple< ::std::tuple<int, bool>, char> nested(
-      ::std::make_tuple(5, true), 'a');
+  ::std::tuple<::std::tuple<int, bool>, char> nested(::std::make_tuple(5, true),
+                                                     'a');
   EXPECT_EQ("((5, true), 'a' (97, 0x61))", Print(nested));
 }
 
-TEST(PrintNullptrT, Basic) {
-  EXPECT_EQ("(nullptr)", Print(nullptr));
-}
+TEST(PrintNullptrT, Basic) { EXPECT_EQ("(nullptr)", Print(nullptr)); }
 
 TEST(PrintReferenceWrapper, Printable) {
   int x = 5;
@@ -1252,8 +1271,7 @@ TEST(PrintReferenceWrapper, Unprintable) {
 
 // Unprintable types in the global namespace.
 TEST(PrintUnprintableTypeTest, InGlobalNamespace) {
-  EXPECT_EQ("1-byte object <00>",
-            Print(UnprintableTemplateInGlobal<char>()));
+  EXPECT_EQ("1-byte object <00>", Print(UnprintableTemplateInGlobal<char>()));
 }
 
 // Unprintable types in a user namespace.
@@ -1270,14 +1288,15 @@ struct Big {
 };
 
 TEST(PrintUnpritableTypeTest, BigObject) {
-  EXPECT_EQ("257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
-            "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
-            Print(Big()));
+  EXPECT_EQ(
+      "257-byte object <00-00 00-00 00-00 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 ... 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 "
+      "00-00 00-00 00-00 00-00 00-00 00-00 00-00 00-00 00>",
+      Print(Big()));
 }
 
 // Tests printing user-defined streamable types.
@@ -1320,8 +1339,7 @@ TEST(PrintStreamableTypeTest, PathLikeInUserNamespace) {
 
 // Tests printing user-defined types that have a PrintTo() function.
 TEST(PrintPrintableTypeTest, InUserNamespace) {
-  EXPECT_EQ("PrintableViaPrintTo: 0",
-            Print(::foo::PrintableViaPrintTo()));
+  EXPECT_EQ("PrintableViaPrintTo: 0", Print(::foo::PrintableViaPrintTo()));
 }
 
 // Tests printing a pointer to a user-defined type that has a <<
@@ -1343,16 +1361,14 @@ TEST(PrintReferenceTest, PrintsAddressAndValue) {
   int n = 5;
   EXPECT_EQ("@" + PrintPointer(&n) + " 5", PrintByRef(n));
 
-  int a[2][3] = {
-    { 0, 1, 2 },
-    { 3, 4, 5 }
-  };
+  int a[2][3] = {{0, 1, 2}, {3, 4, 5}};
   EXPECT_EQ("@" + PrintPointer(a) + " { { 0, 1, 2 }, { 3, 4, 5 } }",
             PrintByRef(a));
 
   const ::foo::UnprintableInFoo x;
-  EXPECT_EQ("@" + PrintPointer(&x) + " 16-byte object "
-            "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
+  EXPECT_EQ("@" + PrintPointer(&x) +
+                " 16-byte object "
+                "<EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
             PrintByRef(x));
 }
 
@@ -1368,33 +1384,29 @@ TEST(PrintReferenceTest, HandlesFunctionPointer) {
   // this limitation.
   const std::string fp_string = PrintPointer(reinterpret_cast<const void*>(
       reinterpret_cast<internal::BiggestInt>(fp)));
-  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
-            PrintByRef(fp));
+  EXPECT_EQ("@" + fp_pointer_string + " " + fp_string, PrintByRef(fp));
 }
 
 // Tests that the universal printer prints a member function pointer
 // passed by reference.
 TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
   int (Foo::*p)(char ch) = &Foo::MyMethod;
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p),
-      "@" + PrintPointer(reinterpret_cast<const void*>(&p)) + " " +
-          Print(sizeof(p)) + "-byte object "));
+  EXPECT_TRUE(HasPrefix(PrintByRef(p),
+                        "@" + PrintPointer(reinterpret_cast<const void*>(&p)) +
+                            " " + Print(sizeof(p)) + "-byte object "));
 
   char (Foo::*p2)(int n) = &Foo::MyVirtualMethod;
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p2),
-      "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) + " " +
-          Print(sizeof(p2)) + "-byte object "));
+  EXPECT_TRUE(HasPrefix(PrintByRef(p2),
+                        "@" + PrintPointer(reinterpret_cast<const void*>(&p2)) +
+                            " " + Print(sizeof(p2)) + "-byte object "));
 }
 
 // Tests that the universal printer prints a member variable pointer
 // passed by reference.
 TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
   int Foo::*p = &Foo::value;  // NOLINT
-  EXPECT_TRUE(HasPrefix(
-      PrintByRef(p),
-      "@" + PrintPointer(&p) + " " + Print(sizeof(p)) + "-byte object "));
+  EXPECT_TRUE(HasPrefix(PrintByRef(p), "@" + PrintPointer(&p) + " " +
+                                           Print(sizeof(p)) + "-byte object "));
 }
 
 // Tests that FormatForComparisonFailureMessage(), which is used to print
@@ -1403,8 +1415,7 @@ TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
 
 // scalar
 TEST(FormatForComparisonFailureMessageTest, WorksForScalar) {
-  EXPECT_STREQ("123",
-               FormatForComparisonFailureMessage(123, 124).c_str());
+  EXPECT_STREQ("123", FormatForComparisonFailureMessage(123, 124).c_str());
 }
 
 // non-char pointer
@@ -1418,9 +1429,8 @@ TEST(FormatForComparisonFailureMessageTest, WorksForNonCharPointer) {
 TEST(FormatForComparisonFailureMessageTest, FormatsNonCharArrayAsPointer) {
   // In expression 'array == x', 'array' is compared by pointer.
   // Therefore we want to print an array operand as a pointer.
-  int n[] = { 1, 2, 3 };
-  EXPECT_EQ(PrintPointer(n),
-            FormatForComparisonFailureMessage(n, n).c_str());
+  int n[] = {1, 2, 3};
+  EXPECT_EQ(PrintPointer(n), FormatForComparisonFailureMessage(n, n).c_str());
 }
 
 // Tests formatting a char pointer when it's compared with another pointer.
@@ -1436,8 +1446,7 @@ TEST(FormatForComparisonFailureMessageTest, WorksForCharPointerVsPointer) {
 
   // const char*
   const char* s = "hello";
-  EXPECT_EQ(PrintPointer(s),
-            FormatForComparisonFailureMessage(s, s).c_str());
+  EXPECT_EQ(PrintPointer(s), FormatForComparisonFailureMessage(s, s).c_str());
 
   // char*
   char ch = 'a';
@@ -1454,8 +1463,7 @@ TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsPointer) {
 
   // const wchar_t*
   const wchar_t* s = L"hello";
-  EXPECT_EQ(PrintPointer(s),
-            FormatForComparisonFailureMessage(s, s).c_str());
+  EXPECT_EQ(PrintPointer(s), FormatForComparisonFailureMessage(s, s).c_str());
 
   // wchar_t*
   wchar_t ch = L'a';
@@ -1552,13 +1560,11 @@ TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsStdWString) {
 // Useful for testing PrintToString().  We cannot use EXPECT_EQ()
 // there as its implementation uses PrintToString().  The caller must
 // ensure that 'value' has no side effect.
-#define EXPECT_PRINT_TO_STRING_(value, expected_string)         \
-  EXPECT_TRUE(PrintToString(value) == (expected_string))        \
+#define EXPECT_PRINT_TO_STRING_(value, expected_string)  \
+  EXPECT_TRUE(PrintToString(value) == (expected_string)) \
       << " where " #value " prints as " << (PrintToString(value))
 
-TEST(PrintToStringTest, WorksForScalar) {
-  EXPECT_PRINT_TO_STRING_(123, "123");
-}
+TEST(PrintToStringTest, WorksForScalar) { EXPECT_PRINT_TO_STRING_(123, "123"); }
 
 TEST(PrintToStringTest, WorksForPointerToConstChar) {
   const char* p = "hello";
@@ -1583,7 +1589,7 @@ TEST(PrintToStringTest, EscapesForPointerToNonConstChar) {
 }
 
 TEST(PrintToStringTest, WorksForArray) {
-  int n[3] = { 1, 2, 3 };
+  int n[3] = {1, 2, 3};
   EXPECT_PRINT_TO_STRING_(n, "{ 1, 2, 3 }");
 }
 
@@ -1600,8 +1606,8 @@ TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
   EXPECT_PRINT_TO_STRING_(mutable_str_with_nul, "\"hello\\0 world\"");
 }
 
-  TEST(PrintToStringTest, ContainsNonLatin) {
-  // Sanity test with valid UTF-8. Prints both in hex and as text.
+TEST(PrintToStringTest, ContainsNonLatin) {
+  // Test with valid UTF-8. Prints both in hex and as text.
   std::string non_ascii_str = ::std::string("오전 4:30");
   EXPECT_PRINT_TO_STRING_(non_ascii_str,
                           "\"\\xEC\\x98\\xA4\\xEC\\xA0\\x84 4:30\"\n"
@@ -1612,62 +1618,80 @@ TEST(PrintToStringTest, WorksForCharArrayWithEmbeddedNul) {
                           "\n    As Text: \"From ä — ẑ\"");
 }
 
+TEST(PrintToStringTest, PrintStreamableInLocal) {
+  EXPECT_STREQ("StreamableInLocal",
+               PrintToString(foo::StreamableInLocal()).c_str());
+}
+
+TEST(PrintToStringTest, PrintReferenceToStreamableInLocal) {
+  foo::StreamableInLocal s;
+  std::reference_wrapper<foo::StreamableInLocal> r(s);
+  EXPECT_STREQ("StreamableInLocal", PrintToString(r).c_str());
+}
+
+TEST(PrintToStringTest, PrintReferenceToStreamableInGlobal) {
+  StreamableInGlobal s;
+  std::reference_wrapper<StreamableInGlobal> r(s);
+  EXPECT_STREQ("StreamableInGlobal", PrintToString(r).c_str());
+}
+
 TEST(IsValidUTF8Test, IllFormedUTF8) {
   // The following test strings are ill-formed UTF-8 and are printed
   // as hex only (or ASCII, in case of ASCII bytes) because IsValidUTF8() is
   // expected to fail, thus output does not contain "As Text:".
 
-  static const char *const kTestdata[][2] = {
-    // 2-byte lead byte followed by a single-byte character.
-    {"\xC3\x74", "\"\\xC3t\""},
-    // Valid 2-byte character followed by an orphan trail byte.
-    {"\xC3\x84\xA4", "\"\\xC3\\x84\\xA4\""},
-    // Lead byte without trail byte.
-    {"abc\xC3", "\"abc\\xC3\""},
-    // 3-byte lead byte, single-byte character, orphan trail byte.
-    {"x\xE2\x70\x94", "\"x\\xE2p\\x94\""},
-    // Truncated 3-byte character.
-    {"\xE2\x80", "\"\\xE2\\x80\""},
-    // Truncated 3-byte character followed by valid 2-byte char.
-    {"\xE2\x80\xC3\x84", "\"\\xE2\\x80\\xC3\\x84\""},
-    // Truncated 3-byte character followed by a single-byte character.
-    {"\xE2\x80\x7A", "\"\\xE2\\x80z\""},
-    // 3-byte lead byte followed by valid 3-byte character.
-    {"\xE2\xE2\x80\x94", "\"\\xE2\\xE2\\x80\\x94\""},
-    // 4-byte lead byte followed by valid 3-byte character.
-    {"\xF0\xE2\x80\x94", "\"\\xF0\\xE2\\x80\\x94\""},
-    // Truncated 4-byte character.
-    {"\xF0\xE2\x80", "\"\\xF0\\xE2\\x80\""},
-     // Invalid UTF-8 byte sequences embedded in other chars.
-    {"abc\xE2\x80\x94\xC3\x74xyc", "\"abc\\xE2\\x80\\x94\\xC3txyc\""},
-    {"abc\xC3\x84\xE2\x80\xC3\x84xyz",
-     "\"abc\\xC3\\x84\\xE2\\x80\\xC3\\x84xyz\""},
-    // Non-shortest UTF-8 byte sequences are also ill-formed.
-    // The classics: xC0, xC1 lead byte.
-    {"\xC0\x80", "\"\\xC0\\x80\""},
-    {"\xC1\x81", "\"\\xC1\\x81\""},
-    // Non-shortest sequences.
-    {"\xE0\x80\x80", "\"\\xE0\\x80\\x80\""},
-    {"\xf0\x80\x80\x80", "\"\\xF0\\x80\\x80\\x80\""},
-    // Last valid code point before surrogate range, should be printed as text,
-    // too.
-    {"\xED\x9F\xBF", "\"\\xED\\x9F\\xBF\"\n    As Text: \"퟿\""},
-    // Start of surrogate lead. Surrogates are not printed as text.
-    {"\xED\xA0\x80", "\"\\xED\\xA0\\x80\""},
-    // Last non-private surrogate lead.
-    {"\xED\xAD\xBF", "\"\\xED\\xAD\\xBF\""},
-    // First private-use surrogate lead.
-    {"\xED\xAE\x80", "\"\\xED\\xAE\\x80\""},
-    // Last private-use surrogate lead.
-    {"\xED\xAF\xBF", "\"\\xED\\xAF\\xBF\""},
-    // Mid-point of surrogate trail.
-    {"\xED\xB3\xBF", "\"\\xED\\xB3\\xBF\""},
-    // First valid code point after surrogate range, should be printed as text,
-    // too.
-    {"\xEE\x80\x80", "\"\\xEE\\x80\\x80\"\n    As Text: \"\""}
-  };
-
-  for (int i = 0; i < int(sizeof(kTestdata)/sizeof(kTestdata[0])); ++i) {
+  static const char* const kTestdata[][2] = {
+      // 2-byte lead byte followed by a single-byte character.
+      {"\xC3\x74", "\"\\xC3t\""},
+      // Valid 2-byte character followed by an orphan trail byte.
+      {"\xC3\x84\xA4", "\"\\xC3\\x84\\xA4\""},
+      // Lead byte without trail byte.
+      {"abc\xC3", "\"abc\\xC3\""},
+      // 3-byte lead byte, single-byte character, orphan trail byte.
+      {"x\xE2\x70\x94", "\"x\\xE2p\\x94\""},
+      // Truncated 3-byte character.
+      {"\xE2\x80", "\"\\xE2\\x80\""},
+      // Truncated 3-byte character followed by valid 2-byte char.
+      {"\xE2\x80\xC3\x84", "\"\\xE2\\x80\\xC3\\x84\""},
+      // Truncated 3-byte character followed by a single-byte character.
+      {"\xE2\x80\x7A", "\"\\xE2\\x80z\""},
+      // 3-byte lead byte followed by valid 3-byte character.
+      {"\xE2\xE2\x80\x94", "\"\\xE2\\xE2\\x80\\x94\""},
+      // 4-byte lead byte followed by valid 3-byte character.
+      {"\xF0\xE2\x80\x94", "\"\\xF0\\xE2\\x80\\x94\""},
+      // Truncated 4-byte character.
+      {"\xF0\xE2\x80", "\"\\xF0\\xE2\\x80\""},
+      // Invalid UTF-8 byte sequences embedded in other chars.
+      {"abc\xE2\x80\x94\xC3\x74xyc", "\"abc\\xE2\\x80\\x94\\xC3txyc\""},
+      {"abc\xC3\x84\xE2\x80\xC3\x84xyz",
+       "\"abc\\xC3\\x84\\xE2\\x80\\xC3\\x84xyz\""},
+      // Non-shortest UTF-8 byte sequences are also ill-formed.
+      // The classics: xC0, xC1 lead byte.
+      {"\xC0\x80", "\"\\xC0\\x80\""},
+      {"\xC1\x81", "\"\\xC1\\x81\""},
+      // Non-shortest sequences.
+      {"\xE0\x80\x80", "\"\\xE0\\x80\\x80\""},
+      {"\xf0\x80\x80\x80", "\"\\xF0\\x80\\x80\\x80\""},
+      // Last valid code point before surrogate range, should be printed as
+      // text,
+      // too.
+      {"\xED\x9F\xBF", "\"\\xED\\x9F\\xBF\"\n    As Text: \"퟿\""},
+      // Start of surrogate lead. Surrogates are not printed as text.
+      {"\xED\xA0\x80", "\"\\xED\\xA0\\x80\""},
+      // Last non-private surrogate lead.
+      {"\xED\xAD\xBF", "\"\\xED\\xAD\\xBF\""},
+      // First private-use surrogate lead.
+      {"\xED\xAE\x80", "\"\\xED\\xAE\\x80\""},
+      // Last private-use surrogate lead.
+      {"\xED\xAF\xBF", "\"\\xED\\xAF\\xBF\""},
+      // Mid-point of surrogate trail.
+      {"\xED\xB3\xBF", "\"\\xED\\xB3\\xBF\""},
+      // First valid code point after surrogate range, should be printed as
+      // text,
+      // too.
+      {"\xEE\x80\x80", "\"\\xEE\\x80\\x80\"\n    As Text: \"\""}};
+
+  for (int i = 0; i < int(sizeof(kTestdata) / sizeof(kTestdata[0])); ++i) {
     EXPECT_PRINT_TO_STRING_(kTestdata[i][0], kTestdata[i][1]);
   }
 }
@@ -1816,15 +1840,15 @@ TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
 }
 
 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsOneTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::make_tuple(1));
+  Strings result =
+      UniversalTersePrintTupleFieldsToStrings(::std::make_tuple(1));
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ("1", result[0]);
 }
 
 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTwoTuple) {
-  Strings result = UniversalTersePrintTupleFieldsToStrings(
-      ::std::make_tuple(1, 'a'));
+  Strings result =
+      UniversalTersePrintTupleFieldsToStrings(::std::make_tuple(1, 'a'));
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ("1", result[0]);
   EXPECT_EQ("'a' (97, 0x61)", result[1]);
@@ -1873,6 +1897,7 @@ TEST_F(PrintAnyTest, NonEmpty) {
 
 #if GTEST_INTERNAL_HAS_OPTIONAL
 TEST(PrintOptionalTest, Basic) {
+  EXPECT_EQ("(nullopt)", PrintToString(internal::Nullopt()));
   internal::Optional<int> value;
   EXPECT_EQ("(nullopt)", PrintToString(value));
   value = {7};
diff --git a/googletest/googletest/test/googletest-setuptestsuite-test.py b/googletest/googletest/test/googletest-setuptestsuite-test.py
index c82162fc99f8bbecf4a8caf2ce0a29bf64b3c24a..9d1fd0295cd101c9de195b067a4aa876a9e4b123 100644
--- a/googletest/googletest/test/googletest-setuptestsuite-test.py
+++ b/googletest/googletest/test/googletest-setuptestsuite-test.py
@@ -31,7 +31,7 @@
 
 """Verifies that SetUpTestSuite and TearDownTestSuite errors are noticed."""
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 COMMAND = gtest_test_utils.GetTestExecutablePath(
     'googletest-setuptestsuite-test_')
diff --git a/googletest/googletest/test/googletest-setuptestsuite-test_.cc b/googletest/googletest/test/googletest-setuptestsuite-test_.cc
index a4bc4ef441d9be4802e2c010df8f1c3d96dfaf40..d20899f568661417e1f5d9389a27ec9e0563f9d9 100644
--- a/googletest/googletest/test/googletest-setuptestsuite-test_.cc
+++ b/googletest/googletest/test/googletest-setuptestsuite-test_.cc
@@ -27,23 +27,18 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest.h"
 
 class SetupFailTest : public ::testing::Test {
  protected:
-  static void SetUpTestSuite() {
-    ASSERT_EQ("", "SET_UP_FAIL");
-  }
+  static void SetUpTestSuite() { ASSERT_EQ("", "SET_UP_FAIL"); }
 };
 
 TEST_F(SetupFailTest, NoopPassingTest) {}
 
 class TearDownFailTest : public ::testing::Test {
  protected:
-  static void TearDownTestSuite() {
-    ASSERT_EQ("", "TEAR_DOWN_FAIL");
-  }
+  static void TearDownTestSuite() { ASSERT_EQ("", "TEAR_DOWN_FAIL"); }
 };
 
 TEST_F(TearDownFailTest, NoopPassingTest) {}
diff --git a/googletest/googletest/test/googletest-shuffle-test.py b/googletest/googletest/test/googletest-shuffle-test.py
index 573cc5eca3fce458aa3ac3e39850f47bb382e55b..9d2adc1286b278533faae0e6616db8accd1f2667 100644
--- a/googletest/googletest/test/googletest-shuffle-test.py
+++ b/googletest/googletest/test/googletest-shuffle-test.py
@@ -31,7 +31,7 @@
 """Verifies that test shuffling works."""
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Command to run the googletest-shuffle-test_ program.
 COMMAND = gtest_test_utils.GetTestExecutablePath('googletest-shuffle-test_')
diff --git a/googletest/googletest/test/googletest-shuffle-test_.cc b/googletest/googletest/test/googletest-shuffle-test_.cc
index 4505663ae433c4fd53205c160fbc2ab3e8e66ed4..a14e22f98cf8c8093775ea6b6761f02675e2c0a6 100644
--- a/googletest/googletest/test/googletest-shuffle-test_.cc
+++ b/googletest/googletest/test/googletest-shuffle-test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Verifies that test shuffling works.
 
 #include "gtest/gtest.h"
@@ -88,7 +87,7 @@ class TestNamePrinter : public EmptyTestEventListener {
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   InitGoogleTest(&argc, argv);
 
   // Replaces the default printer with TestNamePrinter, which prints
diff --git a/googletest/googletest/test/googletest-test-part-test.cc b/googletest/googletest/test/googletest-test-part-test.cc
index 44cf7ca044b850dadc0df89628225c07dea27c91..076e5be2fa44c16e0c66e64654efa2b19612c68c 100644
--- a/googletest/googletest/test/googletest-test-part-test.cc
+++ b/googletest/googletest/test/googletest-test-part-test.cc
@@ -28,7 +28,6 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "gtest/gtest-test-part.h"
-
 #include "gtest/gtest.h"
 
 using testing::Message;
@@ -52,17 +51,14 @@ class TestPartResultTest : public Test {
   TestPartResult r1_, r2_, r3_, r4_;
 };
 
-
 TEST_F(TestPartResultTest, ConstructorWorks) {
   Message message;
   message << "something is terribly wrong";
   message << static_cast<const char*>(testing::internal::kStackTraceMarker);
   message << "some unimportant stack trace";
 
-  const TestPartResult result(TestPartResult::kNonFatalFailure,
-                              "some_file.cc",
-                              42,
-                              message.GetString().c_str());
+  const TestPartResult result(TestPartResult::kNonFatalFailure, "some_file.cc",
+                              42, message.GetString().c_str());
 
   EXPECT_EQ(TestPartResult::kNonFatalFailure, result.type());
   EXPECT_STREQ("some_file.cc", result.file_name());
@@ -72,9 +68,7 @@ TEST_F(TestPartResultTest, ConstructorWorks) {
 }
 
 TEST_F(TestPartResultTest, ResultAccessorsWork) {
-  const TestPartResult success(TestPartResult::kSuccess,
-                               "file.cc",
-                               42,
+  const TestPartResult success(TestPartResult::kSuccess, "file.cc", 42,
                                "message");
   EXPECT_TRUE(success.passed());
   EXPECT_FALSE(success.failed());
@@ -83,19 +77,15 @@ TEST_F(TestPartResultTest, ResultAccessorsWork) {
   EXPECT_FALSE(success.skipped());
 
   const TestPartResult nonfatal_failure(TestPartResult::kNonFatalFailure,
-                                        "file.cc",
-                                        42,
-                                        "message");
+                                        "file.cc", 42, "message");
   EXPECT_FALSE(nonfatal_failure.passed());
   EXPECT_TRUE(nonfatal_failure.failed());
   EXPECT_TRUE(nonfatal_failure.nonfatally_failed());
   EXPECT_FALSE(nonfatal_failure.fatally_failed());
   EXPECT_FALSE(nonfatal_failure.skipped());
 
-  const TestPartResult fatal_failure(TestPartResult::kFatalFailure,
-                                     "file.cc",
-                                     42,
-                                     "message");
+  const TestPartResult fatal_failure(TestPartResult::kFatalFailure, "file.cc",
+                                     42, "message");
   EXPECT_FALSE(fatal_failure.passed());
   EXPECT_TRUE(fatal_failure.failed());
   EXPECT_FALSE(fatal_failure.nonfatally_failed());
diff --git a/googletest/googletest/test/googletest-throw-on-failure-test.py b/googletest/googletest/test/googletest-throw-on-failure-test.py
index ea627c479d5b19824ca67b98089cf400c33c279a..772bbc5f39b993064b4cd0bc24cc472c719d6c9e 100644
--- a/googletest/googletest/test/googletest-throw-on-failure-test.py
+++ b/googletest/googletest/test/googletest-throw-on-failure-test.py
@@ -36,7 +36,7 @@ Google Test) with different environments and command line flags.
 """
 
 import os
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 
 # Constants.
diff --git a/googletest/googletest/test/googletest-throw-on-failure-test_.cc b/googletest/googletest/test/googletest-throw-on-failure-test_.cc
index 83bb914c7e474a812d5745a3ec50b95b38a658e4..3b81a5a1db667cd0acc50e2955fa5a199bfadbab 100644
--- a/googletest/googletest/test/googletest-throw-on-failure-test_.cc
+++ b/googletest/googletest/test/googletest-throw-on-failure-test_.cc
@@ -27,18 +27,18 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests Google Test's throw-on-failure mode with exceptions disabled.
 //
 // This program must be compiled with exceptions disabled.  It will be
 // invoked by googletest-throw-on-failure-test.py, and is expected to exit
 // with non-zero in the throw-on-failure mode or 0 otherwise.
 
-#include "gtest/gtest.h"
+#include <stdio.h>   // for fflush, fprintf, NULL, etc.
+#include <stdlib.h>  // for exit
 
-#include <stdio.h>                      // for fflush, fprintf, NULL, etc.
-#include <stdlib.h>                     // for exit
-#include <exception>                    // for set_terminate
+#include <exception>  // for set_terminate
+
+#include "gtest/gtest.h"
 
 // This terminate handler aborts the program using exit() rather than abort().
 // This avoids showing pop-ups on Windows systems and core dumps on Unix-like
diff --git a/googletest/googletest/test/googletest-uninitialized-test.py b/googletest/googletest/test/googletest-uninitialized-test.py
index 69595a0ddede807ae3711e9ef5f7b0ae92207563..73c91764a5b8a93e1a1acd41a87f9e4c7fe9cf02 100644
--- a/googletest/googletest/test/googletest-uninitialized-test.py
+++ b/googletest/googletest/test/googletest-uninitialized-test.py
@@ -31,7 +31,7 @@
 
 """Verifies that Google Test warns the user when not initialized properly."""
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 COMMAND = gtest_test_utils.GetTestExecutablePath('googletest-uninitialized-test_')
 
diff --git a/googletest/googletest/test/googletest-uninitialized-test_.cc b/googletest/googletest/test/googletest-uninitialized-test_.cc
index b4434d51eebfd8726bd3f04c2d0426bba960298c..88b61fcefd5e5eb81ff0f6783e18bb9ff2a53108 100644
--- a/googletest/googletest/test/googletest-uninitialized-test_.cc
+++ b/googletest/googletest/test/googletest-uninitialized-test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest.h"
 
 TEST(DummyTest, Dummy) {
@@ -37,6 +36,4 @@ TEST(DummyTest, Dummy) {
   // testing::InitGoogleTest() being called first.
 }
 
-int main() {
-  return RUN_ALL_TESTS();
-}
+int main() { return RUN_ALL_TESTS(); }
diff --git a/googletest/googletest/test/gtest-typed-test2_test.cc b/googletest/googletest/test/gtest-typed-test2_test.cc
index e83ca2e11b1b626f323b92853a01821b8a353190..f2eae12058b747925668281aabda1aa8dbbdb80b 100644
--- a/googletest/googletest/test/gtest-typed-test2_test.cc
+++ b/googletest/googletest/test/gtest-typed-test2_test.cc
@@ -27,11 +27,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include <vector>
 
-#include "test/gtest-typed-test_test.h"
 #include "gtest/gtest.h"
+#include "test/gtest-typed-test_test.h"
 
 // Tests that the same type-parameterized test case can be
 // instantiated in different translation units linked together.
diff --git a/googletest/googletest/test/gtest-typed-test_test.cc b/googletest/googletest/test/gtest-typed-test_test.cc
index 5fc678cb0d5d1d025d69356c2b1b6d10e45ed66a..4b1c23ddb9f7dcc4959acf015b03a7e7d2d8c91b 100644
--- a/googletest/googletest/test/gtest-typed-test_test.cc
+++ b/googletest/googletest/test/gtest-typed-test_test.cc
@@ -27,10 +27,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "test/gtest-typed-test_test.h"
 
 #include <set>
+#include <string>
 #include <type_traits>
 #include <vector>
 
@@ -50,9 +50,7 @@ class CommonTest : public Test {
   // For some technical reason, SetUpTestSuite() and TearDownTestSuite()
   // must be public.
  public:
-  static void SetUpTestSuite() {
-    shared_ = new T(5);
-  }
+  static void SetUpTestSuite() { shared_ = new T(5); }
 
   static void TearDownTestSuite() {
     delete shared_;
@@ -130,8 +128,7 @@ TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
 // translation unit.
 
 template <typename T>
-class TypedTest1 : public Test {
-};
+class TypedTest1 : public Test {};
 
 // Verifies that the second argument of TYPED_TEST_SUITE can be a
 // single type.
@@ -139,8 +136,7 @@ TYPED_TEST_SUITE(TypedTest1, int);
 TYPED_TEST(TypedTest1, A) {}
 
 template <typename T>
-class TypedTest2 : public Test {
-};
+class TypedTest2 : public Test {};
 
 // Verifies that the second argument of TYPED_TEST_SUITE can be a
 // Types<...> type list.
@@ -155,15 +151,12 @@ TYPED_TEST(TypedTest2, A) {}
 namespace library1 {
 
 template <typename T>
-class NumericTest : public Test {
-};
+class NumericTest : public Test {};
 
 typedef Types<int, long> NumericTypes;
 TYPED_TEST_SUITE(NumericTest, NumericTypes);
 
-TYPED_TEST(NumericTest, DefaultIsZero) {
-  EXPECT_EQ(0, TypeParam());
-}
+TYPED_TEST(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
 
 }  // namespace library1
 
@@ -265,8 +258,7 @@ TEST_F(TypedTestSuitePStateDeathTest, DetectsTestAfterRegistration) {
 // and SetUp()/TearDown() work correctly in type-parameterized tests.
 
 template <typename T>
-class DerivedTest : public CommonTest<T> {
-};
+class DerivedTest : public CommonTest<T> {};
 
 TYPED_TEST_SUITE_P(DerivedTest);
 
@@ -290,8 +282,8 @@ TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
   EXPECT_EQ(2, this->value_);
 }
 
-REGISTER_TYPED_TEST_SUITE_P(DerivedTest,
-                           ValuesAreCorrect, ValuesAreStillCorrect);
+REGISTER_TYPED_TEST_SUITE_P(DerivedTest, ValuesAreCorrect,
+                            ValuesAreStillCorrect);
 
 typedef Types<short, long> MyTwoTypes;
 INSTANTIATE_TYPED_TEST_SUITE_P(My, DerivedTest, MyTwoTypes);
@@ -334,14 +326,13 @@ class TypeParametrizedTestNames {
 };
 
 INSTANTIATE_TYPED_TEST_SUITE_P(CustomName, TypeParametrizedTestWithNames,
-                              TwoTypes, TypeParametrizedTestNames);
+                               TwoTypes, TypeParametrizedTestNames);
 
 // Tests that multiple TYPED_TEST_SUITE_P's can be defined in the same
 // translation unit.
 
 template <typename T>
-class TypedTestP1 : public Test {
-};
+class TypedTestP1 : public Test {};
 
 TYPED_TEST_SUITE_P(TypedTestP1);
 
@@ -359,8 +350,7 @@ using IntBeforeRegisterTypedTestSuiteP = int;
 REGISTER_TYPED_TEST_SUITE_P(TypedTestP1, A, B);
 
 template <typename T>
-class TypedTestP2 : public Test {
-};
+class TypedTestP2 : public Test {};
 
 TYPED_TEST_SUITE_P(TypedTestP2);
 
@@ -396,21 +386,17 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, ContainerTest, MyContainers);
 namespace library2 {
 
 template <typename T>
-class NumericTest : public Test {
-};
+class NumericTest : public Test {};
 
 TYPED_TEST_SUITE_P(NumericTest);
 
-TYPED_TEST_P(NumericTest, DefaultIsZero) {
-  EXPECT_EQ(0, TypeParam());
-}
+TYPED_TEST_P(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
 
 TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
   EXPECT_LT(TypeParam(0), TypeParam(1));
 }
 
-REGISTER_TYPED_TEST_SUITE_P(NumericTest,
-                           DefaultIsZero, ZeroIsLessThanOne);
+REGISTER_TYPED_TEST_SUITE_P(NumericTest, DefaultIsZero, ZeroIsLessThanOne);
 typedef Types<int, double> NumericTypes;
 INSTANTIATE_TYPED_TEST_SUITE_P(My, NumericTest, NumericTypes);
 
@@ -418,20 +404,20 @@ static const char* GetTestName() {
   return testing::UnitTest::GetInstance()->current_test_info()->name();
 }
 // Test the stripping of space from test names
-template <typename T> class TrimmedTest : public Test { };
+template <typename T>
+class TrimmedTest : public Test {};
 TYPED_TEST_SUITE_P(TrimmedTest);
 TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); }
 TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); }
 TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); }
 TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); }
 TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); }
-REGISTER_TYPED_TEST_SUITE_P(
-    TrimmedTest,
-    Test1, Test2,Test3 , Test4 ,Test5 );  // NOLINT
-template <typename T1, typename T2> struct MyPair {};
+REGISTER_TYPED_TEST_SUITE_P(TrimmedTest, Test1, Test2, Test3, Test4,
+                            Test5);  // NOLINT
+template <typename T1, typename T2>
+struct MyPair {};
 // Be sure to try a type with a comma in its name just in case it matters.
 typedef Types<int, double, MyPair<int, int> > TrimTypes;
 INSTANTIATE_TYPED_TEST_SUITE_P(My, TrimmedTest, TrimTypes);
 
 }  // namespace library2
-
diff --git a/googletest/googletest/test/gtest-typed-test_test.h b/googletest/googletest/test/gtest-typed-test_test.h
index 8ce559c99f7341ceb8a0b2b89c4b1a97026fa5ae..f3ef0a5962970e18bbd096414271b746b6d525c4 100644
--- a/googletest/googletest/test/gtest-typed-test_test.h
+++ b/googletest/googletest/test/gtest-typed-test_test.h
@@ -40,21 +40,18 @@ using testing::Test;
 // and gtest-typed-test2_test.cc.
 
 template <typename T>
-class ContainerTest : public Test {
-};
+class ContainerTest : public Test {};
 
 TYPED_TEST_SUITE_P(ContainerTest);
 
-TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) {
-  TypeParam container;
-}
+TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) { TypeParam container; }
 
 TYPED_TEST_P(ContainerTest, InitialSizeIsZero) {
   TypeParam container;
   EXPECT_EQ(0U, container.size());
 }
 
-REGISTER_TYPED_TEST_SUITE_P(ContainerTest,
-                            CanBeDefaultConstructed, InitialSizeIsZero);
+REGISTER_TYPED_TEST_SUITE_P(ContainerTest, CanBeDefaultConstructed,
+                            InitialSizeIsZero);
 
 #endif  // GOOGLETEST_TEST_GTEST_TYPED_TEST_TEST_H_
diff --git a/googletest/googletest/test/gtest-unittest-api_test.cc b/googletest/googletest/test/gtest-unittest-api_test.cc
index 8ef505838c70dfc6e3354e85189fc3faf0b0aa7d..2ea692739ad4cf20ba7e93c2f390a1f23965042d 100644
--- a/googletest/googletest/test/gtest-unittest-api_test.cc
+++ b/googletest/googletest/test/gtest-unittest-api_test.cc
@@ -32,11 +32,12 @@
 // This file contains tests verifying correctness of data provided via
 // UnitTest's public methods.
 
-#include "gtest/gtest.h"
-
 #include <string.h>  // For strcmp.
+
 #include <algorithm>
 
+#include "gtest/gtest.h"
+
 using ::testing::InitGoogleTest;
 
 namespace testing {
@@ -56,13 +57,12 @@ class UnitTestHelper {
   static TestSuite const** GetSortedTestSuites() {
     UnitTest& unit_test = *UnitTest::GetInstance();
     auto const** const test_suites = new const TestSuite*[static_cast<size_t>(
-      unit_test.total_test_suite_count())];
+        unit_test.total_test_suite_count())];
 
     for (int i = 0; i < unit_test.total_test_suite_count(); ++i)
       test_suites[i] = unit_test.GetTestSuite(i);
 
-    std::sort(test_suites,
-              test_suites + unit_test.total_test_suite_count(),
+    std::sort(test_suites, test_suites + unit_test.total_test_suite_count(),
               LessByName<TestSuite>());
     return test_suites;
   }
@@ -73,8 +73,7 @@ class UnitTestHelper {
     UnitTest& unit_test = *UnitTest::GetInstance();
     for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
       const TestSuite* test_suite = unit_test.GetTestSuite(i);
-      if (0 == strcmp(test_suite->name(), name))
-        return test_suite;
+      if (0 == strcmp(test_suite->name(), name)) return test_suite;
     }
     return nullptr;
   }
@@ -84,7 +83,7 @@ class UnitTestHelper {
   // array.
   static TestInfo const** GetSortedTests(const TestSuite* test_suite) {
     TestInfo const** const tests = new const TestInfo*[static_cast<size_t>(
-      test_suite->total_test_count())];
+        test_suite->total_test_count())];
 
     for (int i = 0; i < test_suite->total_test_count(); ++i)
       tests[i] = test_suite->GetTestInfo(i);
@@ -95,7 +94,8 @@ class UnitTestHelper {
   }
 };
 
-template <typename T> class TestSuiteWithCommentTest : public Test {};
+template <typename T>
+class TestSuiteWithCommentTest : public Test {};
 TYPED_TEST_SUITE(TestSuiteWithCommentTest, Types<int>);
 TYPED_TEST(TestSuiteWithCommentTest, Dummy) {}
 
@@ -106,7 +106,7 @@ const int kTypedTests = 1;
 // Since tests can be run in any order, the values the accessors that track
 // test execution (such as failed_test_count) can not be predicted.
 TEST(ApiTest, UnitTestImmutableAccessorsWork) {
-  UnitTest* unit_test = UnitTest::GetInstance();
+  const auto& unit_test = UnitTest::GetInstance();
 
   ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count());
   EXPECT_EQ(1 + kTypedTestSuites, unit_test->test_suite_to_run_count());
@@ -224,7 +224,7 @@ TEST(DISABLED_Test, Dummy2) {}
 class FinalSuccessChecker : public Environment {
  protected:
   void TearDown() override {
-    UnitTest* unit_test = UnitTest::GetInstance();
+    const auto& unit_test = UnitTest::GetInstance();
 
     EXPECT_EQ(1 + kTypedTestSuites, unit_test->successful_test_suite_count());
     EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
@@ -319,7 +319,7 @@ class FinalSuccessChecker : public Environment {
 }  // namespace internal
 }  // namespace testing
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   InitGoogleTest(&argc, argv);
 
   AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
diff --git a/googletest/googletest/test/gtest_assert_by_exception_test.cc b/googletest/googletest/test/gtest_assert_by_exception_test.cc
index ada4cb30ef68c55db81356529186834e25c1ac24..f507eac475756e5dc44521bbe56b7f9568edfb95 100644
--- a/googletest/googletest/test/gtest_assert_by_exception_test.cc
+++ b/googletest/googletest/test/gtest_assert_by_exception_test.cc
@@ -27,16 +27,16 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests Google Test's assert-by-exception mode with exceptions enabled.
 
-#include "gtest/gtest.h"
-
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+
 #include <stdexcept>
 
+#include "gtest/gtest.h"
+
 class ThrowListener : public testing::EmptyTestEventListener {
   void OnTestPartResult(const testing::TestPartResult& result) override {
     if (result.type() == testing::TestPartResult::kFatalFailure) {
@@ -55,9 +55,7 @@ void Fail(const char* msg) {
   exit(1);
 }
 
-static void AssertFalse() {
-  ASSERT_EQ(2, 3) << "Expected failure";
-}
+static void AssertFalse() { ASSERT_EQ(2, 3) << "Expected failure"; }
 
 // Tests that an assertion failure throws a subclass of
 // std::runtime_error.
@@ -65,21 +63,21 @@ TEST(Test, Test) {
   // A successful assertion shouldn't throw.
   try {
     EXPECT_EQ(3, 3);
-  } catch(...) {
+  } catch (...) {
     Fail("A successful assertion wrongfully threw.");
   }
 
   // A successful assertion shouldn't throw.
   try {
     EXPECT_EQ(3, 4);
-  } catch(...) {
+  } catch (...) {
     Fail("A failed non-fatal assertion wrongfully threw.");
   }
 
   // A failed assertion should throw.
   try {
     AssertFalse();
-  } catch(const testing::AssertionException& e) {
+  } catch (const testing::AssertionException& e) {
     if (strstr(e.what(), "Expected failure") != nullptr) throw;
 
     printf("%s",
@@ -87,7 +85,7 @@ TEST(Test, Test) {
            "but the message is incorrect.  Instead of containing \"Expected "
            "failure\", it is:\n");
     Fail(e.what());
-  } catch(...) {
+  } catch (...) {
     Fail("A failed assertion threw the wrong type of exception.");
   }
   Fail("A failed assertion should've thrown but didn't.");
@@ -95,9 +93,7 @@ TEST(Test, Test) {
 
 int kTestForContinuingTest = 0;
 
-TEST(Test, Test2) {
-  kTestForContinuingTest = 1;
-}
+TEST(Test, Test2) { kTestForContinuingTest = 1; }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/googletest/googletest/test/gtest_dirs_test.cc b/googletest/googletest/test/gtest_dirs_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c0da9ac463c50498e4e4aa7a42ef3c03c14517a6
--- /dev/null
+++ b/googletest/googletest/test/gtest_dirs_test.cc
@@ -0,0 +1,97 @@
+#include <sys/stat.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace {
+
+class SetEnv {
+ public:
+  // Sets the environment value with name `name` to `value`, unless `value` is
+  // nullptr, in which case it unsets it. Restores the original value on
+  // destruction.
+  SetEnv(const char* name, const char* value) : name_(name) {
+    const char* old_value = getenv(name);
+    if (old_value != nullptr) {
+      saved_value_ = old_value;
+      have_saved_value_ = true;
+    }
+    if (value == nullptr) {
+      GTEST_CHECK_POSIX_SUCCESS_(unsetenv(name));
+    } else {
+      GTEST_CHECK_POSIX_SUCCESS_(setenv(name, value, 1 /*overwrite*/));
+    }
+  }
+
+  ~SetEnv() {
+    if (have_saved_value_) {
+      GTEST_CHECK_POSIX_SUCCESS_(
+          setenv(name_.c_str(), saved_value_.c_str(), 1 /*overwrite*/));
+    } else {
+      GTEST_CHECK_POSIX_SUCCESS_(unsetenv(name_.c_str()));
+    }
+  }
+
+ private:
+  std::string name_;
+  bool have_saved_value_ = false;
+  std::string saved_value_;
+};
+
+class MakeTempDir {
+ public:
+  // Creates a directory with a unique name including `testname`.
+  // The destructor removes it.
+  explicit MakeTempDir(const std::string& testname) {
+    // mkdtemp requires that the last 6 characters of the input pattern
+    // are Xs, and the string is modified by replacing those characters.
+    std::string pattern = "/tmp/" + testname + "_XXXXXX";
+    GTEST_CHECK_(mkdtemp(pattern.data()) != nullptr);
+    dirname_ = pattern;
+  }
+
+  ~MakeTempDir() { GTEST_CHECK_POSIX_SUCCESS_(rmdir(dirname_.c_str())); }
+
+  const char* DirName() const { return dirname_.c_str(); }
+
+ private:
+  std::string dirname_;
+};
+
+bool StartsWith(const std::string& str, const std::string& prefix) {
+  return str.substr(0, prefix.size()) == prefix;
+}
+
+TEST(TempDirTest, InEnvironment) {
+  // Since the test infrastructure might be verifying directory existence or
+  // even creating subdirectories, we need to be careful that the directories we
+  // specify are actually valid.
+  MakeTempDir temp_dir("TempDirTest_InEnvironment");
+  SetEnv set_env("TEST_TMPDIR", temp_dir.DirName());
+  EXPECT_TRUE(StartsWith(testing::TempDir(), temp_dir.DirName()));
+}
+
+TEST(TempDirTest, NotInEnvironment) {
+  SetEnv set_env("TEST_TMPDIR", nullptr);
+  EXPECT_NE(testing::TempDir(), "");
+}
+
+TEST(SrcDirTest, InEnvironment) {
+  // Since the test infrastructure might be verifying directory existence or
+  // even creating subdirectories, we need to be careful that the directories we
+  // specify are actually valid.
+  MakeTempDir temp_dir("SrcDirTest_InEnvironment");
+  SetEnv set_env("TEST_SRCDIR", temp_dir.DirName());
+  EXPECT_TRUE(StartsWith(testing::SrcDir(), temp_dir.DirName()));
+}
+
+TEST(SrcDirTest, NotInEnvironment) {
+  SetEnv set_env("TEST_SRCDIR", nullptr);
+  EXPECT_NE(testing::SrcDir(), "");
+}
+
+}  // namespace
diff --git a/googletest/googletest/test/gtest_environment_test.cc b/googletest/googletest/test/gtest_environment_test.cc
index 064bfc50b918451e2907bd5856673ddcd2701941..122eaf3ca80212efe7d8210a9f8dd9ef72c64b15 100644
--- a/googletest/googletest/test/gtest_environment_test.cc
+++ b/googletest/googletest/test/gtest_environment_test.cc
@@ -30,20 +30,15 @@
 //
 // Tests using global test environments.
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
+
 #include "gtest/gtest.h"
 #include "src/gtest-internal-inl.h"
 
-namespace testing {
-GTEST_DECLARE_string_(filter);
-}
-
 namespace {
 
-enum FailureType {
-  NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
-};
+enum FailureType { NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE };
 
 // For testing using global test environments.
 class MyEnvironment : public testing::Environment {
@@ -83,9 +78,7 @@ class MyEnvironment : public testing::Environment {
 
   // We call this function to set the type of failure SetUp() should
   // generate.
-  void set_failure_in_set_up(FailureType type) {
-    failure_in_set_up_ = type;
-  }
+  void set_failure_in_set_up(FailureType type) { failure_in_set_up_ = type; }
 
   // Was SetUp() run?
   bool set_up_was_run() const { return set_up_was_run_; }
@@ -104,9 +97,7 @@ bool test_was_run;
 
 // The sole purpose of this TEST is to enable us to check whether it
 // was run.
-TEST(FooTest, Bar) {
-  test_was_run = true;
-}
+TEST(FooTest, Bar) { test_was_run = true; }
 
 // Prints the message and aborts the program if condition is false.
 void Check(bool condition, const char* msg) {
@@ -130,7 +121,7 @@ int RunAllTests(MyEnvironment* env, FailureType failure) {
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
 
   // Registers a global test environment, and verifies that the
@@ -174,7 +165,7 @@ int main(int argc, char **argv) {
 
   // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
   // tear-down when there is no test to run.
-  testing::GTEST_FLAG(filter) = "-*";
+  GTEST_FLAG_SET(filter, "-*");
   Check(RunAllTests(env, NO_FAILURE) == 0,
         "RUN_ALL_TESTS() should return zero, as there is no test to run.");
   Check(!env->set_up_was_run(),
diff --git a/googletest/googletest/test/gtest_help_test.py b/googletest/googletest/test/gtest_help_test.py
index 8d953bbd9dc4db72367a9508213224e880bea0c3..642ab865062b02aeef713867c6f49ab745e23210 100644
--- a/googletest/googletest/test/gtest_help_test.py
+++ b/googletest/googletest/test/gtest_help_test.py
@@ -39,27 +39,29 @@ SYNOPSIS
 
 import os
 import re
-import gtest_test_utils
+import sys
+from googletest.test import gtest_test_utils
 
 
 IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
+IS_GNUHURD = os.name == 'posix' and os.uname()[0] == 'GNU'
 IS_GNUKFREEBSD = os.name == 'posix' and os.uname()[0] == 'GNU/kFreeBSD'
+IS_OPENBSD = os.name == 'posix' and os.uname()[0] == 'OpenBSD'
 IS_WINDOWS = os.name == 'nt'
 
 PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
 FLAG_PREFIX = '--gtest_'
 DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
 STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
-UNKNOWN_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
+UNKNOWN_GTEST_PREFIXED_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
 LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
-INCORRECT_FLAG_VARIANTS = [re.sub('^--', '-', LIST_TESTS_FLAG),
-                           re.sub('^--', '/', LIST_TESTS_FLAG),
-                           re.sub('_', '-', LIST_TESTS_FLAG)]
 INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
 
 SUPPORTS_DEATH_TESTS = "DeathTest" in gtest_test_utils.Subprocess(
     [PROGRAM_PATH, LIST_TESTS_FLAG]).output
 
+HAS_ABSL_FLAGS = '--has_absl_flags' in sys.argv
+
 # The help message must match this regex.
 HELP_REGEX = re.compile(
     FLAG_PREFIX + r'list_tests.*' +
@@ -109,18 +111,37 @@ class GTestHelpTest(gtest_test_utils.TestCase):
     """
 
     exit_code, output = RunWithFlag(flag)
-    self.assertEquals(0, exit_code)
-    self.assert_(HELP_REGEX.search(output), output)
+    if HAS_ABSL_FLAGS:
+      # The Abseil flags library prints the ProgramUsageMessage() with
+      # --help and returns 1.
+      self.assertEqual(1, exit_code)
+    else:
+      self.assertEqual(0, exit_code)
+
+    self.assertTrue(HELP_REGEX.search(output), output)
 
-    if IS_LINUX or IS_GNUKFREEBSD:
-      self.assert_(STREAM_RESULT_TO_FLAG in output, output)
+    if IS_LINUX or IS_GNUHURD or IS_GNUKFREEBSD or IS_OPENBSD:
+      self.assertIn(STREAM_RESULT_TO_FLAG, output)
     else:
-      self.assert_(STREAM_RESULT_TO_FLAG not in output, output)
+      self.assertNotIn(STREAM_RESULT_TO_FLAG, output)
 
     if SUPPORTS_DEATH_TESTS and not IS_WINDOWS:
-      self.assert_(DEATH_TEST_STYLE_FLAG in output, output)
+      self.assertIn(DEATH_TEST_STYLE_FLAG, output)
     else:
-      self.assert_(DEATH_TEST_STYLE_FLAG not in output, output)
+      self.assertNotIn(DEATH_TEST_STYLE_FLAG, output)
+
+  def TestUnknownFlagWithAbseil(self, flag):
+    """Verifies correct behavior when an unknown flag is specified.
+
+    The right message must be printed and the tests must
+    skipped when the given flag is specified.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+    exit_code, output = RunWithFlag(flag)
+    self.assertEqual(1, exit_code)
+    self.assertIn('ERROR: Unknown command line flag', output)
 
   def TestNonHelpFlag(self, flag):
     """Verifies correct behavior when no help flag is specified.
@@ -133,27 +154,21 @@ class GTestHelpTest(gtest_test_utils.TestCase):
     """
 
     exit_code, output = RunWithFlag(flag)
-    self.assert_(exit_code != 0)
-    self.assert_(not HELP_REGEX.search(output), output)
+    self.assertNotEqual(exit_code, 0)
+    self.assertFalse(HELP_REGEX.search(output), output)
 
   def testPrintsHelpWithFullFlag(self):
     self.TestHelpFlag('--help')
 
-  def testPrintsHelpWithShortFlag(self):
-    self.TestHelpFlag('-h')
-
-  def testPrintsHelpWithQuestionFlag(self):
-    self.TestHelpFlag('-?')
-
-  def testPrintsHelpWithWindowsStyleQuestionFlag(self):
-    self.TestHelpFlag('/?')
-
   def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
-    self.TestHelpFlag(UNKNOWN_FLAG)
-
-  def testPrintsHelpWithIncorrectFlagStyle(self):
-    for incorrect_flag in INCORRECT_FLAG_VARIANTS:
-      self.TestHelpFlag(incorrect_flag)
+    # The behavior is slightly different when Abseil flags is
+    # used. Abseil flags rejects all unknown flags, while the builtin
+    # GTest flags implementation interprets an unknown flag with a
+    # '--gtest_' prefix as a request for help.
+    if HAS_ABSL_FLAGS:
+      self.TestUnknownFlagWithAbseil(UNKNOWN_GTEST_PREFIXED_FLAG)
+    else:
+      self.TestHelpFlag(UNKNOWN_GTEST_PREFIXED_FLAG)
 
   def testRunsTestsWithoutHelpFlag(self):
     """Verifies that when no help flag is specified, the tests are run
@@ -169,4 +184,6 @@ class GTestHelpTest(gtest_test_utils.TestCase):
 
 
 if __name__ == '__main__':
+  if '--has_absl_flags' in sys.argv:
+    sys.argv.remove('--has_absl_flags')
   gtest_test_utils.Main()
diff --git a/googletest/googletest/test/gtest_help_test_.cc b/googletest/googletest/test/gtest_help_test_.cc
index 750ae6ce95fcbcb338ed5db2b588f15cdd5c2f9e..da289f05f3f4189282e8a2253c0a28d59d2c308a 100644
--- a/googletest/googletest/test/gtest_help_test_.cc
+++ b/googletest/googletest/test/gtest_help_test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This program is meant to be run by gtest_help_test.py.  Do not run
 // it directly.
 
diff --git a/googletest/googletest/test/gtest_json_test_utils.py b/googletest/googletest/test/gtest_json_test_utils.py
index 62bbfc288f82b387cd83446c0a05ba167b1aa754..f62896c9234b6c9f173798bb07702235537e1515 100644
--- a/googletest/googletest/test/gtest_json_test_utils.py
+++ b/googletest/googletest/test/gtest_json_test_utils.py
@@ -50,6 +50,8 @@ def normalize(obj):
     elif key == 'failure':
       value = re.sub(r'^.*[/\\](.*:)\d+\n', '\\1*\n', value)
       return re.sub(r'Stack trace:\n(.|\n)*', 'Stack trace:\n*', value)
+    elif key == 'file':
+      return re.sub(r'^.*[/\\](.*)', '\\1', value)
     else:
       return normalize(value)
   if isinstance(obj, dict):
diff --git a/googletest/googletest/test/gtest_list_output_unittest.py b/googletest/googletest/test/gtest_list_output_unittest.py
index a442fc169c87fc0debb42d352b28c6371def302a..faacf103c342b8e68c5ed4ba6bb03c018671bd2d 100644
--- a/googletest/googletest/test/gtest_list_output_unittest.py
+++ b/googletest/googletest/test/gtest_list_output_unittest.py
@@ -40,7 +40,7 @@ This script tests such functionality by invoking gtest_list_output_unittest_
 
 import os
 import re
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 GTEST_LIST_TESTS_FLAG = '--gtest_list_tests'
 GTEST_OUTPUT_FLAG = '--gtest_output'
diff --git a/googletest/googletest/test/gtest_main_unittest.cc b/googletest/googletest/test/gtest_main_unittest.cc
index eddedeabe8f3bb083dabca600e72f451b8d94cdb..29cd5510a4b1b85216db5e08fc78636ed551155a 100644
--- a/googletest/googletest/test/gtest_main_unittest.cc
+++ b/googletest/googletest/test/gtest_main_unittest.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #include "gtest/gtest.h"
 
 // Tests that we don't have to define main() when we link to
@@ -35,8 +34,7 @@
 
 namespace {
 
-TEST(GTestMainTest, ShouldSucceed) {
-}
+TEST(GTestMainTest, ShouldSucceed) {}
 
 }  // namespace
 
diff --git a/googletest/googletest/test/gtest_pred_impl_unittest.cc b/googletest/googletest/test/gtest_pred_impl_unittest.cc
index bbef9947d99da43a6455f308ca17b7b6cb301bfe..033e2d9f6519489abd962dcbe37be40916698370 100644
--- a/googletest/googletest/test/gtest_pred_impl_unittest.cc
+++ b/googletest/googletest/test/gtest_pred_impl_unittest.cc
@@ -27,9 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// This file is AUTOMATICALLY GENERATED on 11/05/2019 by command
-// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
-
 // Regression test for gtest_pred_impl.h
 //
 // This file is generated by a script and quite long.  If you intend to
@@ -48,9 +45,10 @@
 // stand-alone regression test.
 
 #include <iostream>
+#include <ostream>
 
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 
 // A user-defined data type.
 struct Bool {
@@ -80,12 +78,8 @@ bool PredFunction1(T1 v1) {
 
 // The following two functions are needed because a compiler doesn't have
 // a context yet to know which template function must be instantiated.
-bool PredFunction1Int(int v1) {
-  return v1 > 0;
-}
-bool PredFunction1Bool(Bool v1) {
-  return v1 > 0;
-}
+bool PredFunction1Int(int v1) { return v1 > 0; }
+bool PredFunction1Bool(Bool v1) { return v1 > 0; }
 
 // A unary predicate functor.
 struct PredFunctor1 {
@@ -97,22 +91,17 @@ struct PredFunctor1 {
 
 // A unary predicate-formatter function.
 template <typename T1>
-testing::AssertionResult PredFormatFunction1(const char* e1,
-                                             const T1& v1) {
-  if (PredFunction1(v1))
-    return testing::AssertionSuccess();
+testing::AssertionResult PredFormatFunction1(const char* e1, const T1& v1) {
+  if (PredFunction1(v1)) return testing::AssertionSuccess();
 
   return testing::AssertionFailure()
-      << e1
-      << " is expected to be positive, but evaluates to "
-      << v1 << ".";
+         << e1 << " is expected to be positive, but evaluates to " << v1 << ".";
 }
 
 // A unary predicate-formatter functor.
 struct PredFormatFunctor1 {
   template <typename T1>
-  testing::AssertionResult operator()(const char* e1,
-                                      const T1& v1) const {
+  testing::AssertionResult operator()(const char* e1, const T1& v1) const {
     return PredFormatFunction1(e1, v1);
   }
 };
@@ -130,13 +119,12 @@ class Predicate1Test : public testing::Test {
   void TearDown() override {
     // Verifies that each of the predicate's arguments was evaluated
     // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
+    EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
+                         "exactly once.";
 
     // Verifies that the control flow in the test function is expected.
     if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+      FAIL() << "The predicate assertion unexpectedly aborted the test.";
     } else if (!expected_to_finish_ && finished_) {
       FAIL() << "The failed predicate assertion didn't abort the test "
                 "as expected.";
@@ -164,104 +152,100 @@ typedef Predicate1Test ASSERT_PRED1Test;
 // Tests a successful EXPECT_PRED1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED1(PredFunction1Int,
-               ++n1_);
+  EXPECT_PRED1(PredFunction1Int, ++n1_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED1(PredFunction1Bool,
-               Bool(++n1_));
+  EXPECT_PRED1(PredFunction1Bool, Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED1(PredFunctor1(),
-               ++n1_);
+  EXPECT_PRED1(PredFunctor1(), ++n1_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED1(PredFunctor1(),
-               Bool(++n1_));
+  EXPECT_PRED1(PredFunctor1(), Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunction1Int,
-                 n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED1(PredFunction1Int, n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunction1Bool,
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED1(PredFunction1Bool, Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunctor1(),
-                 n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED1(PredFunctor1(), n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(PredFunctor1(),
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED1(PredFunctor1(), Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED1(PredFunction1Int,
-               ++n1_);
+  ASSERT_PRED1(PredFunction1Int, ++n1_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED1(PredFunction1Bool,
-               Bool(++n1_));
+  ASSERT_PRED1(PredFunction1Bool, Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED1(PredFunctor1(),
-               ++n1_);
+  ASSERT_PRED1(PredFunctor1(), ++n1_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED1(PredFunctor1(),
-               Bool(++n1_));
+  ASSERT_PRED1(PredFunctor1(), Bool(++n1_));
   finished_ = true;
 }
 
@@ -269,147 +253,147 @@ TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunction1Int,
-                 n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED1(PredFunction1Int, n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunction1Bool,
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED1(PredFunction1Bool, Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunctor1(),
-                 n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED1(PredFunctor1(), n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED1(PredFunctor1(),
-                 Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED1(PredFunctor1(), Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                      ++n1_);
+  EXPECT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                      Bool(++n1_));
+  EXPECT_PRED_FORMAT1(PredFormatFunction1, Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                      ++n1_);
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(), ++n1_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                      Bool(++n1_));
+  EXPECT_PRED_FORMAT1(PredFormatFunctor1(), Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                        n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT1(PredFormatFunction1, n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunction1,
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT1(PredFormatFunction1, Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                        n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT1(PredFormatFunctor1(), n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT1(PredFormatFunctor1(), Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                      ++n1_);
+  ASSERT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                      Bool(++n1_));
+  ASSERT_PRED_FORMAT1(PredFormatFunction1, Bool(++n1_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                      ++n1_);
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(), ++n1_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                      Bool(++n1_));
+  ASSERT_PRED_FORMAT1(PredFormatFunctor1(), Bool(++n1_));
   finished_ = true;
 }
 
@@ -417,44 +401,48 @@ TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                        n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(PredFormatFunction1, n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunction1,
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(PredFormatFunction1, Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                        n1_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(PredFormatFunctor1(), n1_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT1 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
-                        Bool(n1_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(PredFormatFunctor1(), Bool(n1_++));
+        finished_ = true;
+      },
+      "");
 }
 // Sample functions/functors for testing binary predicate assertions.
 
@@ -466,44 +454,33 @@ bool PredFunction2(T1 v1, T2 v2) {
 
 // The following two functions are needed because a compiler doesn't have
 // a context yet to know which template function must be instantiated.
-bool PredFunction2Int(int v1, int v2) {
-  return v1 + v2 > 0;
-}
-bool PredFunction2Bool(Bool v1, Bool v2) {
-  return v1 + v2 > 0;
-}
+bool PredFunction2Int(int v1, int v2) { return v1 + v2 > 0; }
+bool PredFunction2Bool(Bool v1, Bool v2) { return v1 + v2 > 0; }
 
 // A binary predicate functor.
 struct PredFunctor2 {
   template <typename T1, typename T2>
-  bool operator()(const T1& v1,
-                  const T2& v2) {
+  bool operator()(const T1& v1, const T2& v2) {
     return v1 + v2 > 0;
   }
 };
 
 // A binary predicate-formatter function.
 template <typename T1, typename T2>
-testing::AssertionResult PredFormatFunction2(const char* e1,
-                                             const char* e2,
-                                             const T1& v1,
-                                             const T2& v2) {
-  if (PredFunction2(v1, v2))
-    return testing::AssertionSuccess();
+testing::AssertionResult PredFormatFunction2(const char* e1, const char* e2,
+                                             const T1& v1, const T2& v2) {
+  if (PredFunction2(v1, v2)) return testing::AssertionSuccess();
 
   return testing::AssertionFailure()
-      << e1 << " + " << e2
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 << ".";
+         << e1 << " + " << e2
+         << " is expected to be positive, but evaluates to " << v1 + v2 << ".";
 }
 
 // A binary predicate-formatter functor.
 struct PredFormatFunctor2 {
   template <typename T1, typename T2>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const T1& v1,
-                                      const T2& v2) const {
+  testing::AssertionResult operator()(const char* e1, const char* e2,
+                                      const T1& v1, const T2& v2) const {
     return PredFormatFunction2(e1, e2, v1, v2);
   }
 };
@@ -521,16 +498,14 @@ class Predicate2Test : public testing::Test {
   void TearDown() override {
     // Verifies that each of the predicate's arguments was evaluated
     // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
+    EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
+                         "exactly once.";
+    EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
+                         "exactly once.";
 
     // Verifies that the control flow in the test function is expected.
     if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+      FAIL() << "The predicate assertion unexpectedly aborted the test.";
     } else if (!expected_to_finish_ && finished_) {
       FAIL() << "The failed predicate assertion didn't abort the test "
                 "as expected.";
@@ -560,116 +535,100 @@ typedef Predicate2Test ASSERT_PRED2Test;
 // Tests a successful EXPECT_PRED2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED2(PredFunction2Int,
-               ++n1_,
-               ++n2_);
+  EXPECT_PRED2(PredFunction2Int, ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED2(PredFunction2Bool,
-               Bool(++n1_),
-               Bool(++n2_));
+  EXPECT_PRED2(PredFunction2Bool, Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED2(PredFunctor2(),
-               ++n1_,
-               ++n2_);
+  EXPECT_PRED2(PredFunctor2(), ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED2(PredFunctor2(),
-               Bool(++n1_),
-               Bool(++n2_));
+  EXPECT_PRED2(PredFunctor2(), Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunction2Int,
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED2(PredFunction2Int, n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunction2Bool,
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED2(PredFunction2Bool, Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunctor2(),
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED2(PredFunctor2(), n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(PredFunctor2(),
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED2(PredFunctor2(), Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED2(PredFunction2Int,
-               ++n1_,
-               ++n2_);
+  ASSERT_PRED2(PredFunction2Int, ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED2(PredFunction2Bool,
-               Bool(++n1_),
-               Bool(++n2_));
+  ASSERT_PRED2(PredFunction2Bool, Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED2(PredFunctor2(),
-               ++n1_,
-               ++n2_);
+  ASSERT_PRED2(PredFunctor2(), ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED2(PredFunctor2(),
-               Bool(++n1_),
-               Bool(++n2_));
+  ASSERT_PRED2(PredFunctor2(), Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
@@ -677,163 +636,147 @@ TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunction2Int,
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED2(PredFunction2Int, n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunction2Bool,
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED2(PredFunction2Bool, Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunctor2(),
-                 n1_++,
-                 n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED2(PredFunctor2(), n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED2(PredFunctor2(),
-                 Bool(n1_++),
-                 Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED2(PredFunctor2(), Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                      ++n1_,
-                      ++n2_);
+  EXPECT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                      Bool(++n1_),
-                      Bool(++n2_));
+  EXPECT_PRED_FORMAT2(PredFormatFunction2, Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                      ++n1_,
-                      ++n2_);
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(), ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                      Bool(++n1_),
-                      Bool(++n2_));
+  EXPECT_PRED_FORMAT2(PredFormatFunctor2(), Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunction2,
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(PredFormatFunction2, Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(PredFormatFunctor2(), n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(PredFormatFunctor2(), Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                      ++n1_,
-                      ++n2_);
+  ASSERT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                      Bool(++n1_),
-                      Bool(++n2_));
+  ASSERT_PRED_FORMAT2(PredFormatFunction2, Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                      ++n1_,
-                      ++n2_);
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(), ++n1_, ++n2_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                      Bool(++n1_),
-                      Bool(++n2_));
+  ASSERT_PRED_FORMAT2(PredFormatFunctor2(), Bool(++n1_), Bool(++n2_));
   finished_ = true;
 }
 
@@ -841,48 +784,48 @@ TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunction2,
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(PredFormatFunction2, Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                        n1_++,
-                        n2_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(PredFormatFunctor2(), n1_++, n2_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT2 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
-                        Bool(n1_++),
-                        Bool(n2_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(PredFormatFunctor2(), Bool(n1_++), Bool(n2_++));
+        finished_ = true;
+      },
+      "");
 }
 // Sample functions/functors for testing ternary predicate assertions.
 
@@ -894,49 +837,36 @@ bool PredFunction3(T1 v1, T2 v2, T3 v3) {
 
 // The following two functions are needed because a compiler doesn't have
 // a context yet to know which template function must be instantiated.
-bool PredFunction3Int(int v1, int v2, int v3) {
-  return v1 + v2 + v3 > 0;
-}
-bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
-  return v1 + v2 + v3 > 0;
-}
+bool PredFunction3Int(int v1, int v2, int v3) { return v1 + v2 + v3 > 0; }
+bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) { return v1 + v2 + v3 > 0; }
 
 // A ternary predicate functor.
 struct PredFunctor3 {
   template <typename T1, typename T2, typename T3>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3) {
+  bool operator()(const T1& v1, const T2& v2, const T3& v3) {
     return v1 + v2 + v3 > 0;
   }
 };
 
 // A ternary predicate-formatter function.
 template <typename T1, typename T2, typename T3>
-testing::AssertionResult PredFormatFunction3(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3) {
-  if (PredFunction3(v1, v2, v3))
-    return testing::AssertionSuccess();
+testing::AssertionResult PredFormatFunction3(const char* e1, const char* e2,
+                                             const char* e3, const T1& v1,
+                                             const T2& v2, const T3& v3) {
+  if (PredFunction3(v1, v2, v3)) return testing::AssertionSuccess();
 
   return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 << ".";
+         << e1 << " + " << e2 << " + " << e3
+         << " is expected to be positive, but evaluates to " << v1 + v2 + v3
+         << ".";
 }
 
 // A ternary predicate-formatter functor.
 struct PredFormatFunctor3 {
   template <typename T1, typename T2, typename T3>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3) const {
+  testing::AssertionResult operator()(const char* e1, const char* e2,
+                                      const char* e3, const T1& v1,
+                                      const T2& v2, const T3& v3) const {
     return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
   }
 };
@@ -954,19 +884,16 @@ class Predicate3Test : public testing::Test {
   void TearDown() override {
     // Verifies that each of the predicate's arguments was evaluated
     // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
+    EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
+                         "exactly once.";
+    EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
+                         "exactly once.";
+    EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
+                         "exactly once.";
 
     // Verifies that the control flow in the test function is expected.
     if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+      FAIL() << "The predicate assertion unexpectedly aborted the test.";
     } else if (!expected_to_finish_ && finished_) {
       FAIL() << "The failed predicate assertion didn't abort the test "
                 "as expected.";
@@ -998,128 +925,100 @@ typedef Predicate3Test ASSERT_PRED3Test;
 // Tests a successful EXPECT_PRED3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED3(PredFunction3Int,
-               ++n1_,
-               ++n2_,
-               ++n3_);
+  EXPECT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED3(PredFunction3Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
+  EXPECT_PRED3(PredFunction3Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED3(PredFunctor3(),
-               ++n1_,
-               ++n2_,
-               ++n3_);
+  EXPECT_PRED3(PredFunctor3(), ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED3(PredFunctor3(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
+  EXPECT_PRED3(PredFunctor3(), Bool(++n1_), Bool(++n2_), Bool(++n3_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunction3Int,
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunction3Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED3(PredFunction3Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunctor3(),
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED3(PredFunctor3(), n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(PredFunctor3(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED3(PredFunctor3(), Bool(n1_++), Bool(n2_++), Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED3(PredFunction3Int,
-               ++n1_,
-               ++n2_,
-               ++n3_);
+  ASSERT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED3(PredFunction3Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
+  ASSERT_PRED3(PredFunction3Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED3(PredFunctor3(),
-               ++n1_,
-               ++n2_,
-               ++n3_);
+  ASSERT_PRED3(PredFunctor3(), ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED3(PredFunctor3(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_));
+  ASSERT_PRED3(PredFunctor3(), Bool(++n1_), Bool(++n2_), Bool(++n3_));
   finished_ = true;
 }
 
@@ -1127,70 +1026,61 @@ TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunction3Int,
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunction3Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED3(PredFunction3Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunctor3(),
-                 n1_++,
-                 n2_++,
-                 n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED3(PredFunctor3(), n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(PredFunctor3(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED3(PredFunctor3(), Bool(n1_++), Bool(n2_++), Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
+  EXPECT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                      Bool(++n1_),
-                      Bool(++n2_),
+  EXPECT_PRED_FORMAT3(PredFormatFunction3, Bool(++n1_), Bool(++n2_),
                       Bool(++n3_));
   finished_ = true;
 }
@@ -1198,19 +1088,14 @@ TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
 // Tests a successful EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(), ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                      Bool(++n1_),
-                      Bool(++n2_),
+  EXPECT_PRED_FORMAT3(PredFormatFunctor3(), Bool(++n1_), Bool(++n2_),
                       Bool(++n3_));
   finished_ = true;
 }
@@ -1218,67 +1103,60 @@ TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
 // Tests a failed EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunction3,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT3(PredFormatFunction3, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT3(PredFormatFunctor3(), n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT3(PredFormatFunctor3(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
+  ASSERT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                      Bool(++n1_),
-                      Bool(++n2_),
+  ASSERT_PRED_FORMAT3(PredFormatFunction3, Bool(++n1_), Bool(++n2_),
                       Bool(++n3_));
   finished_ = true;
 }
@@ -1286,19 +1164,14 @@ TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
 // Tests a successful ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_);
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(), ++n1_, ++n2_, ++n3_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                      Bool(++n1_),
-                      Bool(++n2_),
+  ASSERT_PRED_FORMAT3(PredFormatFunctor3(), Bool(++n1_), Bool(++n2_),
                       Bool(++n3_));
   finished_ = true;
 }
@@ -1307,52 +1180,50 @@ TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunction3,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT3(PredFormatFunction3, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                        n1_++,
-                        n2_++,
-                        n3_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT3(PredFormatFunctor3(), n1_++, n2_++, n3_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT3 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT3(PredFormatFunctor3(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++));
+        finished_ = true;
+      },
+      "");
 }
 // Sample functions/functors for testing 4-ary predicate assertions.
 
@@ -1374,43 +1245,31 @@ bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
 // A 4-ary predicate functor.
 struct PredFunctor4 {
   template <typename T1, typename T2, typename T3, typename T4>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3,
-                  const T4& v4) {
+  bool operator()(const T1& v1, const T2& v2, const T3& v3, const T4& v4) {
     return v1 + v2 + v3 + v4 > 0;
   }
 };
 
 // A 4-ary predicate-formatter function.
 template <typename T1, typename T2, typename T3, typename T4>
-testing::AssertionResult PredFormatFunction4(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const char* e4,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3,
-                                             const T4& v4) {
-  if (PredFunction4(v1, v2, v3, v4))
-    return testing::AssertionSuccess();
+testing::AssertionResult PredFormatFunction4(const char* e1, const char* e2,
+                                             const char* e3, const char* e4,
+                                             const T1& v1, const T2& v2,
+                                             const T3& v3, const T4& v4) {
+  if (PredFunction4(v1, v2, v3, v4)) return testing::AssertionSuccess();
 
   return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3 << " + " << e4
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 + v4 << ".";
+         << e1 << " + " << e2 << " + " << e3 << " + " << e4
+         << " is expected to be positive, but evaluates to "
+         << v1 + v2 + v3 + v4 << ".";
 }
 
 // A 4-ary predicate-formatter functor.
 struct PredFormatFunctor4 {
   template <typename T1, typename T2, typename T3, typename T4>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const char* e4,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3,
+  testing::AssertionResult operator()(const char* e1, const char* e2,
+                                      const char* e3, const char* e4,
+                                      const T1& v1, const T2& v2, const T3& v3,
                                       const T4& v4) const {
     return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
   }
@@ -1429,22 +1288,18 @@ class Predicate4Test : public testing::Test {
   void TearDown() override {
     // Verifies that each of the predicate's arguments was evaluated
     // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
-    EXPECT_EQ(1, n4_) <<
-        "The predicate assertion didn't evaluate argument 5 "
-        "exactly once.";
+    EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
+                         "exactly once.";
+    EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
+                         "exactly once.";
+    EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
+                         "exactly once.";
+    EXPECT_EQ(1, n4_) << "The predicate assertion didn't evaluate argument 5 "
+                         "exactly once.";
 
     // Verifies that the control flow in the test function is expected.
     if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+      FAIL() << "The predicate assertion unexpectedly aborted the test.";
     } else if (!expected_to_finish_ && finished_) {
       FAIL() << "The failed predicate assertion didn't abort the test "
                 "as expected.";
@@ -1478,21 +1333,14 @@ typedef Predicate4Test ASSERT_PRED4Test;
 // Tests a successful EXPECT_PRED4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED4(PredFunction4Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
+  EXPECT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED4(PredFunction4Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
+  EXPECT_PRED4(PredFunction4Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
                Bool(++n4_));
   finished_ = true;
 }
@@ -1500,21 +1348,14 @@ TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
 // Tests a successful EXPECT_PRED4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED4(PredFunctor4(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
+  EXPECT_PRED4(PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED4(PredFunctor4(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
+  EXPECT_PRED4(PredFunctor4(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
                Bool(++n4_));
   finished_ = true;
 }
@@ -1522,73 +1363,60 @@ TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
 // Tests a failed EXPECT_PRED4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunction4Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunction4Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED4(PredFunction4Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunctor4(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED4(PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED4(PredFunctor4(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED4(PredFunctor4(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED4(PredFunction4Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
+  ASSERT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED4(PredFunction4Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
+  ASSERT_PRED4(PredFunction4Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
                Bool(++n4_));
   finished_ = true;
 }
@@ -1596,21 +1424,14 @@ TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
 // Tests a successful ASSERT_PRED4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED4(PredFunctor4(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_);
+  ASSERT_PRED4(PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED4(PredFunctor4(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
+  ASSERT_PRED4(PredFunctor4(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
                Bool(++n4_));
   finished_ = true;
 }
@@ -1619,195 +1440,155 @@ TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunction4Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunction4Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED4(PredFunction4Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunctor4(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED4(PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED4(PredFunctor4(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED4(PredFunctor4(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
+  EXPECT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
+  EXPECT_PRED_FORMAT4(PredFormatFunction4, Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
+  EXPECT_PRED_FORMAT4(PredFormatFunctor4(), Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunction4,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(PredFormatFunction4, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(PredFormatFunctor4(), n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(PredFormatFunctor4(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
+  ASSERT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
+  ASSERT_PRED_FORMAT4(PredFormatFunction4, Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_);
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_));
+  ASSERT_PRED_FORMAT4(PredFormatFunctor4(), Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_));
   finished_ = true;
 }
 
@@ -1815,56 +1596,50 @@ TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunction4,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT4(PredFormatFunction4, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT4(PredFormatFunctor4(), n1_++, n2_++, n3_++, n4_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT4 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT4(PredFormatFunctor4(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++));
+        finished_ = true;
+      },
+      "");
 }
 // Sample functions/functors for testing 5-ary predicate assertions.
 
@@ -1886,10 +1661,7 @@ bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
 // A 5-ary predicate functor.
 struct PredFunctor5 {
   template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  bool operator()(const T1& v1,
-                  const T2& v2,
-                  const T3& v3,
-                  const T4& v4,
+  bool operator()(const T1& v1, const T2& v2, const T3& v3, const T4& v4,
                   const T5& v5) {
     return v1 + v2 + v3 + v4 + v5 > 0;
   }
@@ -1897,37 +1669,26 @@ struct PredFunctor5 {
 
 // A 5-ary predicate-formatter function.
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
-testing::AssertionResult PredFormatFunction5(const char* e1,
-                                             const char* e2,
-                                             const char* e3,
-                                             const char* e4,
-                                             const char* e5,
-                                             const T1& v1,
-                                             const T2& v2,
-                                             const T3& v3,
-                                             const T4& v4,
-                                             const T5& v5) {
-  if (PredFunction5(v1, v2, v3, v4, v5))
-    return testing::AssertionSuccess();
+testing::AssertionResult PredFormatFunction5(const char* e1, const char* e2,
+                                             const char* e3, const char* e4,
+                                             const char* e5, const T1& v1,
+                                             const T2& v2, const T3& v3,
+                                             const T4& v4, const T5& v5) {
+  if (PredFunction5(v1, v2, v3, v4, v5)) return testing::AssertionSuccess();
 
   return testing::AssertionFailure()
-      << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
-      << " is expected to be positive, but evaluates to "
-      << v1 + v2 + v3 + v4 + v5 << ".";
+         << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
+         << " is expected to be positive, but evaluates to "
+         << v1 + v2 + v3 + v4 + v5 << ".";
 }
 
 // A 5-ary predicate-formatter functor.
 struct PredFormatFunctor5 {
   template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  testing::AssertionResult operator()(const char* e1,
-                                      const char* e2,
-                                      const char* e3,
-                                      const char* e4,
-                                      const char* e5,
-                                      const T1& v1,
-                                      const T2& v2,
-                                      const T3& v3,
-                                      const T4& v4,
+  testing::AssertionResult operator()(const char* e1, const char* e2,
+                                      const char* e3, const char* e4,
+                                      const char* e5, const T1& v1,
+                                      const T2& v2, const T3& v3, const T4& v4,
                                       const T5& v5) const {
     return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
   }
@@ -1946,25 +1707,20 @@ class Predicate5Test : public testing::Test {
   void TearDown() override {
     // Verifies that each of the predicate's arguments was evaluated
     // exactly once.
-    EXPECT_EQ(1, n1_) <<
-        "The predicate assertion didn't evaluate argument 2 "
-        "exactly once.";
-    EXPECT_EQ(1, n2_) <<
-        "The predicate assertion didn't evaluate argument 3 "
-        "exactly once.";
-    EXPECT_EQ(1, n3_) <<
-        "The predicate assertion didn't evaluate argument 4 "
-        "exactly once.";
-    EXPECT_EQ(1, n4_) <<
-        "The predicate assertion didn't evaluate argument 5 "
-        "exactly once.";
-    EXPECT_EQ(1, n5_) <<
-        "The predicate assertion didn't evaluate argument 6 "
-        "exactly once.";
+    EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
+                         "exactly once.";
+    EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
+                         "exactly once.";
+    EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
+                         "exactly once.";
+    EXPECT_EQ(1, n4_) << "The predicate assertion didn't evaluate argument 5 "
+                         "exactly once.";
+    EXPECT_EQ(1, n5_) << "The predicate assertion didn't evaluate argument 6 "
+                         "exactly once.";
 
     // Verifies that the control flow in the test function is expected.
     if (expected_to_finish_ && !finished_) {
-      FAIL() << "The predicate assertion unexpactedly aborted the test.";
+      FAIL() << "The predicate assertion unexpectedly aborted the test.";
     } else if (!expected_to_finish_ && finished_) {
       FAIL() << "The failed predicate assertion didn't abort the test "
                 "as expected.";
@@ -2000,152 +1756,106 @@ typedef Predicate5Test ASSERT_PRED5Test;
 // Tests a successful EXPECT_PRED5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED5(PredFunction5Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
+  EXPECT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED5(PredFunction5Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
+  EXPECT_PRED5(PredFunction5Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
+               Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED5(PredFunctor5(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
+  EXPECT_PRED5(PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED5(PredFunctor5(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
+  EXPECT_PRED5(PredFunctor5(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
+               Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunction5Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunction5Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED5(PredFunction5Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunctor5(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED5(PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED5(PredFunctor5(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED5(PredFunctor5(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED5(PredFunction5Int,
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
+  ASSERT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED5(PredFunction5Bool,
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
+  ASSERT_PRED5(PredFunction5Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
+               Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED5(PredFunctor5(),
-               ++n1_,
-               ++n2_,
-               ++n3_,
-               ++n4_,
-               ++n5_);
+  ASSERT_PRED5(PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED5(PredFunctor5(),
-               Bool(++n1_),
-               Bool(++n2_),
-               Bool(++n3_),
-               Bool(++n4_),
-               Bool(++n5_));
+  ASSERT_PRED5(PredFunctor5(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
+               Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
@@ -2153,211 +1863,157 @@ TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunction5Int,
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunction5Bool,
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED5(PredFunction5Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunctor5(),
-                 n1_++,
-                 n2_++,
-                 n3_++,
-                 n4_++,
-                 n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED5(PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED5(PredFunctor5(),
-                 Bool(n1_++),
-                 Bool(n2_++),
-                 Bool(n3_++),
-                 Bool(n4_++),
-                 Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED5(PredFunctor5(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
+                     Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
+  EXPECT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
+  EXPECT_PRED_FORMAT5(PredFormatFunction5, Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
-  EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
+  EXPECT_PRED_FORMAT5(PredFormatFunctor5(), Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a failed EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
+                            n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunction5,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT5(PredFormatFunction5, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT5(PredFormatFunctor5(), n1_++, n2_++, n3_++, n4_++,
+                            n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed EXPECT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT5(PredFormatFunctor5(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a successful ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
+  ASSERT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
+  ASSERT_PRED_FORMAT5(PredFormatFunction5, Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                      ++n1_,
-                      ++n2_,
-                      ++n3_,
-                      ++n4_,
-                      ++n5_);
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
   finished_ = true;
 }
 
 // Tests a successful ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
-  ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                      Bool(++n1_),
-                      Bool(++n2_),
-                      Bool(++n3_),
-                      Bool(++n4_),
-                      Bool(++n5_));
+  ASSERT_PRED_FORMAT5(PredFormatFunctor5(), Bool(++n1_), Bool(++n2_),
+                      Bool(++n3_), Bool(++n4_), Bool(++n5_));
   finished_ = true;
 }
 
@@ -2365,58 +2021,50 @@ TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
 // predicate-formatter is a function on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
+                            n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a function on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunction5,
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT5(PredFormatFunction5, Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a built-in type (int).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                        n1_++,
-                        n2_++,
-                        n3_++,
-                        n4_++,
-                        n5_++);
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT5(PredFormatFunctor5(), n1_++, n2_++, n3_++, n4_++,
+                            n5_++);
+        finished_ = true;
+      },
+      "");
 }
 
 // Tests a failed ASSERT_PRED_FORMAT5 where the
 // predicate-formatter is a functor on a user-defined type (Bool).
 TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
   expected_to_finish_ = false;
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
-                        Bool(n1_++),
-                        Bool(n2_++),
-                        Bool(n3_++),
-                        Bool(n4_++),
-                        Bool(n5_++));
-    finished_ = true;
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT5(PredFormatFunctor5(), Bool(n1_++), Bool(n2_++),
+                            Bool(n3_++), Bool(n4_++), Bool(n5_++));
+        finished_ = true;
+      },
+      "");
 }
diff --git a/googletest/googletest/test/gtest_premature_exit_test.cc b/googletest/googletest/test/gtest_premature_exit_test.cc
index 1d1187eff006cc88750ef957829d580ac690350b..1a0c5ea4f0d31ae34f8149eae3e739f601347a8c 100644
--- a/googletest/googletest/test/gtest_premature_exit_test.cc
+++ b/googletest/googletest/test/gtest_premature_exit_test.cc
@@ -81,15 +81,17 @@ TEST_F(PrematureExitDeathTest, FileExistsDuringExecutionOfDeathTest) {
     return;
   }
 
-  EXPECT_DEATH_IF_SUPPORTED({
-      // If the file exists, crash the process such that the main test
-      // process will catch the (expected) crash and report a success;
-      // otherwise don't crash, which will cause the main test process
-      // to report that the death test has failed.
-      if (PrematureExitFileExists()) {
-        exit(1);
-      }
-    }, "");
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        // If the file exists, crash the process such that the main test
+        // process will catch the (expected) crash and report a success;
+        // otherwise don't crash, which will cause the main test process
+        // to report that the death test has failed.
+        if (PrematureExitFileExists()) {
+          exit(1);
+        }
+      },
+      "");
 }
 
 // Tests that the premature-exit file exists during the execution of a
@@ -106,7 +108,7 @@ TEST_F(PrematureExitTest, PrematureExitFileExistsDuringTestExecution) {
 
 }  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   InitGoogleTest(&argc, argv);
   const int exit_code = RUN_ALL_TESTS();
 
diff --git a/googletest/googletest/test/gtest_repeat_test.cc b/googletest/googletest/test/gtest_repeat_test.cc
index 7da4a15ea141989f86426a572bac0a58b33f76ba..73fb8dc906a97ec505fbc27f3ea7111ed101c0ff 100644
--- a/googletest/googletest/test/gtest_repeat_test.cc
+++ b/googletest/googletest/test/gtest_repeat_test.cc
@@ -27,44 +27,32 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests the --gtest_repeat=number flag.
 
 #include <stdlib.h>
+
 #include <iostream>
+
 #include "gtest/gtest.h"
 #include "src/gtest-internal-inl.h"
 
-namespace testing {
-
-GTEST_DECLARE_string_(death_test_style);
-GTEST_DECLARE_string_(filter);
-GTEST_DECLARE_int32_(repeat);
-
-}  // namespace testing
-
-using testing::GTEST_FLAG(death_test_style);
-using testing::GTEST_FLAG(filter);
-using testing::GTEST_FLAG(repeat);
-
 namespace {
 
 // We need this when we are testing Google Test itself and therefore
 // cannot use Google Test assertions.
-#define GTEST_CHECK_INT_EQ_(expected, actual) \
-  do {\
-    const int expected_val = (expected);\
-    const int actual_val = (actual);\
-    if (::testing::internal::IsTrue(expected_val != actual_val)) {\
-      ::std::cout << "Value of: " #actual "\n"\
-                  << "  Actual: " << actual_val << "\n"\
-                  << "Expected: " #expected "\n"\
-                  << "Which is: " << expected_val << "\n";\
-      ::testing::internal::posix::Abort();\
-    }\
+#define GTEST_CHECK_INT_EQ_(expected, actual)                      \
+  do {                                                             \
+    const int expected_val = (expected);                           \
+    const int actual_val = (actual);                               \
+    if (::testing::internal::IsTrue(expected_val != actual_val)) { \
+      ::std::cout << "Value of: " #actual "\n"                     \
+                  << "  Actual: " << actual_val << "\n"            \
+                  << "Expected: " #expected "\n"                   \
+                  << "Which is: " << expected_val << "\n";         \
+      ::testing::internal::posix::Abort();                         \
+    }                                                              \
   } while (::testing::internal::AlwaysFalse())
 
-
 // Used for verifying that global environment set-up and tear-down are
 // inside the --gtest_repeat loop.
 
@@ -91,9 +79,7 @@ TEST(FooTest, ShouldFail) {
 
 int g_should_pass_count = 0;
 
-TEST(FooTest, ShouldPass) {
-  g_should_pass_count++;
-}
+TEST(FooTest, ShouldPass) { g_should_pass_count++; }
 
 // A test that contains a thread-safe death test and a fast death
 // test.  It should pass.
@@ -103,10 +89,10 @@ int g_death_test_count = 0;
 TEST(BarDeathTest, ThreadSafeAndFast) {
   g_death_test_count++;
 
-  GTEST_FLAG(death_test_style) = "threadsafe";
+  GTEST_FLAG_SET(death_test_style, "threadsafe");
   EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
 
-  GTEST_FLAG(death_test_style) = "fast";
+  GTEST_FLAG_SET(death_test_style, "fast");
   EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), "");
 }
 
@@ -120,8 +106,7 @@ TEST_P(MyParamTest, ShouldPass) {
   GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
   g_param_test_count++;
 }
-INSTANTIATE_TEST_SUITE_P(MyParamSequence,
-                         MyParamTest,
+INSTANTIATE_TEST_SUITE_P(MyParamSequence, MyParamTest,
                          testing::Range(0, kNumberOfParamTests));
 
 // Resets the count for each test.
@@ -153,7 +138,8 @@ void TestRepeatUnspecified() {
 
 // Tests the behavior of Google Test when --gtest_repeat has the given value.
 void TestRepeat(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
+  GTEST_FLAG_SET(repeat, repeat);
+  GTEST_FLAG_SET(recreate_environments_when_repeating, true);
 
   ResetCounts();
   GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
@@ -163,8 +149,9 @@ void TestRepeat(int repeat) {
 // Tests using --gtest_repeat when --gtest_filter specifies an empty
 // set of tests.
 void TestRepeatWithEmptyFilter(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "None";
+  GTEST_FLAG_SET(repeat, repeat);
+  GTEST_FLAG_SET(recreate_environments_when_repeating, true);
+  GTEST_FLAG_SET(filter, "None");
 
   ResetCounts();
   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
@@ -174,8 +161,9 @@ void TestRepeatWithEmptyFilter(int repeat) {
 // Tests using --gtest_repeat when --gtest_filter specifies a set of
 // successful tests.
 void TestRepeatWithFilterForSuccessfulTests(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "*-*ShouldFail";
+  GTEST_FLAG_SET(repeat, repeat);
+  GTEST_FLAG_SET(recreate_environments_when_repeating, true);
+  GTEST_FLAG_SET(filter, "*-*ShouldFail");
 
   ResetCounts();
   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
@@ -190,8 +178,9 @@ void TestRepeatWithFilterForSuccessfulTests(int repeat) {
 // Tests using --gtest_repeat when --gtest_filter specifies a set of
 // failed tests.
 void TestRepeatWithFilterForFailedTests(int repeat) {
-  GTEST_FLAG(repeat) = repeat;
-  GTEST_FLAG(filter) = "*ShouldFail";
+  GTEST_FLAG_SET(repeat, repeat);
+  GTEST_FLAG_SET(recreate_environments_when_repeating, true);
+  GTEST_FLAG_SET(filter, "*ShouldFail");
 
   ResetCounts();
   GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
diff --git a/googletest/googletest/test/gtest_skip_check_output_test.py b/googletest/googletest/test/gtest_skip_check_output_test.py
index 14e63ab897d9628c671c9364b1f3391703268569..1c87b44f01578df083f5c846126f9d8e7472640d 100644
--- a/googletest/googletest/test/gtest_skip_check_output_test.py
+++ b/googletest/googletest/test/gtest_skip_check_output_test.py
@@ -35,7 +35,7 @@ output.
 
 import re
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Path to the gtest_skip_in_environment_setup_test binary
 EXE_PATH = gtest_test_utils.GetTestExecutablePath('gtest_skip_test')
diff --git a/googletest/googletest/test/gtest_skip_environment_check_output_test.py b/googletest/googletest/test/gtest_skip_environment_check_output_test.py
index 6e791556aa71e5623a357af822713b4df2176403..6960b11a586650fff717687779ea3e85bd56f6b0 100644
--- a/googletest/googletest/test/gtest_skip_environment_check_output_test.py
+++ b/googletest/googletest/test/gtest_skip_environment_check_output_test.py
@@ -33,7 +33,7 @@ This script invokes gtest_skip_in_environment_setup_test_ and verifies its
 output.
 """
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 # Path to the gtest_skip_in_environment_setup_test binary
 EXE_PATH = gtest_test_utils.GetTestExecutablePath(
diff --git a/googletest/googletest/test/gtest_skip_in_environment_setup_test.cc b/googletest/googletest/test/gtest_skip_in_environment_setup_test.cc
index 937231063816e047acdd2fb416da80e4986438be..5f21c27dcdbd67721439d66168608c89a6aecad4 100644
--- a/googletest/googletest/test/gtest_skip_in_environment_setup_test.cc
+++ b/googletest/googletest/test/gtest_skip_in_environment_setup_test.cc
@@ -31,6 +31,7 @@
 // testcases being skipped.
 
 #include <iostream>
+
 #include "gtest/gtest.h"
 
 class SetupEnvironment : public testing::Environment {
diff --git a/googletest/googletest/test/gtest_skip_test.cc b/googletest/googletest/test/gtest_skip_test.cc
index 4a23004cca36814ec3bf7e0c124444ad64770c58..e1b8d655adae34648bc4cfbcf1a2fa29bc161642 100644
--- a/googletest/googletest/test/gtest_skip_test.cc
+++ b/googletest/googletest/test/gtest_skip_test.cc
@@ -46,10 +46,6 @@ class Fixture : public Test {
   }
 };
 
-TEST_F(Fixture, SkipsOneTest) {
-  EXPECT_EQ(5, 7);
-}
+TEST_F(Fixture, SkipsOneTest) { EXPECT_EQ(5, 7); }
 
-TEST_F(Fixture, SkipsAnotherTest) {
-  EXPECT_EQ(99, 100);
-}
+TEST_F(Fixture, SkipsAnotherTest) { EXPECT_EQ(99, 100); }
diff --git a/googletest/googletest/test/gtest_sole_header_test.cc b/googletest/googletest/test/gtest_sole_header_test.cc
index 1d94ac6b3ad9f9f7dbadbfb2bf749b8271560dac..e8e22a83c58ca6f9bfcb1f1c84b4c00daabc4759 100644
--- a/googletest/googletest/test/gtest_sole_header_test.cc
+++ b/googletest/googletest/test/gtest_sole_header_test.cc
@@ -35,9 +35,7 @@
 
 namespace {
 
-void Subroutine() {
-  EXPECT_EQ(42, 42);
-}
+void Subroutine() { EXPECT_EQ(42, 42); }
 
 TEST(NoFatalFailureTest, ExpectNoFatalFailure) {
   EXPECT_NO_FATAL_FAILURE(;);
diff --git a/googletest/googletest/test/gtest_stress_test.cc b/googletest/googletest/test/gtest_stress_test.cc
index 843481910f03f6989773c586b8e11eddbd6034cb..24b173ffd884c4044ea10a180d8ba16104622215 100644
--- a/googletest/googletest/test/gtest_stress_test.cc
+++ b/googletest/googletest/test/gtest_stress_test.cc
@@ -27,14 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests that SCOPED_TRACE() and various Google Test assertions can be
 // used in a large number of threads concurrently.
 
-#include "gtest/gtest.h"
-
 #include <vector>
 
+#include "gtest/gtest.h"
 #include "src/gtest-internal-inl.h"
 
 #if GTEST_IS_THREADSAFE
@@ -66,8 +64,7 @@ std::string IdToString(int id) {
 }
 
 void ExpectKeyAndValueWereRecordedForId(
-    const std::vector<TestProperty>& properties,
-    int id, const char* suffix) {
+    const std::vector<TestProperty>& properties, int id, const char* suffix) {
   TestPropertyKeyIs matches_key(IdToKey(id, suffix).c_str());
   const std::vector<TestProperty>::const_iterator property =
       std::find_if(properties.begin(), properties.end(), matches_key);
@@ -121,15 +118,13 @@ TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
     std::unique_ptr<ThreadWithParam<int> > threads[kThreadCount];
     Notification threads_can_start;
     for (int i = 0; i != kThreadCount; i++)
-      threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
-                                                i,
-                                                &threads_can_start));
+      threads[i].reset(
+          new ThreadWithParam<int>(&ManyAsserts, i, &threads_can_start));
 
     threads_can_start.Notify();
 
     // Blocks until all the threads are done.
-    for (int i = 0; i != kThreadCount; i++)
-      threads[i]->Join();
+    for (int i = 0; i != kThreadCount; i++) threads[i]->Join();
   }
 
   // Ensures that kThreadCount*kThreadCount failures have been reported.
@@ -149,7 +144,7 @@ TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
     ExpectKeyAndValueWereRecordedForId(properties, i, "string");
     ExpectKeyAndValueWereRecordedForId(properties, i, "int");
   }
-  CheckTestFailureCount(kThreadCount*kThreadCount);
+  CheckTestFailureCount(kThreadCount * kThreadCount);
 }
 
 void FailingThread(bool is_fatal) {
@@ -196,8 +191,8 @@ TEST(FatalFailureTest, ExpectFatalFailureIgnoresFailuresInOtherThreads) {
 TEST(FatalFailureOnAllThreadsTest, ExpectFatalFailureOnAllThreads) {
   // This statement should succeed, because failures in all threads are
   // considered.
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
-      GenerateFatalFailureInAnotherThread(true), "expected");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(GenerateFatalFailureInAnotherThread(true),
+                                      "expected");
   CheckTestFailureCount(0);
   // We need to add a failure, because main() checks that there are failures.
   // But when only this test is run, we shouldn't have any failures.
@@ -226,7 +221,7 @@ TEST(NonFatalFailureOnAllThreadsTest, ExpectNonFatalFailureOnAllThreads) {
 }  // namespace
 }  // namespace testing
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
 
   const int result = RUN_ALL_TESTS();  // Expected to fail.
@@ -238,8 +233,7 @@ int main(int argc, char **argv) {
 
 #else
 TEST(StressTest,
-     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {
-}
+     DISABLED_ThreadSafetyTestsAreSkippedWhenGoogleTestIsNotThreadSafe) {}
 
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/googletest/googletest/test/gtest_test_macro_stack_footprint_test.cc b/googletest/googletest/test/gtest_test_macro_stack_footprint_test.cc
index a48db05012cc30e0edf4a1354ff392c92d000bf0..45f368b3a5e3ced287beacfb1ba70e95a8f0f0b3 100644
--- a/googletest/googletest/test/gtest_test_macro_stack_footprint_test.cc
+++ b/googletest/googletest/test/gtest_test_macro_stack_footprint_test.cc
@@ -39,42 +39,42 @@
 
 // This macro defines 10 dummy tests.
 #define TEN_TESTS_(test_case_name) \
-  TEST(test_case_name, T0) {} \
-  TEST(test_case_name, T1) {} \
-  TEST(test_case_name, T2) {} \
-  TEST(test_case_name, T3) {} \
-  TEST(test_case_name, T4) {} \
-  TEST(test_case_name, T5) {} \
-  TEST(test_case_name, T6) {} \
-  TEST(test_case_name, T7) {} \
-  TEST(test_case_name, T8) {} \
+  TEST(test_case_name, T0) {}      \
+  TEST(test_case_name, T1) {}      \
+  TEST(test_case_name, T2) {}      \
+  TEST(test_case_name, T3) {}      \
+  TEST(test_case_name, T4) {}      \
+  TEST(test_case_name, T5) {}      \
+  TEST(test_case_name, T6) {}      \
+  TEST(test_case_name, T7) {}      \
+  TEST(test_case_name, T8) {}      \
   TEST(test_case_name, T9) {}
 
 // This macro defines 100 dummy tests.
 #define HUNDRED_TESTS_(test_case_name_prefix) \
-  TEN_TESTS_(test_case_name_prefix ## 0) \
-  TEN_TESTS_(test_case_name_prefix ## 1) \
-  TEN_TESTS_(test_case_name_prefix ## 2) \
-  TEN_TESTS_(test_case_name_prefix ## 3) \
-  TEN_TESTS_(test_case_name_prefix ## 4) \
-  TEN_TESTS_(test_case_name_prefix ## 5) \
-  TEN_TESTS_(test_case_name_prefix ## 6) \
-  TEN_TESTS_(test_case_name_prefix ## 7) \
-  TEN_TESTS_(test_case_name_prefix ## 8) \
-  TEN_TESTS_(test_case_name_prefix ## 9)
+  TEN_TESTS_(test_case_name_prefix##0)        \
+  TEN_TESTS_(test_case_name_prefix##1)        \
+  TEN_TESTS_(test_case_name_prefix##2)        \
+  TEN_TESTS_(test_case_name_prefix##3)        \
+  TEN_TESTS_(test_case_name_prefix##4)        \
+  TEN_TESTS_(test_case_name_prefix##5)        \
+  TEN_TESTS_(test_case_name_prefix##6)        \
+  TEN_TESTS_(test_case_name_prefix##7)        \
+  TEN_TESTS_(test_case_name_prefix##8)        \
+  TEN_TESTS_(test_case_name_prefix##9)
 
 // This macro defines 1000 dummy tests.
 #define THOUSAND_TESTS_(test_case_name_prefix) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 0) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 1) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 2) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 3) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 4) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 5) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 6) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 7) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 8) \
-  HUNDRED_TESTS_(test_case_name_prefix ## 9)
+  HUNDRED_TESTS_(test_case_name_prefix##0)     \
+  HUNDRED_TESTS_(test_case_name_prefix##1)     \
+  HUNDRED_TESTS_(test_case_name_prefix##2)     \
+  HUNDRED_TESTS_(test_case_name_prefix##3)     \
+  HUNDRED_TESTS_(test_case_name_prefix##4)     \
+  HUNDRED_TESTS_(test_case_name_prefix##5)     \
+  HUNDRED_TESTS_(test_case_name_prefix##6)     \
+  HUNDRED_TESTS_(test_case_name_prefix##7)     \
+  HUNDRED_TESTS_(test_case_name_prefix##8)     \
+  HUNDRED_TESTS_(test_case_name_prefix##9)
 
 // Ensures that we can define 1000 TEST()s in the same translation
 // unit.
diff --git a/googletest/googletest/test/gtest_test_utils.py b/googletest/googletest/test/gtest_test_utils.py
index d0c24466a4b7e3e623b5af495b8e26eaa8a9c864..eecc53346c277085ebae99e132dca3181b725296 100644
--- a/googletest/googletest/test/gtest_test_utils.py
+++ b/googletest/googletest/test/gtest_test_utils.py
@@ -32,6 +32,7 @@
 # pylint: disable-msg=C6204
 
 import os
+import subprocess
 import sys
 
 IS_WINDOWS = os.name == 'nt'
@@ -42,13 +43,6 @@ import atexit
 import shutil
 import tempfile
 import unittest as _test_module
-
-try:
-  import subprocess
-  _SUBPROCESS_MODULE_AVAILABLE = True
-except:
-  import popen2
-  _SUBPROCESS_MODULE_AVAILABLE = False
 # pylint: enable-msg=C6204
 
 GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
@@ -173,7 +167,7 @@ def GetTestExecutablePath(executable_name, build_dir=None):
         'Unable to find the test binary "%s". Please make sure to provide\n'
         'a path to the binary via the --build_dir flag or the BUILD_DIR\n'
         'environment variable.' % path)
-    print >> sys.stderr, message
+    print(message, file=sys.stderr)
     sys.exit(1)
 
   return path
@@ -224,69 +218,18 @@ class Subprocess:
                                combined in a string.
     """
 
-    # The subprocess module is the preferrable way of running programs
-    # since it is available and behaves consistently on all platforms,
-    # including Windows. But it is only available starting in python 2.4.
-    # In earlier python versions, we revert to the popen2 module, which is
-    # available in python 2.0 and later but doesn't provide required
-    # functionality (Popen4) under Windows. This allows us to support Mac
-    # OS X 10.4 Tiger, which has python 2.3 installed.
-    if _SUBPROCESS_MODULE_AVAILABLE:
-      if capture_stderr:
-        stderr = subprocess.STDOUT
-      else:
-        stderr = subprocess.PIPE
-
-      p = subprocess.Popen(command,
-                           stdout=subprocess.PIPE, stderr=stderr,
-                           cwd=working_dir, universal_newlines=True, env=env)
-      # communicate returns a tuple with the file object for the child's
-      # output.
-      self.output = p.communicate()[0]
-      self._return_code = p.returncode
+    if capture_stderr:
+      stderr = subprocess.STDOUT
     else:
-      old_dir = os.getcwd()
-
-      def _ReplaceEnvDict(dest, src):
-        # Changes made by os.environ.clear are not inheritable by child
-        # processes until Python 2.6. To produce inheritable changes we have
-        # to delete environment items with the del statement.
-        for key in dest.keys():
-          del dest[key]
-        dest.update(src)
-
-      # When 'env' is not None, backup the environment variables and replace
-      # them with the passed 'env'. When 'env' is None, we simply use the
-      # current 'os.environ' for compatibility with the subprocess.Popen
-      # semantics used above.
-      if env is not None:
-        old_environ = os.environ.copy()
-        _ReplaceEnvDict(os.environ, env)
-
-      try:
-        if working_dir is not None:
-          os.chdir(working_dir)
-        if capture_stderr:
-          p = popen2.Popen4(command)
-        else:
-          p = popen2.Popen3(command)
-        p.tochild.close()
-        self.output = p.fromchild.read()
-        ret_code = p.wait()
-      finally:
-        os.chdir(old_dir)
-
-        # Restore the old environment variables
-        # if they were replaced.
-        if env is not None:
-          _ReplaceEnvDict(os.environ, old_environ)
-
-      # Converts ret_code to match the semantics of
-      # subprocess.Popen.returncode.
-      if os.WIFSIGNALED(ret_code):
-        self._return_code = -os.WTERMSIG(ret_code)
-      else:  # os.WIFEXITED(ret_code) should return True here.
-        self._return_code = os.WEXITSTATUS(ret_code)
+      stderr = subprocess.PIPE
+
+    p = subprocess.Popen(command,
+                         stdout=subprocess.PIPE, stderr=stderr,
+                         cwd=working_dir, universal_newlines=True, env=env)
+    # communicate returns a tuple with the file object for the child's
+    # output.
+    self.output = p.communicate()[0]
+    self._return_code = p.returncode
 
     if bool(self._return_code & 0x80000000):
       self.terminated_by_signal = True
diff --git a/googletest/googletest/test/gtest_testbridge_test.py b/googletest/googletest/test/gtest_testbridge_test.py
index 87ffad73d40065298f30500de824d808b6571d8d..1c2a303a8887a5c2904044807958c18cba675be4 100644
--- a/googletest/googletest/test/gtest_testbridge_test.py
+++ b/googletest/googletest/test/gtest_testbridge_test.py
@@ -31,7 +31,7 @@
 
 import os
 
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 binary_name = 'gtest_testbridge_test_'
 COMMAND = gtest_test_utils.GetTestExecutablePath(binary_name)
diff --git a/googletest/googletest/test/gtest_testbridge_test_.cc b/googletest/googletest/test/gtest_testbridge_test_.cc
index 24617b209e10a9d1798368e26465aaa62715f0ee..c2c000dca50d07b065e3b24d2aa6738e6e9af98f 100644
--- a/googletest/googletest/test/gtest_testbridge_test_.cc
+++ b/googletest/googletest/test/gtest_testbridge_test_.cc
@@ -27,7 +27,6 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // This program is meant to be run by gtest_test_filter_test.py.  Do not run
 // it directly.
 
diff --git a/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc b/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
index 1d95adbf537ba9178163987c0d3e0c8aa03ab5ee..25d7c797ed4c249da9e471c940178234ddaa1dd5 100644
--- a/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
+++ b/googletest/googletest/test/gtest_throw_on_failure_ex_test.cc
@@ -27,16 +27,16 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Tests Google Test's throw-on-failure mode with exceptions enabled.
 
-#include "gtest/gtest.h"
-
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+
 #include <stdexcept>
 
+#include "gtest/gtest.h"
+
 // Prints the given failure message and exits the program with
 // non-zero.  We use this instead of a Google Test assertion to
 // indicate a failure, as the latter is been tested and cannot be
@@ -50,19 +50,19 @@ void Fail(const char* msg) {
 // Tests that an assertion failure throws a subclass of
 // std::runtime_error.
 void TestFailureThrowsRuntimeError() {
-  testing::GTEST_FLAG(throw_on_failure) = true;
+  GTEST_FLAG_SET(throw_on_failure, true);
 
   // A successful assertion shouldn't throw.
   try {
     EXPECT_EQ(3, 3);
-  } catch(...) {
+  } catch (...) {
     Fail("A successful assertion wrongfully threw.");
   }
 
   // A failed assertion should throw a subclass of std::runtime_error.
   try {
     EXPECT_EQ(2, 3) << "Expected failure";
-  } catch(const std::runtime_error& e) {
+  } catch (const std::runtime_error& e) {
     if (strstr(e.what(), "Expected failure") != nullptr) return;
 
     printf("%s",
@@ -70,7 +70,7 @@ void TestFailureThrowsRuntimeError() {
            "but the message is incorrect.  Instead of containing \"Expected "
            "failure\", it is:\n");
     Fail(e.what());
-  } catch(...) {
+  } catch (...) {
     Fail("A failed assertion threw the wrong type of exception.");
   }
   Fail("A failed assertion should've thrown but didn't.");
diff --git a/googletest/googletest/test/gtest_unittest.cc b/googletest/googletest/test/gtest_unittest.cc
index 1730e8b8c9c9b742b5dcfd1f5055b2f232d483dd..e66e66b95ed47566d67fd85cf3053a7e089b1995 100644
--- a/googletest/googletest/test/gtest_unittest.cc
+++ b/googletest/googletest/test/gtest_unittest.cc
@@ -37,22 +37,19 @@
 // code once "gtest.h" has been #included.
 // Do not move it after other gtest #includes.
 TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
-  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) ||
-               testing::GTEST_FLAG(break_on_failure) ||
-               testing::GTEST_FLAG(catch_exceptions) ||
-               testing::GTEST_FLAG(color) != "unknown" ||
-               testing::GTEST_FLAG(fail_fast) ||
-               testing::GTEST_FLAG(filter) != "unknown" ||
-               testing::GTEST_FLAG(list_tests) ||
-               testing::GTEST_FLAG(output) != "unknown" ||
-               testing::GTEST_FLAG(brief) || testing::GTEST_FLAG(print_time) ||
-               testing::GTEST_FLAG(random_seed) ||
-               testing::GTEST_FLAG(repeat) > 0 ||
-               testing::GTEST_FLAG(show_internal_stack_frames) ||
-               testing::GTEST_FLAG(shuffle) ||
-               testing::GTEST_FLAG(stack_trace_depth) > 0 ||
-               testing::GTEST_FLAG(stream_result_to) != "unknown" ||
-               testing::GTEST_FLAG(throw_on_failure);
+  bool dummy =
+      GTEST_FLAG_GET(also_run_disabled_tests) ||
+      GTEST_FLAG_GET(break_on_failure) || GTEST_FLAG_GET(catch_exceptions) ||
+      GTEST_FLAG_GET(color) != "unknown" || GTEST_FLAG_GET(fail_fast) ||
+      GTEST_FLAG_GET(filter) != "unknown" || GTEST_FLAG_GET(list_tests) ||
+      GTEST_FLAG_GET(output) != "unknown" || GTEST_FLAG_GET(brief) ||
+      GTEST_FLAG_GET(print_time) || GTEST_FLAG_GET(random_seed) ||
+      GTEST_FLAG_GET(repeat) > 0 ||
+      GTEST_FLAG_GET(recreate_environments_when_repeating) ||
+      GTEST_FLAG_GET(show_internal_stack_frames) || GTEST_FLAG_GET(shuffle) ||
+      GTEST_FLAG_GET(stack_trace_depth) > 0 ||
+      GTEST_FLAG_GET(stream_result_to) != "unknown" ||
+      GTEST_FLAG_GET(throw_on_failure);
   EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
 }
 
@@ -64,6 +61,7 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
 #include <cstdint>
 #include <map>
 #include <ostream>
+#include <set>
 #include <string>
 #include <type_traits>
 #include <unordered_set>
@@ -114,15 +112,15 @@ TEST_F(StreamingListenerTest, OnTestIterationEnd) {
   EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output());
 }
 
-TEST_F(StreamingListenerTest, OnTestCaseStart) {
+TEST_F(StreamingListenerTest, OnTestSuiteStart) {
   *output() = "";
-  streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", nullptr, nullptr));
+  streamer_.OnTestSuiteStart(TestSuite("FooTest", "Bar", nullptr, nullptr));
   EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output());
 }
 
-TEST_F(StreamingListenerTest, OnTestCaseEnd) {
+TEST_F(StreamingListenerTest, OnTestSuiteEnd) {
   *output() = "";
-  streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", nullptr, nullptr));
+  streamer_.OnTestSuiteEnd(TestSuite("FooTest", "Bar", nullptr, nullptr));
   EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output());
 }
 
@@ -140,8 +138,8 @@ TEST_F(StreamingListenerTest, OnTestEnd) {
 
 TEST_F(StreamingListenerTest, OnTestPartResult) {
   *output() = "";
-  streamer_.OnTestPartResult(TestPartResult(
-      TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%"));
+  streamer_.OnTestPartResult(TestPartResult(TestPartResult::kFatalFailure,
+                                            "foo.cc", 42, "failed=\n&%"));
 
   // Meta characters in the failure message should be properly escaped.
   EXPECT_EQ(
@@ -199,24 +197,6 @@ using testing::DoubleLE;
 using testing::EmptyTestEventListener;
 using testing::Environment;
 using testing::FloatLE;
-using testing::GTEST_FLAG(also_run_disabled_tests);
-using testing::GTEST_FLAG(break_on_failure);
-using testing::GTEST_FLAG(catch_exceptions);
-using testing::GTEST_FLAG(color);
-using testing::GTEST_FLAG(death_test_use_fork);
-using testing::GTEST_FLAG(fail_fast);
-using testing::GTEST_FLAG(filter);
-using testing::GTEST_FLAG(list_tests);
-using testing::GTEST_FLAG(output);
-using testing::GTEST_FLAG(brief);
-using testing::GTEST_FLAG(print_time);
-using testing::GTEST_FLAG(random_seed);
-using testing::GTEST_FLAG(repeat);
-using testing::GTEST_FLAG(show_internal_stack_frames);
-using testing::GTEST_FLAG(shuffle);
-using testing::GTEST_FLAG(stack_trace_depth);
-using testing::GTEST_FLAG(stream_result_to);
-using testing::GTEST_FLAG(throw_on_failure);
 using testing::IsNotSubstring;
 using testing::IsSubstring;
 using testing::kMaxStackTraceDepth;
@@ -265,7 +245,7 @@ using testing::internal::kTestTypeIdInGoogleTest;
 using testing::internal::NativeArray;
 using testing::internal::OsStackTraceGetter;
 using testing::internal::OsStackTraceGetterInterface;
-using testing::internal::ParseInt32Flag;
+using testing::internal::ParseFlag;
 using testing::internal::RelationToSourceCopy;
 using testing::internal::RelationToSourceReference;
 using testing::internal::ShouldRunTestOnShard;
@@ -293,11 +273,9 @@ using testing::internal::GetCapturedStdout;
 using testing::internal::ThreadWithParam;
 #endif
 
-class TestingVector : public std::vector<int> {
-};
+class TestingVector : public std::vector<int> {};
 
-::std::ostream& operator<<(::std::ostream& os,
-                           const TestingVector& vector) {
+::std::ostream& operator<<(::std::ostream& os, const TestingVector& vector) {
   os << "{ ";
   for (size_t i = 0; i < vector.size(); i++) {
     os << vector[i] << " ";
@@ -425,7 +403,7 @@ TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
 
 // Tests FormatEpochTimeInMillisAsIso8601().  The correctness of conversion
 // for particular dates below was verified in Python using
-// datetime.datetime.fromutctimestamp(<timetamp>/1000).
+// datetime.datetime.fromutctimestamp(<timestamp>/1000).
 
 // FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
 // have to set up a particular timezone to obtain predictable results.
@@ -441,8 +419,7 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
     saved_tz_ = nullptr;
 
     GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv, strdup: deprecated */)
-    if (getenv("TZ"))
-      saved_tz_ = strdup(getenv("TZ"));
+    if (getenv("TZ")) saved_tz_ = strdup(getenv("TZ"));
     GTEST_DISABLE_MSC_DEPRECATED_POP_()
 
     // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use.  We
@@ -471,6 +448,12 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
     tzset();
     GTEST_DISABLE_MSC_WARNINGS_POP_()
 #else
+#if GTEST_OS_LINUX_ANDROID && __ANDROID_API__ < 21
+    // Work around KitKat bug in tzset by setting "UTC" before setting "UTC+00".
+    // See https://github.com/android/ndk/issues/1604.
+    setenv("TZ", "UTC", 1);
+    tzset();
+#endif
     if (time_zone) {
       setenv(("TZ"), time_zone, 1);
     } else {
@@ -491,9 +474,8 @@ TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
 }
 
 TEST_F(FormatEpochTimeInMillisAsIso8601Test, IncludesMillisecondsAfterDot) {
-  EXPECT_EQ(
-      "2011-10-31T18:52:42.234",
-      FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
+  EXPECT_EQ("2011-10-31T18:52:42.234",
+            FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
 }
 
 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
@@ -510,10 +492,10 @@ TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
   EXPECT_EQ("1970-01-01T00:00:00.000", FormatEpochTimeInMillisAsIso8601(0));
 }
 
-# ifdef __BORLANDC__
+#ifdef __BORLANDC__
 // Silences warnings: "Condition is always true", "Unreachable code"
-#  pragma option push -w-ccc -w-rch
-# endif
+#pragma option push -w-ccc -w-rch
+#endif
 
 // Tests that the LHS of EXPECT_EQ or ASSERT_EQ can be used as a null literal
 // when the RHS is a pointer type.
@@ -587,10 +569,10 @@ TEST(NullLiteralTest, NoConversionNoWarning) {
 #pragma clang diagnostic pop
 #endif
 
-# ifdef __BORLANDC__
+#ifdef __BORLANDC__
 // Restores warnings after previous "#pragma option push" suppressed them.
-#  pragma option pop
-# endif
+#pragma option pop
+#endif
 
 //
 // Tests CodePointToUtf8().
@@ -618,20 +600,17 @@ TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
   // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
   // in wide strings and wide chars. In order to accommodate them, we have to
   // introduce such character constants as integers.
-  EXPECT_EQ("\xD5\xB6",
-            CodePointToUtf8(static_cast<wchar_t>(0x576)));
+  EXPECT_EQ("\xD5\xB6", CodePointToUtf8(static_cast<wchar_t>(0x576)));
 }
 
 // Tests that Unicode code-points that have 12 to 16 bits are encoded
 // as 1110xxxx 10xxxxxx 10xxxxxx.
 TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
   // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
-  EXPECT_EQ("\xE0\xA3\x93",
-            CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
+  EXPECT_EQ("\xE0\xA3\x93", CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
 
   // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
-  EXPECT_EQ("\xEC\x9D\x8D",
-            CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
+  EXPECT_EQ("\xEC\x9D\x8D", CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
 }
 
 #if !GTEST_WIDE_STRING_USES_UTF16_
@@ -683,7 +662,7 @@ TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
   EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
 
   // 101 0111 0110 => 110-10101 10-110110
-  const wchar_t s[] = { 0x576, '\0' };
+  const wchar_t s[] = {0x576, '\0'};
   EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
   EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
 }
@@ -692,12 +671,12 @@ TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
 // as 1110xxxx 10xxxxxx 10xxxxxx.
 TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
   // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
-  const wchar_t s1[] = { 0x8D3, '\0' };
+  const wchar_t s1[] = {0x8D3, '\0'};
   EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
   EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
 
   // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
-  const wchar_t s2[] = { 0xC74D, '\0' };
+  const wchar_t s2[] = {0xC74D, '\0'};
   EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
   EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
 }
@@ -732,11 +711,11 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
   EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
                WideStringToUtf8(L"\xABCDFF", -1).c_str());
 }
-#else  // !GTEST_WIDE_STRING_USES_UTF16_
+#else   // !GTEST_WIDE_STRING_USES_UTF16_
 // Tests that surrogate pairs are encoded correctly on the systems using
 // UTF-16 encoding in the wide strings.
 TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
-  const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
+  const wchar_t s[] = {0xD801, 0xDC00, '\0'};
   EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
 }
 
@@ -744,13 +723,13 @@ TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
 // generates the expected result.
 TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
   // Leading surrogate is at the end of the string.
-  const wchar_t s1[] = { 0xD800, '\0' };
+  const wchar_t s1[] = {0xD800, '\0'};
   EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
   // Leading surrogate is not followed by the trailing surrogate.
-  const wchar_t s2[] = { 0xD800, 'M', '\0' };
+  const wchar_t s2[] = {0xD800, 'M', '\0'};
   EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
   // Trailing surrogate appearas without a leading surrogate.
-  const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
+  const wchar_t s3[] = {0xDC00, 'P', 'Q', 'R', '\0'};
   EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
 }
 #endif  // !GTEST_WIDE_STRING_USES_UTF16_
@@ -758,21 +737,24 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
 // Tests that codepoint concatenation works correctly.
 #if !GTEST_WIDE_STRING_USES_UTF16_
 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
-  const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
+  const wchar_t s[] = {0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
   EXPECT_STREQ(
       "\xF4\x88\x98\xB4"
-          "\xEC\x9D\x8D"
-          "\n"
-          "\xD5\xB6"
-          "\xE0\xA3\x93"
-          "\xF4\x88\x98\xB4",
+      "\xEC\x9D\x8D"
+      "\n"
+      "\xD5\xB6"
+      "\xE0\xA3\x93"
+      "\xF4\x88\x98\xB4",
       WideStringToUtf8(s, -1).c_str());
 }
 #else
 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
-  const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
+  const wchar_t s[] = {0xC74D, '\n', 0x576, 0x8D3, '\0'};
   EXPECT_STREQ(
-      "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
+      "\xEC\x9D\x8D"
+      "\n"
+      "\xD5\xB6"
+      "\xE0\xA3\x93",
       WideStringToUtf8(s, -1).c_str());
 }
 #endif  // !GTEST_WIDE_STRING_USES_UTF16_
@@ -781,9 +763,8 @@ TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
 
 TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
   testing::internal::Random random(42);
-  EXPECT_DEATH_IF_SUPPORTED(
-      random.Generate(0),
-      "Cannot generate a number in the range \\[0, 0\\)");
+  EXPECT_DEATH_IF_SUPPORTED(random.Generate(0),
+                            "Cannot generate a number in the range \\[0, 0\\)");
   EXPECT_DEATH_IF_SUPPORTED(
       random.Generate(testing::internal::Random::kMaxRange + 1),
       "Generation of a number in \\[0, 2147483649\\) was requested, "
@@ -912,7 +893,7 @@ class VectorShuffleTest : public Test {
       return true;
     }
 
-    bool found_in_vector[kVectorSize] = { false };
+    bool found_in_vector[kVectorSize] = {false};
     for (size_t i = 0; i < vector.size(); i++) {
       const int e = vector[i];
       if (e < 0 || e >= static_cast<int>(kVectorSize) || found_in_vector[e]) {
@@ -939,8 +920,8 @@ class VectorShuffleTest : public Test {
     return false;
   }
 
-  static bool RangeIsUnshuffled(
-      const TestingVector& vector, int begin, int end) {
+  static bool RangeIsUnshuffled(const TestingVector& vector, int begin,
+                                int end) {
     return !RangeIsShuffled(vector, begin, end);
   }
 
@@ -965,7 +946,7 @@ TEST_F(VectorShuffleTest, HandlesEmptyRange) {
   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 
   // ...in the middle...
-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
+  ShuffleRange(&random_, kVectorSize / 2, kVectorSize / 2, &vector_);
   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 
@@ -987,7 +968,7 @@ TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 
   // ...in the middle...
-  ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
+  ShuffleRange(&random_, kVectorSize / 2, kVectorSize / 2 + 1, &vector_);
   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
   ASSERT_PRED1(VectorIsUnshuffled, vector_);
 
@@ -1012,7 +993,7 @@ TEST_F(VectorShuffleTest, ShufflesEntireVector) {
 }
 
 TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
-  const int kRangeSize = kVectorSize/2;
+  const int kRangeSize = kVectorSize / 2;
 
   ShuffleRange(&random_, 0, kRangeSize, &vector_);
 
@@ -1034,11 +1015,11 @@ TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
 
 TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
   const int kRangeSize = static_cast<int>(kVectorSize) / 3;
-  ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
+  ShuffleRange(&random_, kRangeSize, 2 * kRangeSize, &vector_);
 
   ASSERT_PRED1(VectorIsNotCorrupt, vector_);
   EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
-  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
+  EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2 * kRangeSize);
   EXPECT_PRED3(RangeIsUnshuffled, vector_, 2 * kRangeSize,
                static_cast<int>(kVectorSize));
 }
@@ -1103,13 +1084,12 @@ TEST(StringTest, CaseInsensitiveWideCStringEquals) {
 
 // Tests String::ShowWideCString().
 TEST(StringTest, ShowWideCString) {
-  EXPECT_STREQ("(null)",
-               String::ShowWideCString(NULL).c_str());
+  EXPECT_STREQ("(null)", String::ShowWideCString(NULL).c_str());
   EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
   EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
 }
 
-# if GTEST_OS_WINDOWS_MOBILE
+#if GTEST_OS_WINDOWS_MOBILE
 TEST(StringTest, AnsiAndUtf16Null) {
   EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
   EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
@@ -1118,21 +1098,21 @@ TEST(StringTest, AnsiAndUtf16Null) {
 TEST(StringTest, AnsiAndUtf16ConvertBasic) {
   const char* ansi = String::Utf16ToAnsi(L"str");
   EXPECT_STREQ("str", ansi);
-  delete [] ansi;
+  delete[] ansi;
   const WCHAR* utf16 = String::AnsiToUtf16("str");
   EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
-  delete [] utf16;
+  delete[] utf16;
 }
 
 TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
   const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
   EXPECT_STREQ(".:\\ \"*?", ansi);
-  delete [] ansi;
+  delete[] ansi;
   const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
   EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
-  delete [] utf16;
+  delete[] utf16;
 }
-# endif  // GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_OS_WINDOWS_MOBILE
 
 #endif  // GTEST_OS_WINDOWS
 
@@ -1154,9 +1134,7 @@ TEST(TestPropertyTest, ReplaceStringValue) {
 // AddFatalFailure() and AddNonfatalFailure() must be stand-alone
 // functions (i.e. their definitions cannot be inlined at the call
 // sites), or C++Builder won't compile the code.
-static void AddFatalFailure() {
-  FAIL() << "Expected fatal failure.";
-}
+static void AddFatalFailure() { FAIL() << "Expected fatal failure."; }
 
 static void AddNonfatalFailure() {
   ADD_FAILURE() << "Expected non-fatal failure.";
@@ -1164,10 +1142,7 @@ static void AddNonfatalFailure() {
 
 class ScopedFakeTestPartResultReporterTest : public Test {
  public:  // Must be public and not protected due to a bug in g++ 3.4.2.
-  enum FailureMode {
-    FATAL_FAILURE,
-    NONFATAL_FAILURE
-  };
+  enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE };
   static void AddFailure(FailureMode failure) {
     if (failure == FATAL_FAILURE) {
       AddFatalFailure();
@@ -1207,7 +1182,7 @@ TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
 #if GTEST_IS_THREADSAFE
 
 class ScopedFakeTestPartResultReporterWithThreadsTest
-  : public ScopedFakeTestPartResultReporterTest {
+    : public ScopedFakeTestPartResultReporterTest {
  protected:
   static void AddFailureInOtherThread(FailureMode failure) {
     ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);
@@ -1260,7 +1235,7 @@ TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
 
 #ifdef __BORLANDC__
 // Silences warnings: "Condition is always true"
-# pragma option push -w-ccc
+#pragma option push -w-ccc
 #endif
 
 // Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
@@ -1288,7 +1263,7 @@ void DoesNotAbortHelper(bool* aborted) {
 
 #ifdef __BORLANDC__
 // Restores warnings after previous "#pragma option push" suppressed them.
-# pragma option pop
+#pragma option pop
 #endif
 
 TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
@@ -1307,16 +1282,20 @@ static int global_var = 0;
 TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
 #ifndef __BORLANDC__
   // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddFatalFailure();
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {
+        GTEST_USE_UNPROTECTED_COMMA_;
+        AddFatalFailure();
+      },
+      "");
 #endif
 
-  EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddFatalFailure();
-  }, "");
+  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
+      {
+        GTEST_USE_UNPROTECTED_COMMA_;
+        AddFatalFailure();
+      },
+      "");
 }
 
 // Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
@@ -1324,8 +1303,7 @@ TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
 typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
 
 TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
-  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
-                          "Expected non-fatal failure.");
+  EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), "Expected non-fatal failure.");
 }
 
 TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
@@ -1344,15 +1322,19 @@ TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
 // statement that contains a macro which expands to code containing an
 // unprotected comma.
 TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
-  EXPECT_NONFATAL_FAILURE({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddNonfatalFailure();
-  }, "");
+  EXPECT_NONFATAL_FAILURE(
+      {
+        GTEST_USE_UNPROTECTED_COMMA_;
+        AddNonfatalFailure();
+      },
+      "");
 
-  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
-    GTEST_USE_UNPROTECTED_COMMA_;
-    AddNonfatalFailure();
-  }, "");
+  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
+      {
+        GTEST_USE_UNPROTECTED_COMMA_;
+        AddNonfatalFailure();
+      },
+      "");
 }
 
 #if GTEST_IS_THREADSAFE
@@ -1396,21 +1378,18 @@ class TestResultTest : public Test {
   typedef std::vector<TestPartResult> TPRVector;
 
   // We make use of 2 TestPartResult objects,
-  TestPartResult * pr1, * pr2;
+  TestPartResult *pr1, *pr2;
 
   // ... and 3 TestResult objects.
-  TestResult * r0, * r1, * r2;
+  TestResult *r0, *r1, *r2;
 
   void SetUp() override {
     // pr1 is for success.
-    pr1 = new TestPartResult(TestPartResult::kSuccess,
-                             "foo/bar.cc",
-                             10,
+    pr1 = new TestPartResult(TestPartResult::kSuccess, "foo/bar.cc", 10,
                              "Success!");
 
     // pr2 is for fatal failure.
-    pr2 = new TestPartResult(TestPartResult::kFatalFailure,
-                             "foo/bar.cc",
+    pr2 = new TestPartResult(TestPartResult::kFatalFailure, "foo/bar.cc",
                              -1,  // This line number means "unknown"
                              "Failure!");
 
@@ -1423,10 +1402,10 @@ class TestResultTest : public Test {
     // state, in particular the TestPartResult vector it holds.
     // test_part_results() returns a const reference to this vector.
     // We cast it to a non-const object s.t. it can be modified
-    TPRVector* results1 = const_cast<TPRVector*>(
-        &TestResultAccessor::test_part_results(*r1));
-    TPRVector* results2 = const_cast<TPRVector*>(
-        &TestResultAccessor::test_part_results(*r2));
+    TPRVector* results1 =
+        const_cast<TPRVector*>(&TestResultAccessor::test_part_results(*r1));
+    TPRVector* results2 =
+        const_cast<TPRVector*>(&TestResultAccessor::test_part_results(*r2));
 
     // r0 is an empty TestResult.
 
@@ -1597,23 +1576,24 @@ class GTestFlagSaverTest : public Test {
   static void SetUpTestSuite() {
     saver_ = new GTestFlagSaver;
 
-    GTEST_FLAG(also_run_disabled_tests) = false;
-    GTEST_FLAG(break_on_failure) = false;
-    GTEST_FLAG(catch_exceptions) = false;
-    GTEST_FLAG(death_test_use_fork) = false;
-    GTEST_FLAG(color) = "auto";
-    GTEST_FLAG(fail_fast) = false;
-    GTEST_FLAG(filter) = "";
-    GTEST_FLAG(list_tests) = false;
-    GTEST_FLAG(output) = "";
-    GTEST_FLAG(brief) = false;
-    GTEST_FLAG(print_time) = true;
-    GTEST_FLAG(random_seed) = 0;
-    GTEST_FLAG(repeat) = 1;
-    GTEST_FLAG(shuffle) = false;
-    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
-    GTEST_FLAG(stream_result_to) = "";
-    GTEST_FLAG(throw_on_failure) = false;
+    GTEST_FLAG_SET(also_run_disabled_tests, false);
+    GTEST_FLAG_SET(break_on_failure, false);
+    GTEST_FLAG_SET(catch_exceptions, false);
+    GTEST_FLAG_SET(death_test_use_fork, false);
+    GTEST_FLAG_SET(color, "auto");
+    GTEST_FLAG_SET(fail_fast, false);
+    GTEST_FLAG_SET(filter, "");
+    GTEST_FLAG_SET(list_tests, false);
+    GTEST_FLAG_SET(output, "");
+    GTEST_FLAG_SET(brief, false);
+    GTEST_FLAG_SET(print_time, true);
+    GTEST_FLAG_SET(random_seed, 0);
+    GTEST_FLAG_SET(repeat, 1);
+    GTEST_FLAG_SET(recreate_environments_when_repeating, true);
+    GTEST_FLAG_SET(shuffle, false);
+    GTEST_FLAG_SET(stack_trace_depth, kMaxStackTraceDepth);
+    GTEST_FLAG_SET(stream_result_to, "");
+    GTEST_FLAG_SET(throw_on_failure, false);
   }
 
   // Restores the Google Test flags that the tests have modified.  This will
@@ -1626,41 +1606,43 @@ class GTestFlagSaverTest : public Test {
   // Verifies that the Google Test flags have their default values, and then
   // modifies each of them.
   void VerifyAndModifyFlags() {
-    EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
-    EXPECT_FALSE(GTEST_FLAG(break_on_failure));
-    EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
-    EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
-    EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
-    EXPECT_FALSE(GTEST_FLAG(fail_fast));
-    EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
-    EXPECT_FALSE(GTEST_FLAG(list_tests));
-    EXPECT_STREQ("", GTEST_FLAG(output).c_str());
-    EXPECT_FALSE(GTEST_FLAG(brief));
-    EXPECT_TRUE(GTEST_FLAG(print_time));
-    EXPECT_EQ(0, GTEST_FLAG(random_seed));
-    EXPECT_EQ(1, GTEST_FLAG(repeat));
-    EXPECT_FALSE(GTEST_FLAG(shuffle));
-    EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
-    EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
-    EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
-
-    GTEST_FLAG(also_run_disabled_tests) = true;
-    GTEST_FLAG(break_on_failure) = true;
-    GTEST_FLAG(catch_exceptions) = true;
-    GTEST_FLAG(color) = "no";
-    GTEST_FLAG(death_test_use_fork) = true;
-    GTEST_FLAG(fail_fast) = true;
-    GTEST_FLAG(filter) = "abc";
-    GTEST_FLAG(list_tests) = true;
-    GTEST_FLAG(output) = "xml:foo.xml";
-    GTEST_FLAG(brief) = true;
-    GTEST_FLAG(print_time) = false;
-    GTEST_FLAG(random_seed) = 1;
-    GTEST_FLAG(repeat) = 100;
-    GTEST_FLAG(shuffle) = true;
-    GTEST_FLAG(stack_trace_depth) = 1;
-    GTEST_FLAG(stream_result_to) = "localhost:1234";
-    GTEST_FLAG(throw_on_failure) = true;
+    EXPECT_FALSE(GTEST_FLAG_GET(also_run_disabled_tests));
+    EXPECT_FALSE(GTEST_FLAG_GET(break_on_failure));
+    EXPECT_FALSE(GTEST_FLAG_GET(catch_exceptions));
+    EXPECT_STREQ("auto", GTEST_FLAG_GET(color).c_str());
+    EXPECT_FALSE(GTEST_FLAG_GET(death_test_use_fork));
+    EXPECT_FALSE(GTEST_FLAG_GET(fail_fast));
+    EXPECT_STREQ("", GTEST_FLAG_GET(filter).c_str());
+    EXPECT_FALSE(GTEST_FLAG_GET(list_tests));
+    EXPECT_STREQ("", GTEST_FLAG_GET(output).c_str());
+    EXPECT_FALSE(GTEST_FLAG_GET(brief));
+    EXPECT_TRUE(GTEST_FLAG_GET(print_time));
+    EXPECT_EQ(0, GTEST_FLAG_GET(random_seed));
+    EXPECT_EQ(1, GTEST_FLAG_GET(repeat));
+    EXPECT_TRUE(GTEST_FLAG_GET(recreate_environments_when_repeating));
+    EXPECT_FALSE(GTEST_FLAG_GET(shuffle));
+    EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG_GET(stack_trace_depth));
+    EXPECT_STREQ("", GTEST_FLAG_GET(stream_result_to).c_str());
+    EXPECT_FALSE(GTEST_FLAG_GET(throw_on_failure));
+
+    GTEST_FLAG_SET(also_run_disabled_tests, true);
+    GTEST_FLAG_SET(break_on_failure, true);
+    GTEST_FLAG_SET(catch_exceptions, true);
+    GTEST_FLAG_SET(color, "no");
+    GTEST_FLAG_SET(death_test_use_fork, true);
+    GTEST_FLAG_SET(fail_fast, true);
+    GTEST_FLAG_SET(filter, "abc");
+    GTEST_FLAG_SET(list_tests, true);
+    GTEST_FLAG_SET(output, "xml:foo.xml");
+    GTEST_FLAG_SET(brief, true);
+    GTEST_FLAG_SET(print_time, false);
+    GTEST_FLAG_SET(random_seed, 1);
+    GTEST_FLAG_SET(repeat, 100);
+    GTEST_FLAG_SET(recreate_environments_when_repeating, false);
+    GTEST_FLAG_SET(shuffle, true);
+    GTEST_FLAG_SET(stack_trace_depth, 1);
+    GTEST_FLAG_SET(stream_result_to, "localhost:1234");
+    GTEST_FLAG_SET(throw_on_failure, true);
   }
 
  private:
@@ -1674,15 +1656,11 @@ GTestFlagSaver* GTestFlagSaverTest::saver_ = nullptr;
 // tests are designed to work regardless of their order.
 
 // Modifies the Google Test flags in the test body.
-TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
-  VerifyAndModifyFlags();
-}
+TEST_F(GTestFlagSaverTest, ModifyGTestFlags) { VerifyAndModifyFlags(); }
 
 // Verifies that the Google Test flags in the body of the previous test were
 // restored to their original values.
-TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
-  VerifyAndModifyFlags();
-}
+TEST_F(GTestFlagSaverTest, VerifyGTestFlags) { VerifyAndModifyFlags(); }
 
 // Sets an environment variable with the given name to the given
 // value.  If the value argument is "", unsets the environment
@@ -1699,12 +1677,12 @@ static void SetEnv(const char* name, const char* value) {
 
   // Because putenv stores a pointer to the string buffer, we can't delete the
   // previous string (if present) until after it's replaced.
-  std::string *prev_env = NULL;
+  std::string* prev_env = NULL;
   if (added_env.find(name) != added_env.end()) {
     prev_env = added_env[name];
   }
-  added_env[name] = new std::string(
-      (Message() << name << "=" << value).GetString());
+  added_env[name] =
+      new std::string((Message() << name << "=" << value).GetString());
 
   // The standard signature of putenv accepts a 'char*' argument. Other
   // implementations, like C++Builder's, accept a 'const char*'.
@@ -1736,7 +1714,7 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
   EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
 }
 
-# if !defined(GTEST_GET_INT32_FROM_ENV_)
+#if !defined(GTEST_GET_INT32_FROM_ENV_)
 
 // Tests that Int32FromGTestEnv() returns the default value when the
 // environment variable overflows as an Int32.
@@ -1762,7 +1740,7 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
   EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
 }
 
-# endif  // !defined(GTEST_GET_INT32_FROM_ENV_)
+#endif  // !defined(GTEST_GET_INT32_FROM_ENV_)
 
 // Tests that Int32FromGTestEnv() parses and returns the value of the
 // environment variable when it represents a valid decimal integer in
@@ -1776,29 +1754,29 @@ TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
 }
 #endif  // !GTEST_OS_WINDOWS_MOBILE
 
-// Tests ParseInt32Flag().
+// Tests ParseFlag().
 
 // Tests that ParseInt32Flag() returns false and doesn't change the
 // output value when the flag has wrong format
 TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
   int32_t value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
+  EXPECT_FALSE(ParseFlag("--a=100", "b", &value));
   EXPECT_EQ(123, value);
 
-  EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
+  EXPECT_FALSE(ParseFlag("a=100", "a", &value));
   EXPECT_EQ(123, value);
 }
 
-// Tests that ParseInt32Flag() returns false and doesn't change the
+// Tests that ParseFlag() returns false and doesn't change the
 // output value when the flag overflows as an Int32.
 TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
   printf("(expecting 2 warnings)\n");
 
   int32_t value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
+  EXPECT_FALSE(ParseFlag("--abc=12345678987654321", "abc", &value));
   EXPECT_EQ(123, value);
 
-  EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
+  EXPECT_FALSE(ParseFlag("--abc=-12345678987654321", "abc", &value));
   EXPECT_EQ(123, value);
 }
 
@@ -1809,10 +1787,10 @@ TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
   printf("(expecting 2 warnings)\n");
 
   int32_t value = 123;
-  EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
+  EXPECT_FALSE(ParseFlag("--abc=A1", "abc", &value));
   EXPECT_EQ(123, value);
 
-  EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
+  EXPECT_FALSE(ParseFlag("--abc=12X", "abc", &value));
   EXPECT_EQ(123, value);
 }
 
@@ -1821,11 +1799,10 @@ TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
 // the range of an Int32.
 TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
   int32_t value = 123;
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
+  EXPECT_TRUE(ParseFlag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
   EXPECT_EQ(456, value);
 
-  EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
-                             "abc", &value));
+  EXPECT_TRUE(ParseFlag("--" GTEST_FLAG_PREFIX_ "abc=-789", "abc", &value));
   EXPECT_EQ(-789, value);
 }
 
@@ -1847,8 +1824,7 @@ TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
 TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
   EXPECT_DEATH_IF_SUPPORTED(
-      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
-      ".*");
+      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), ".*");
 }
 
 // Tests that Int32FromEnvOrDie() aborts with an error message
@@ -1856,8 +1832,7 @@ TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
 TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
   SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
   EXPECT_DEATH_IF_SUPPORTED(
-      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
-      ".*");
+      Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), ".*");
 }
 
 // Tests that ShouldRunTestOnShard() selects all tests
@@ -1964,7 +1939,8 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
           prev_selected_shard_index = shard_index;
         } else {
           ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
-            << shard_index << " are both selected to run test " << test_id;
+                        << shard_index << " are both selected to run test "
+                        << test_id;
         }
       }
     }
@@ -1976,7 +1952,7 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
     int num_tests_on_shard = 0;
     for (int test_id = 0; test_id < num_tests; test_id++) {
       num_tests_on_shard +=
-        ShouldRunTestOnShard(num_shards, shard_index, test_id);
+          ShouldRunTestOnShard(num_shards, shard_index, test_id);
     }
     EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
   }
@@ -2008,8 +1984,8 @@ TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
 void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
     const TestResult& test_result, const char* key) {
   EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key");
-  ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key
-                                                  << "' recorded unexpectedly.";
+  ASSERT_EQ(0, test_result.test_property_count())
+      << "Property for key '" << key << "' recorded unexpectedly.";
 }
 
 void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
@@ -2036,10 +2012,10 @@ void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite(
 }
 
 // Tests that property recording functions in UnitTest outside of tests
-// functions correcly.  Creating a separate instance of UnitTest ensures it
+// functions correctly.  Creating a separate instance of UnitTest ensures it
 // is in a state similar to the UnitTest's singleton's between tests.
-class UnitTestRecordPropertyTest :
-    public testing::internal::UnitTestRecordPropertyTestHelper {
+class UnitTestRecordPropertyTest
+    : public testing::internal::UnitTestRecordPropertyTestHelper {
  public:
   static void SetUpTestSuite() {
     ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite(
@@ -2078,8 +2054,7 @@ TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
 
   EXPECT_STREQ("key_1",
                unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
-  EXPECT_STREQ("1",
-               unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
+  EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
 }
 
 // Tests TestResult has multiple properties when added.
@@ -2120,16 +2095,13 @@ TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
 
 TEST_F(UnitTestRecordPropertyTest,
        AddFailureInsideTestsWhenUsingTestSuiteReservedKeys) {
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "name");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("name");
   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
       "value_param");
   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
       "type_param");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "status");
-  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
-      "time");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("status");
+  ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("time");
   ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
       "classname");
 }
@@ -2177,9 +2149,7 @@ static Environment* record_property_env GTEST_ATTRIBUTE_UNUSED_ =
 // First, some predicates and predicate-formatters needed by the tests.
 
 // Returns true if and only if the argument is an even number.
-bool IsEven(int n) {
-  return (n % 2) == 0;
-}
+bool IsEven(int n) { return (n % 2) == 0; }
 
 // A functor that returns true if and only if the argument is an even number.
 struct IsEvenFunctor {
@@ -2226,41 +2196,37 @@ struct AssertIsEvenFunctor {
 };
 
 // Returns true if and only if the sum of the arguments is an even number.
-bool SumIsEven2(int n1, int n2) {
-  return IsEven(n1 + n2);
-}
+bool SumIsEven2(int n1, int n2) { return IsEven(n1 + n2); }
 
 // A functor that returns true if and only if the sum of the arguments is an
 // even number.
 struct SumIsEven3Functor {
-  bool operator()(int n1, int n2, int n3) {
-    return IsEven(n1 + n2 + n3);
-  }
+  bool operator()(int n1, int n2, int n3) { return IsEven(n1 + n2 + n3); }
 };
 
 // A predicate-formatter function that asserts the sum of the
 // arguments is an even number.
-AssertionResult AssertSumIsEven4(
-    const char* e1, const char* e2, const char* e3, const char* e4,
-    int n1, int n2, int n3, int n4) {
+AssertionResult AssertSumIsEven4(const char* e1, const char* e2, const char* e3,
+                                 const char* e4, int n1, int n2, int n3,
+                                 int n4) {
   const int sum = n1 + n2 + n3 + n4;
   if (IsEven(sum)) {
     return AssertionSuccess();
   }
 
   Message msg;
-  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
-      << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
-      << ") evaluates to " << sum << ", which is not even.";
+  msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " (" << n1 << " + "
+      << n2 << " + " << n3 << " + " << n4 << ") evaluates to " << sum
+      << ", which is not even.";
   return AssertionFailure(msg);
 }
 
 // A predicate-formatter functor that asserts the sum of the arguments
 // is an even number.
 struct AssertSumIsEven5Functor {
-  AssertionResult operator()(
-      const char* e1, const char* e2, const char* e3, const char* e4,
-      const char* e5, int n1, int n2, int n3, int n4, int n5) {
+  AssertionResult operator()(const char* e1, const char* e2, const char* e3,
+                             const char* e4, const char* e5, int n1, int n2,
+                             int n3, int n4, int n5) {
     const int sum = n1 + n2 + n3 + n4 + n5;
     if (IsEven(sum)) {
       return AssertionSuccess();
@@ -2268,14 +2234,12 @@ struct AssertSumIsEven5Functor {
 
     Message msg;
     msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
-        << " ("
-        << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
-        << ") evaluates to " << sum << ", which is not even.";
+        << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + "
+        << n5 << ") evaluates to " << sum << ", which is not even.";
     return AssertionFailure(msg);
   }
 };
 
-
 // Tests unary predicate assertions.
 
 // Tests unary predicate assertions that don't use a custom formatter.
@@ -2285,11 +2249,12 @@ TEST(Pred1Test, WithoutFormat) {
   ASSERT_PRED1(IsEven, 4);
 
   // Failure cases.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
-                       "evaluates to false");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
+      },
+      "This failure is expected.");
+  EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), "evaluates to false");
 }
 
 // Tests unary predicate assertions that use a custom formatter.
@@ -2297,15 +2262,17 @@ TEST(Pred1Test, WithFormat) {
   // Success cases.
   EXPECT_PRED_FORMAT1(AssertIsEven, 2);
   ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
-    << "This failure is UNEXPECTED!";
+      << "This failure is UNEXPECTED!";
 
   // Failure cases.
   const int n = 5;
   EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
                           "n evaluates to 5, which is not even.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
-  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
+      },
+      "This failure is expected.");
 }
 
 // Tests that unary predicate assertions evaluates their arguments
@@ -2317,14 +2284,15 @@ TEST(Pred1Test, SingleEvaluationOnFailure) {
   EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
 
   // A failure case.
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
-        << "This failure is expected.";
-  }, "This failure is expected.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
+            << "This failure is expected.";
+      },
+      "This failure is expected.");
   EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
 }
 
-
 // Tests predicate assertions whose arity is >= 2.
 
 // Tests predicate assertions that don't use a custom formatter.
@@ -2336,19 +2304,23 @@ TEST(PredTest, WithoutFormat) {
   // Failure cases.
   const int n1 = 1;
   const int n2 = 2;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
-  }, "evaluates to false");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
+      },
+      "This failure is expected.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
+      },
+      "evaluates to false");
 }
 
 // Tests predicate assertions that use a custom formatter.
 TEST(PredTest, WithFormat) {
   // Success cases.
-  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
-    "This failure is UNEXPECTED!";
+  ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10)
+      << "This failure is UNEXPECTED!";
   EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
 
   // Failure cases.
@@ -2356,13 +2328,17 @@ TEST(PredTest, WithFormat) {
   const int n2 = 2;
   const int n3 = 4;
   const int n4 = 6;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
-  }, "evaluates to 13, which is not even.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
-        << "This failure is expected.";
-  }, "This failure is expected.");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
+      },
+      "evaluates to 13, which is not even.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
+            << "This failure is expected.";
+      },
+      "This failure is expected.");
 }
 
 // Tests that predicate assertions evaluates their arguments
@@ -2380,9 +2356,8 @@ TEST(PredTest, SingleEvaluationOnFailure) {
   int n3 = 0;
   int n4 = 0;
   int n5 = 0;
-  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
-                      n1++, n2++, n3++, n4++, n5++)
-                        << "This failure is UNEXPECTED!";
+  ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), n1++, n2++, n3++, n4++, n5++)
+      << "This failure is UNEXPECTED!";
   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
@@ -2391,19 +2366,23 @@ TEST(PredTest, SingleEvaluationOnFailure) {
 
   // A failure case.
   n1 = n2 = n3 = 0;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
-        << "This failure is expected.";
-  }, "This failure is expected.");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
+            << "This failure is expected.";
+      },
+      "This failure is expected.");
   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
 
   // Another failure case.
   n1 = n2 = n3 = n4 = 0;
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
-  }, "evaluates to 1, which is not even.");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
+      },
+      "evaluates to 1, which is not even.");
   EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
   EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
   EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
@@ -2414,7 +2393,7 @@ TEST(PredTest, SingleEvaluationOnFailure) {
 TEST(PredTest, ExpectPredEvalFailure) {
   std::set<int> set_a = {2, 1, 3, 4, 5};
   std::set<int> set_b = {0, 4, 8};
-  const auto compare_sets = [] (std::set<int>, std::set<int>) { return false; };
+  const auto compare_sets = [](std::set<int>, std::set<int>) { return false; };
   EXPECT_NONFATAL_FAILURE(
       EXPECT_PRED2(compare_sets, set_a, set_b),
       "compare_sets(set_a, set_b) evaluates to false, where\nset_a evaluates "
@@ -2424,9 +2403,7 @@ TEST(PredTest, ExpectPredEvalFailure) {
 // Some helper functions for testing using overloaded/template
 // functions with ASSERT_PREDn and EXPECT_PREDn.
 
-bool IsPositive(double x) {
-  return x > 0;
-}
+bool IsPositive(double x) { return x > 0; }
 
 template <typename T>
 bool IsNegative(T x) {
@@ -2442,7 +2419,7 @@ bool GreaterThan(T1 x1, T2 x2) {
 // their types are explicitly specified.
 TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
   // C++Builder requires C-style casts rather than static_cast.
-  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);  // NOLINT
+  EXPECT_PRED1((bool (*)(int))(IsPositive), 5);       // NOLINT
   ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0);  // NOLINT
 }
 
@@ -2455,31 +2432,27 @@ TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
   ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
 }
 
-
 // Some helper functions for testing using overloaded/template
 // functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
 
 AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
-  return n > 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
+  return n > 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
 }
 
 AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
-  return x > 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
+  return x > 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
 }
 
 template <typename T>
 AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
-  return x < 0 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
+  return x < 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
 }
 
 template <typename T1, typename T2>
 AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
                              const T1& x1, const T2& x2) {
-  return x1 == x2 ? AssertionSuccess() :
-      AssertionFailure(Message() << "Failure");
+  return x1 == x2 ? AssertionSuccess()
+                  : AssertionFailure(Message() << "Failure");
 }
 
 // Tests that overloaded functions can be used in *_PRED_FORMAT*
@@ -2496,20 +2469,18 @@ TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
   ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
 }
 
-
 // Tests string assertions.
 
 // Tests ASSERT_STREQ with non-NULL arguments.
 TEST(StringAssertionTest, ASSERT_STREQ) {
-  const char * const p1 = "good";
+  const char* const p1 = "good";
   ASSERT_STREQ(p1, p1);
 
   // Let p2 have the same content as p1, but be at a different address.
   const char p2[] = "good";
   ASSERT_STREQ(p1, p2);
 
-  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
-                       "  \"bad\"\n  \"good\"");
+  EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), "  \"bad\"\n  \"good\"");
 }
 
 // Tests ASSERT_STREQ with NULL arguments.
@@ -2532,8 +2503,7 @@ TEST(StringAssertionTest, ASSERT_STRNE) {
   ASSERT_STRNE(nullptr, "");
   ASSERT_STRNE("", "Hi");
   ASSERT_STRNE("Hi", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
-                       "\"Hi\" vs \"Hi\"");
+  EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), "\"Hi\" vs \"Hi\"");
 }
 
 // Tests ASSERT_STRCASEEQ.
@@ -2542,8 +2512,7 @@ TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
   ASSERT_STRCASEEQ(static_cast<const char*>(nullptr), nullptr);
 
   ASSERT_STRCASEEQ("", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
-                       "Ignoring case");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), "Ignoring case");
 }
 
 // Tests ASSERT_STRCASENE.
@@ -2555,8 +2524,7 @@ TEST(StringAssertionTest, ASSERT_STRCASENE) {
   ASSERT_STRCASENE(nullptr, "");
   ASSERT_STRCASENE("", "Hi");
   ASSERT_STRCASENE("Hi", "");
-  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
-                       "(ignoring case)");
+  EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), "(ignoring case)");
 }
 
 // Tests *_STREQ on wide strings.
@@ -2574,17 +2542,17 @@ TEST(StringAssertionTest, STREQ_Wide) {
   EXPECT_STREQ(L"Hi", L"Hi");
 
   // Unequal strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
-                          "Abc");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), "Abc");
 
   // Strings containing wide characters.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
-                          "abc");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), "abc");
 
   // The streaming variation.
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
-  }, "Expected failure");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
+      },
+      "Expected failure");
 }
 
 // Tests *_STRNE on wide strings.
@@ -2597,22 +2565,19 @@ TEST(StringAssertionTest, STRNE_Wide) {
       "");
 
   // Empty strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
-                          "L\"\"");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), "L\"\"");
 
   // Non-null vs NULL.
   ASSERT_STRNE(L"non-null", nullptr);
 
   // Equal strings.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
-                          "L\"Hi\"");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), "L\"Hi\"");
 
   // Unequal strings.
   EXPECT_STRNE(L"abc", L"Abc");
 
   // Strings containing wide characters.
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
-                          "abc");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), "abc");
 
   // The streaming variation.
   ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
@@ -2646,12 +2611,13 @@ TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
 // Tests that IsSubstring() generates the correct message when the input
 // argument type is const char*.
 TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: \"needle\"\n"
-               "Expected: a substring of haystack_expr\n"
-               "Which is: \"haystack\"",
-               IsSubstring("needle_expr", "haystack_expr",
-                           "needle", "haystack").failure_message());
+  EXPECT_STREQ(
+      "Value of: needle_expr\n"
+      "  Actual: \"needle\"\n"
+      "Expected: a substring of haystack_expr\n"
+      "Which is: \"haystack\"",
+      IsSubstring("needle_expr", "haystack_expr", "needle", "haystack")
+          .failure_message());
 }
 
 // Tests that IsSubstring returns the correct result when the input
@@ -2672,13 +2638,14 @@ TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
 // Tests that IsSubstring() generates the correct message when the input
 // argument type is ::std::wstring.
 TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: L\"needle\"\n"
-               "Expected: a substring of haystack_expr\n"
-               "Which is: L\"haystack\"",
-               IsSubstring(
-                   "needle_expr", "haystack_expr",
-                   ::std::wstring(L"needle"), L"haystack").failure_message());
+  EXPECT_STREQ(
+      "Value of: needle_expr\n"
+      "  Actual: L\"needle\"\n"
+      "Expected: a substring of haystack_expr\n"
+      "Which is: L\"haystack\"",
+      IsSubstring("needle_expr", "haystack_expr", ::std::wstring(L"needle"),
+                  L"haystack")
+          .failure_message());
 }
 
 #endif  // GTEST_HAS_STD_WSTRING
@@ -2702,13 +2669,13 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
 // Tests that IsNotSubstring() generates the correct message when the input
 // argument type is const wchar_t*.
 TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: L\"needle\"\n"
-               "Expected: not a substring of haystack_expr\n"
-               "Which is: L\"two needles\"",
-               IsNotSubstring(
-                   "needle_expr", "haystack_expr",
-                   L"needle", L"two needles").failure_message());
+  EXPECT_STREQ(
+      "Value of: needle_expr\n"
+      "  Actual: L\"needle\"\n"
+      "Expected: not a substring of haystack_expr\n"
+      "Which is: L\"two needles\"",
+      IsNotSubstring("needle_expr", "haystack_expr", L"needle", L"two needles")
+          .failure_message());
 }
 
 // Tests that IsNotSubstring returns the correct result when the input
@@ -2721,13 +2688,14 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
 // Tests that IsNotSubstring() generates the correct message when the input
 // argument type is ::std::string.
 TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
-  EXPECT_STREQ("Value of: needle_expr\n"
-               "  Actual: \"needle\"\n"
-               "Expected: not a substring of haystack_expr\n"
-               "Which is: \"two needles\"",
-               IsNotSubstring(
-                   "needle_expr", "haystack_expr",
-                   ::std::string("needle"), "two needles").failure_message());
+  EXPECT_STREQ(
+      "Value of: needle_expr\n"
+      "  Actual: \"needle\"\n"
+      "Expected: not a substring of haystack_expr\n"
+      "Which is: \"two needles\"",
+      IsNotSubstring("needle_expr", "haystack_expr", ::std::string("needle"),
+                     "two needles")
+          .failure_message());
 }
 
 #if GTEST_HAS_STD_WSTRING
@@ -2774,20 +2742,20 @@ class FloatingPointTest : public Test {
     const Bits zero_bits = Floating(0).bits();
 
     // Makes some numbers close to 0.0.
-    values_.close_to_positive_zero = Floating::ReinterpretBits(
-        zero_bits + max_ulps/2);
-    values_.close_to_negative_zero = -Floating::ReinterpretBits(
-        zero_bits + max_ulps - max_ulps/2);
-    values_.further_from_negative_zero = -Floating::ReinterpretBits(
-        zero_bits + max_ulps + 1 - max_ulps/2);
+    values_.close_to_positive_zero =
+        Floating::ReinterpretBits(zero_bits + max_ulps / 2);
+    values_.close_to_negative_zero =
+        -Floating::ReinterpretBits(zero_bits + max_ulps - max_ulps / 2);
+    values_.further_from_negative_zero =
+        -Floating::ReinterpretBits(zero_bits + max_ulps + 1 - max_ulps / 2);
 
     // The bits that represent 1.0.
     const Bits one_bits = Floating(1).bits();
 
     // Makes some numbers close to 1.0.
     values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
-    values_.further_from_one = Floating::ReinterpretBits(
-        one_bits + max_ulps + 1);
+    values_.further_from_one =
+        Floating::ReinterpretBits(one_bits + max_ulps + 1);
 
     // +infinity.
     values_.infinity = Floating::Infinity();
@@ -2796,23 +2764,23 @@ class FloatingPointTest : public Test {
     const Bits infinity_bits = Floating(values_.infinity).bits();
 
     // Makes some numbers close to infinity.
-    values_.close_to_infinity = Floating::ReinterpretBits(
-        infinity_bits - max_ulps);
-    values_.further_from_infinity = Floating::ReinterpretBits(
-        infinity_bits - max_ulps - 1);
+    values_.close_to_infinity =
+        Floating::ReinterpretBits(infinity_bits - max_ulps);
+    values_.further_from_infinity =
+        Floating::ReinterpretBits(infinity_bits - max_ulps - 1);
 
     // Makes some NAN's.  Sets the most significant bit of the fraction so that
     // our NaN's are quiet; trying to process a signaling NaN would raise an
     // exception if our environment enables floating point exceptions.
-    values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
-    values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
-        | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
+    values_.nan1 = Floating::ReinterpretBits(
+        Floating::kExponentBitMask |
+        (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
+    values_.nan2 = Floating::ReinterpretBits(
+        Floating::kExponentBitMask |
+        (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
   }
 
-  void TestSize() {
-    EXPECT_EQ(sizeof(RawType), sizeof(Bits));
-  }
+  void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
 
   static TestValues values_;
 };
@@ -2825,17 +2793,13 @@ typename FloatingPointTest<RawType>::TestValues
 typedef FloatingPointTest<float> FloatTest;
 
 // Tests that the size of Float::Bits matches the size of float.
-TEST_F(FloatTest, Size) {
-  TestSize();
-}
+TEST_F(FloatTest, Size) { TestSize(); }
 
 // Tests comparing with +0 and -0.
 TEST_F(FloatTest, Zeros) {
   EXPECT_FLOAT_EQ(0.0, -0.0);
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
-                          "1.0");
-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
-                       "1.5");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), "1.5");
 }
 
 // Tests comparing numbers close to 0.
@@ -2856,10 +2820,11 @@ TEST_F(FloatTest, AlmostZeros) {
   EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
   EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
 
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_FLOAT_EQ(v.close_to_positive_zero,
-                    v.further_from_negative_zero);
-  }, "v.further_from_negative_zero");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_FLOAT_EQ(v.close_to_positive_zero, v.further_from_negative_zero);
+      },
+      "v.further_from_negative_zero");
 }
 
 // Tests comparing numbers close to each other.
@@ -2871,8 +2836,7 @@ TEST_F(FloatTest, SmallDiff) {
 
 // Tests comparing numbers far apart.
 TEST_F(FloatTest, LargeDiff) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
-                          "3.0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), "3.0");
 }
 
 // Tests comparing with infinity.
@@ -2901,15 +2865,11 @@ TEST_F(FloatTest, NaN) {
   // (parentheses).
   static const FloatTest::TestValues& v = this->values_;
 
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
-                          "v.nan1");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
-                          "v.nan2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
-                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), "v.nan2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), "v.nan1");
 
-  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
-                       "v.infinity");
+  EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), "v.infinity");
 }
 
 // Tests that *_FLOAT_EQ are reflexive.
@@ -2963,36 +2923,40 @@ TEST_F(FloatTest, FloatLEFails) {
                           "(2.0f) <= (1.0f)");
 
   // or by a small yet non-negligible margin,
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
-  }, "(values_.further_from_one) <= (1.0f)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
+      },
+      "(values_.further_from_one) <= (1.0f)");
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
-  }, "(values_.nan1) <= (values_.infinity)");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
-  }, "(-values_.infinity) <= (values_.nan1)");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
-  }, "(values_.nan1) <= (values_.nan1)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
+      },
+      "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
+      },
+      "(-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
+      },
+      "(values_.nan1) <= (values_.nan1)");
 }
 
 // Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
 typedef FloatingPointTest<double> DoubleTest;
 
 // Tests that the size of Double::Bits matches the size of double.
-TEST_F(DoubleTest, Size) {
-  TestSize();
-}
+TEST_F(DoubleTest, Size) { TestSize(); }
 
 // Tests comparing with +0 and -0.
 TEST_F(DoubleTest, Zeros) {
   EXPECT_DOUBLE_EQ(0.0, -0.0);
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
-                          "1.0");
-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
-                       "1.0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), "1.0");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), "1.0");
 }
 
 // Tests comparing numbers close to 0.
@@ -3013,10 +2977,12 @@ TEST_F(DoubleTest, AlmostZeros) {
   EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
   EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
 
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
-                     v.further_from_negative_zero);
-  }, "v.further_from_negative_zero");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
+                         v.further_from_negative_zero);
+      },
+      "v.further_from_negative_zero");
 }
 
 // Tests comparing numbers close to each other.
@@ -3028,8 +2994,7 @@ TEST_F(DoubleTest, SmallDiff) {
 
 // Tests comparing numbers far apart.
 TEST_F(DoubleTest, LargeDiff) {
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
-                          "3.0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), "3.0");
 }
 
 // Tests comparing with infinity.
@@ -3053,12 +3018,10 @@ TEST_F(DoubleTest, NaN) {
   static const DoubleTest::TestValues& v = this->values_;
 
   // Nokia's STLport crashes if we try to output infinity or NaN.
-  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
-                          "v.nan1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), "v.nan1");
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
   EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
-  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
-                       "v.infinity");
+  EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), "v.infinity");
 }
 
 // Tests that *_DOUBLE_EQ are reflexive.
@@ -3119,22 +3082,29 @@ TEST_F(DoubleTest, DoubleLEFails) {
                           "(2.0) <= (1.0)");
 
   // or by a small yet non-negligible margin,
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
-  }, "(values_.further_from_one) <= (1.0)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
+      },
+      "(values_.further_from_one) <= (1.0)");
 
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
-  }, "(values_.nan1) <= (values_.infinity)");
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
-  }, " (-values_.infinity) <= (values_.nan1)");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
-  }, "(values_.nan1) <= (values_.nan1)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
+      },
+      "(values_.nan1) <= (values_.infinity)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
+      },
+      " (-values_.infinity) <= (values_.nan1)");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
+      },
+      "(values_.nan1) <= (values_.nan1)");
 }
 
-
 // Verifies that a test or test case whose name starts with DISABLED_ is
 // not run.
 
@@ -3146,9 +3116,7 @@ TEST(DisabledTest, DISABLED_TestShouldNotRun) {
 
 // A test whose name does not start with DISABLED_.
 // Should run.
-TEST(DisabledTest, NotDISABLED_TestShouldRun) {
-  EXPECT_EQ(1, 1);
-}
+TEST(DisabledTest, NotDISABLED_TestShouldRun) { EXPECT_EQ(1, 1); }
 
 // A test case whose name starts with DISABLED_.
 // Should not run.
@@ -3188,8 +3156,7 @@ TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
 // Tests that disabled typed tests aren't run.
 
 template <typename T>
-class TypedTest : public Test {
-};
+class TypedTest : public Test {};
 
 typedef testing::Types<int, double> NumericTypes;
 TYPED_TEST_SUITE(TypedTest, NumericTypes);
@@ -3199,8 +3166,7 @@ TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
 }
 
 template <typename T>
-class DISABLED_TypedTest : public Test {
-};
+class DISABLED_TypedTest : public Test {};
 
 TYPED_TEST_SUITE(DISABLED_TypedTest, NumericTypes);
 
@@ -3211,8 +3177,7 @@ TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
 // Tests that disabled type-parameterized tests aren't run.
 
 template <typename T>
-class TypedTestP : public Test {
-};
+class TypedTestP : public Test {};
 
 TYPED_TEST_SUITE_P(TypedTestP);
 
@@ -3226,8 +3191,7 @@ REGISTER_TYPED_TEST_SUITE_P(TypedTestP, DISABLED_ShouldNotRun);
 INSTANTIATE_TYPED_TEST_SUITE_P(My, TypedTestP, NumericTypes);
 
 template <typename T>
-class DISABLED_TypedTestP : public Test {
-};
+class DISABLED_TypedTestP : public Test {};
 
 TYPED_TEST_SUITE_P(DISABLED_TypedTestP);
 
@@ -3247,15 +3211,11 @@ class SingleEvaluationTest : public Test {
   // This helper function is needed by the FailedASSERT_STREQ test
   // below.  It's public to work around C++Builder's bug with scoping local
   // classes.
-  static void CompareAndIncrementCharPtrs() {
-    ASSERT_STREQ(p1_++, p2_++);
-  }
+  static void CompareAndIncrementCharPtrs() { ASSERT_STREQ(p1_++, p2_++); }
 
   // This helper function is needed by the FailedASSERT_NE test below.  It's
   // public to work around C++Builder's bug with scoping local classes.
-  static void CompareAndIncrementInts() {
-    ASSERT_NE(a_++, b_++);
-  }
+  static void CompareAndIncrementInts() { ASSERT_NE(a_++, b_++); }
 
  protected:
   SingleEvaluationTest() {
@@ -3298,8 +3258,7 @@ TEST_F(SingleEvaluationTest, ASSERT_STR) {
   EXPECT_EQ(s2_ + 1, p2_);
 
   // failed EXPECT_STRCASEEQ
-  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
-                          "Ignoring case");
+  EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), "Ignoring case");
   EXPECT_EQ(s1_ + 2, p1_);
   EXPECT_EQ(s2_ + 2, p2_);
 }
@@ -3359,34 +3318,39 @@ TEST_F(SingleEvaluationTest, OtherCases) {
 
 #endif  // GTEST_HAS_RTTI
 
-void ThrowAnInteger() {
-  throw 1;
-}
-void ThrowRuntimeError(const char* what) {
-  throw std::runtime_error(what);
-}
+void ThrowAnInteger() { throw 1; }
+void ThrowRuntimeError(const char* what) { throw std::runtime_error(what); }
 
 // Tests that assertion arguments are evaluated exactly once.
 TEST_F(SingleEvaluationTest, ExceptionTests) {
   // successful EXPECT_THROW
-  EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }, int);
+  EXPECT_THROW(
+      {  // NOLINT
+        a_++;
+        ThrowAnInteger();
+      },
+      int);
   EXPECT_EQ(1, a_);
 
   // failed EXPECT_THROW, throws different
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }, bool), "throws a different type");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
+                              {  // NOLINT
+                                a_++;
+                                ThrowAnInteger();
+                              },
+                              bool),
+                          "throws a different type");
   EXPECT_EQ(2, a_);
 
   // failed EXPECT_THROW, throws runtime error
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowRuntimeError("A description");
-  }, bool), "throws " ERROR_DESC " with description \"A description\"");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
+                              {  // NOLINT
+                                a_++;
+                                ThrowRuntimeError("A description");
+                              },
+                              bool),
+                          "throws " ERROR_DESC
+                          " with description \"A description\"");
   EXPECT_EQ(3, a_);
 
   // failed EXPECT_THROW, throws nothing
@@ -3399,9 +3363,10 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
 
   // failed EXPECT_NO_THROW
   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }), "it throws");
+                            a_++;
+                            ThrowAnInteger();
+                          }),
+                          "it throws");
   EXPECT_EQ(6, a_);
 
   // successful EXPECT_ANY_THROW
@@ -3422,12 +3387,8 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
 class NoFatalFailureTest : public Test {
  protected:
   void Succeeds() {}
-  void FailsNonFatal() {
-    ADD_FAILURE() << "some non-fatal failure";
-  }
-  void Fails() {
-    FAIL() << "some fatal failure";
-  }
+  void FailsNonFatal() { ADD_FAILURE() << "some non-fatal failure"; }
+  void Fails() { FAIL() << "some fatal failure"; }
 
   void DoAssertNoFatalFailureOnFails() {
     ASSERT_NO_FATAL_FAILURE(Fails());
@@ -3446,12 +3407,10 @@ TEST_F(NoFatalFailureTest, NoFailure) {
 }
 
 TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
-      "some non-fatal failure");
-  EXPECT_NONFATAL_FAILURE(
-      ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
-      "some non-fatal failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
+                          "some non-fatal failure");
+  EXPECT_NONFATAL_FAILURE(ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
+                          "some non-fatal failure");
 }
 
 TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
@@ -3496,10 +3455,10 @@ TEST_F(NoFatalFailureTest, MessageIsStreamable) {
   TestPartResultArray gtest_failures;
   {
     ScopedFakeTestPartResultReporter gtest_reporter(&gtest_failures);
-    EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
+    EXPECT_NO_FATAL_FAILURE([] { FAIL() << "foo"; }()) << "my message";
   }
   ASSERT_EQ(2, gtest_failures.size());
-  EXPECT_EQ(TestPartResult::kNonFatalFailure,
+  EXPECT_EQ(TestPartResult::kFatalFailure,
             gtest_failures.GetTestPartResult(0).type());
   EXPECT_EQ(TestPartResult::kNonFatalFailure,
             gtest_failures.GetTestPartResult(1).type());
@@ -3574,8 +3533,9 @@ TEST(EditDistance, TestSuites) {
                 EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
                                                     CharsToIndices(c->right))))
         << "Left <" << c->left << "> Right <" << c->right << "> Edits <"
-        << EditsToString(CalculateOptimalEdits(
-               CharsToIndices(c->left), CharsToIndices(c->right))) << ">";
+        << EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
+                                               CharsToIndices(c->right)))
+        << ">";
     EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left),
                                                       CharsToLines(c->right)))
         << "Left <" << c->left << "> Right <" << c->right << "> Diff <"
@@ -3588,8 +3548,7 @@ TEST(EditDistance, TestSuites) {
 TEST(AssertionTest, EqFailure) {
   const std::string foo_val("5"), bar_val("6");
   const std::string msg1(
-      EqFailure("foo", "bar", foo_val, bar_val, false)
-      .failure_message());
+      EqFailure("foo", "bar", foo_val, bar_val, false).failure_message());
   EXPECT_STREQ(
       "Expected equality of these values:\n"
       "  foo\n"
@@ -3599,8 +3558,7 @@ TEST(AssertionTest, EqFailure) {
       msg1.c_str());
 
   const std::string msg2(
-      EqFailure("foo", "6", foo_val, bar_val, false)
-      .failure_message());
+      EqFailure("foo", "6", foo_val, bar_val, false).failure_message());
   EXPECT_STREQ(
       "Expected equality of these values:\n"
       "  foo\n"
@@ -3609,8 +3567,7 @@ TEST(AssertionTest, EqFailure) {
       msg2.c_str());
 
   const std::string msg3(
-      EqFailure("5", "bar", foo_val, bar_val, false)
-      .failure_message());
+      EqFailure("5", "bar", foo_val, bar_val, false).failure_message());
   EXPECT_STREQ(
       "Expected equality of these values:\n"
       "  5\n"
@@ -3627,9 +3584,8 @@ TEST(AssertionTest, EqFailure) {
       msg4.c_str());
 
   const std::string msg5(
-      EqFailure("foo", "bar",
-                std::string("\"x\""), std::string("\"y\""),
-                true).failure_message());
+      EqFailure("foo", "bar", std::string("\"x\""), std::string("\"y\""), true)
+          .failure_message());
   EXPECT_STREQ(
       "Expected equality of these values:\n"
       "  foo\n"
@@ -3664,24 +3620,21 @@ TEST(AssertionTest, AppendUserMessage) {
   const std::string foo("foo");
 
   Message msg;
-  EXPECT_STREQ("foo",
-               AppendUserMessage(foo, msg).c_str());
+  EXPECT_STREQ("foo", AppendUserMessage(foo, msg).c_str());
 
   msg << "bar";
-  EXPECT_STREQ("foo\nbar",
-               AppendUserMessage(foo, msg).c_str());
+  EXPECT_STREQ("foo\nbar", AppendUserMessage(foo, msg).c_str());
 }
 
 #ifdef __BORLANDC__
 // Silences warnings: "Condition is always true", "Unreachable code"
-# pragma option push -w-ccc -w-rch
+#pragma option push -w-ccc -w-rch
 #endif
 
 // Tests ASSERT_TRUE.
 TEST(AssertionTest, ASSERT_TRUE) {
   ASSERT_TRUE(2 > 1);  // NOLINT
-  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
-                       "2 < 1");
+  EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), "2 < 1");
 }
 
 // Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
@@ -3729,7 +3682,7 @@ TEST(AssertionTest, AssertFalseWithAssertionResult) {
 
 #ifdef __BORLANDC__
 // Restores warnings after previous "#pragma option push" suppressed them
-# pragma option pop
+#pragma option pop
 #endif
 
 // Tests using ASSERT_EQ on double values.  The purpose is to make
@@ -3740,18 +3693,19 @@ TEST(ExpectTest, ASSERT_EQ_Double) {
   ASSERT_EQ(5.6, 5.6);
 
   // A failure.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
-                       "5.1");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), "5.1");
 }
 
 // Tests ASSERT_EQ.
 TEST(AssertionTest, ASSERT_EQ) {
   ASSERT_EQ(5, 2 + 3);
+  // clang-format off
   EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
                        "Expected equality of these values:\n"
                        "  5\n"
                        "  2*3\n"
                        "    Which is: 6");
+  // clang-format on
 }
 
 // Tests ASSERT_EQ(NULL, pointer).
@@ -3776,8 +3730,7 @@ TEST(ExpectTest, ASSERT_EQ_0) {
   ASSERT_EQ(0, n);
 
   // A failure.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
-                       "  0\n  5.6");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), "  0\n  5.6");
 }
 
 // Tests ASSERT_NE.
@@ -3792,30 +3745,26 @@ TEST(AssertionTest, ASSERT_NE) {
 TEST(AssertionTest, ASSERT_LE) {
   ASSERT_LE(2, 3);
   ASSERT_LE(2, 2);
-  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
-                       "Expected: (2) <= (0), actual: 2 vs 0");
+  EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), "Expected: (2) <= (0), actual: 2 vs 0");
 }
 
 // Tests ASSERT_LT.
 TEST(AssertionTest, ASSERT_LT) {
   ASSERT_LT(2, 3);
-  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
-                       "Expected: (2) < (2), actual: 2 vs 2");
+  EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), "Expected: (2) < (2), actual: 2 vs 2");
 }
 
 // Tests ASSERT_GE.
 TEST(AssertionTest, ASSERT_GE) {
   ASSERT_GE(2, 1);
   ASSERT_GE(2, 2);
-  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
-                       "Expected: (2) >= (3), actual: 2 vs 3");
+  EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), "Expected: (2) >= (3), actual: 2 vs 3");
 }
 
 // Tests ASSERT_GT.
 TEST(AssertionTest, ASSERT_GT) {
   ASSERT_GT(2, 1);
-  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
-                       "Expected: (2) > (2), actual: 2 vs 2");
+  EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), "Expected: (2) > (2), actual: 2 vs 2");
 }
 
 #if GTEST_HAS_EXCEPTIONS
@@ -3826,7 +3775,7 @@ void ThrowNothing() {}
 TEST(AssertionTest, ASSERT_THROW) {
   ASSERT_THROW(ThrowAnInteger(), int);
 
-# ifndef __BORLANDC__
+#ifndef __BORLANDC__
 
   // ICE's in C++Builder 2007 and 2009.
   EXPECT_FATAL_FAILURE(
@@ -3837,9 +3786,10 @@ TEST(AssertionTest, ASSERT_THROW) {
       ASSERT_THROW(ThrowRuntimeError("A description"), std::logic_error),
       "Expected: ThrowRuntimeError(\"A description\") "
       "throws an exception of type std::logic_error.\n  "
-      "Actual: it throws " ERROR_DESC " "
+      "Actual: it throws " ERROR_DESC
+      " "
       "with description \"A description\".");
-# endif
+#endif
 
   EXPECT_FATAL_FAILURE(
       ASSERT_THROW(ThrowNothing(), bool),
@@ -3856,17 +3806,17 @@ TEST(AssertionTest, ASSERT_NO_THROW) {
   EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowRuntimeError("A description")),
                        "Expected: ThrowRuntimeError(\"A description\") "
                        "doesn't throw an exception.\n  "
-                       "Actual: it throws " ERROR_DESC " "
+                       "Actual: it throws " ERROR_DESC
+                       " "
                        "with description \"A description\".");
 }
 
 // Tests ASSERT_ANY_THROW.
 TEST(AssertionTest, ASSERT_ANY_THROW) {
   ASSERT_ANY_THROW(ThrowAnInteger());
-  EXPECT_FATAL_FAILURE(
-      ASSERT_ANY_THROW(ThrowNothing()),
-      "Expected: ThrowNothing() throws an exception.\n"
-      "  Actual: it doesn't.");
+  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()),
+                       "Expected: ThrowNothing() throws an exception.\n"
+                       "  Actual: it doesn't.");
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -3880,14 +3830,11 @@ TEST(AssertionTest, AssertPrecedence) {
 }
 
 // A subroutine used by the following test.
-void TestEq1(int x) {
-  ASSERT_EQ(1, x);
-}
+void TestEq1(int x) { ASSERT_EQ(1, x); }
 
 // Tests calling a test subroutine that's not part of a fixture.
 TEST(AssertionTest, NonFixtureSubroutine) {
-  EXPECT_FATAL_FAILURE(TestEq1(2),
-                       "  x\n    Which is: 2");
+  EXPECT_FATAL_FAILURE(TestEq1(2), "  x\n    Which is: 2");
 }
 
 // An uncopyable class.
@@ -3899,6 +3846,7 @@ class Uncopyable {
   bool operator==(const Uncopyable& rhs) const {
     return value() == rhs.value();
   }
+
  private:
   // This constructor deliberately has no implementation, as we don't
   // want this class to be copyable.
@@ -3911,10 +3859,7 @@ class Uncopyable {
   return os << value.value();
 }
 
-
-bool IsPositiveUncopyable(const Uncopyable& x) {
-  return x.value() > 0;
-}
+bool IsPositiveUncopyable(const Uncopyable& x) { return x.value() > 0; }
 
 // A subroutine used by the following test.
 void TestAssertNonPositive() {
@@ -3933,8 +3878,9 @@ TEST(AssertionTest, AssertWorksWithUncopyableObject) {
   Uncopyable x(5);
   ASSERT_PRED1(IsPositiveUncopyable, x);
   ASSERT_EQ(x, x);
-  EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_FATAL_FAILURE(
+      TestAssertNonPositive(),
+      "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
   EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
                        "Expected equality of these values:\n"
                        "  x\n    Which is: 5\n  y\n    Which is: -1");
@@ -3945,18 +3891,16 @@ TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
   Uncopyable x(5);
   EXPECT_PRED1(IsPositiveUncopyable, x);
   Uncopyable y(-1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
-    "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_PRED1(IsPositiveUncopyable, y),
+      "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
   EXPECT_EQ(x, x);
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
                           "Expected equality of these values:\n"
                           "  x\n    Which is: 5\n  y\n    Which is: -1");
 }
 
-enum NamedEnum {
-  kE1 = 0,
-  kE2 = 1
-};
+enum NamedEnum { kE1 = 0, kE2 = 1 };
 
 TEST(AssertionTest, NamedEnum) {
   EXPECT_EQ(kE1, kE1);
@@ -3972,7 +3916,7 @@ TEST(AssertionTest, NamedEnum) {
 enum {
   kCaseA = -1,
 
-# if GTEST_OS_LINUX
+#if GTEST_OS_LINUX
 
   // We want to test the case where the size of the anonymous enum is
   // larger than sizeof(int), to make sure our implementation of the
@@ -3985,21 +3929,21 @@ enum {
   // assertions.
   kCaseB = testing::internal::kMaxBiggestInt,
 
-# else
+#else
 
   kCaseB = INT_MAX,
 
-# endif  // GTEST_OS_LINUX
+#endif  // GTEST_OS_LINUX
 
   kCaseC = 42
 };
 
 TEST(AssertionTest, AnonymousEnum) {
-# if GTEST_OS_LINUX
+#if GTEST_OS_LINUX
 
   EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
 
-# endif  // GTEST_OS_LINUX
+#endif  // GTEST_OS_LINUX
 
   EXPECT_EQ(kCaseA, kCaseA);
   EXPECT_NE(kCaseA, kCaseB);
@@ -4007,10 +3951,8 @@ TEST(AssertionTest, AnonymousEnum) {
   EXPECT_LE(kCaseA, kCaseB);
   EXPECT_GT(kCaseB, kCaseA);
   EXPECT_GE(kCaseA, kCaseA);
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
-                          "(kCaseA) >= (kCaseB)");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
-                          "-1 vs 42");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB), "(kCaseA) >= (kCaseB)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC), "-1 vs 42");
 
   ASSERT_EQ(kCaseA, kCaseA);
   ASSERT_NE(kCaseA, kCaseB);
@@ -4019,34 +3961,25 @@ TEST(AssertionTest, AnonymousEnum) {
   ASSERT_GT(kCaseB, kCaseA);
   ASSERT_GE(kCaseA, kCaseA);
 
-# ifndef __BORLANDC__
+#ifndef __BORLANDC__
 
   // ICE's in C++Builder.
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
-                       "  kCaseB\n    Which is: ");
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
-                       "\n    Which is: 42");
-# endif
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), "  kCaseB\n    Which is: ");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), "\n    Which is: 42");
+#endif
 
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
-                       "\n    Which is: -1");
+  EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), "\n    Which is: -1");
 }
 
 #endif  // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
 
 #if GTEST_OS_WINDOWS
 
-static HRESULT UnexpectedHRESULTFailure() {
-  return E_UNEXPECTED;
-}
+static HRESULT UnexpectedHRESULTFailure() { return E_UNEXPECTED; }
 
-static HRESULT OkHRESULTSuccess() {
-  return S_OK;
-}
+static HRESULT OkHRESULTSuccess() { return S_OK; }
 
-static HRESULT FalseHRESULTSuccess() {
-  return S_FALSE;
-}
+static HRESULT FalseHRESULTSuccess() { return S_FALSE; }
 
 // HRESULT assertion tests test both zero and non-zero
 // success codes as well as failure message for each.
@@ -4057,8 +3990,8 @@ TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
   EXPECT_HRESULT_SUCCEEDED(S_FALSE);
 
   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
-    "  Actual: 0x8000FFFF");
+                          "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+                          "  Actual: 0x8000FFFF");
 }
 
 TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
@@ -4066,35 +3999,35 @@ TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
   ASSERT_HRESULT_SUCCEEDED(S_FALSE);
 
   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
-    "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
-    "  Actual: 0x8000FFFF");
+                       "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
+                       "  Actual: 0x8000FFFF");
 }
 
 TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
   EXPECT_HRESULT_FAILED(E_UNEXPECTED);
 
   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
-    "Expected: (OkHRESULTSuccess()) fails.\n"
-    "  Actual: 0x0");
+                          "Expected: (OkHRESULTSuccess()) fails.\n"
+                          "  Actual: 0x0");
   EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
-    "Expected: (FalseHRESULTSuccess()) fails.\n"
-    "  Actual: 0x1");
+                          "Expected: (FalseHRESULTSuccess()) fails.\n"
+                          "  Actual: 0x1");
 }
 
 TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
   ASSERT_HRESULT_FAILED(E_UNEXPECTED);
 
-# ifndef __BORLANDC__
+#ifndef __BORLANDC__
 
   // ICE's in C++Builder 2007 and 2009.
   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
-    "Expected: (OkHRESULTSuccess()) fails.\n"
-    "  Actual: 0x0");
-# endif
+                       "Expected: (OkHRESULTSuccess()) fails.\n"
+                       "  Actual: 0x0");
+#endif
 
   EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
-    "Expected: (FalseHRESULTSuccess()) fails.\n"
-    "  Actual: 0x1");
+                       "Expected: (FalseHRESULTSuccess()) fails.\n"
+                       "  Actual: 0x1");
 }
 
 // Tests that streaming to the HRESULT macros works.
@@ -4104,25 +4037,23 @@ TEST(HRESULTAssertionTest, Streaming) {
   EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
   ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
 
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
-      "expected failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED)
+                              << "expected failure",
+                          "expected failure");
 
-# ifndef __BORLANDC__
+#ifndef __BORLANDC__
 
   // ICE's in C++Builder 2007 and 2009.
-  EXPECT_FATAL_FAILURE(
-      ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
-      "expected failure");
-# endif
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED)
+                           << "expected failure",
+                       "expected failure");
+#endif
 
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
-      "expected failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
+                          "expected failure");
 
-  EXPECT_FATAL_FAILURE(
-      ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
-      "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
+                       "expected failure");
 }
 
 #endif  // GTEST_OS_WINDOWS
@@ -4145,8 +4076,7 @@ TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
   else
     ;  // NOLINT
 
-  if (AlwaysFalse())
-    ASSERT_LT(1, 3);
+  if (AlwaysFalse()) ASSERT_LT(1, 3);
 
   if (AlwaysFalse())
     ;  // NOLINT
@@ -4184,24 +4114,21 @@ TEST(ExpectThrowTest, DoesNotGenerateDuplicateCatchClauseWarning) {
 #pragma GCC diagnostic ignored "-Wpragmas"
 #endif
 TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
-  if (AlwaysFalse())
-    EXPECT_THROW(ThrowNothing(), bool);
+  if (AlwaysFalse()) EXPECT_THROW(ThrowNothing(), bool);
 
   if (AlwaysTrue())
     EXPECT_THROW(ThrowAnInteger(), int);
   else
     ;  // NOLINT
 
-  if (AlwaysFalse())
-    EXPECT_NO_THROW(ThrowAnInteger());
+  if (AlwaysFalse()) EXPECT_NO_THROW(ThrowAnInteger());
 
   if (AlwaysTrue())
     EXPECT_NO_THROW(ThrowNothing());
   else
     ;  // NOLINT
 
-  if (AlwaysFalse())
-    EXPECT_ANY_THROW(ThrowNothing());
+  if (AlwaysFalse()) EXPECT_ANY_THROW(ThrowNothing());
 
   if (AlwaysTrue())
     EXPECT_ANY_THROW(ThrowAnInteger());
@@ -4257,8 +4184,8 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
   }
 
   switch (0)
-    case 0:
-      EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
+  case 0:
+    EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
 
   // Binary assertions are implemented using a different code path
   // than the Boolean assertions.  Hence we test them separately.
@@ -4269,22 +4196,20 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
   }
 
   switch (0)
-    case 0:
-      EXPECT_NE(1, 2);
+  case 0:
+    EXPECT_NE(1, 2);
 }
 
 #if GTEST_HAS_EXCEPTIONS
 
-void ThrowAString() {
-    throw "std::string";
-}
+void ThrowAString() { throw "std::string"; }
 
 // Test that the exception assertion macros compile and work with const
 // type qualifier.
 TEST(AssertionSyntaxTest, WorksWithConst) {
-    ASSERT_THROW(ThrowAString(), const char*);
+  ASSERT_THROW(ThrowAString(), const char*);
 
-    EXPECT_THROW(ThrowAString(), const char*);
+  EXPECT_THROW(ThrowAString(), const char*);
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -4382,22 +4307,19 @@ TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
 // Tests using ASSERT_FALSE with a streamed message.
 TEST(AssertionWithMessageTest, ASSERT_FALSE) {
   ASSERT_FALSE(false) << "This shouldn't fail.";
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
-                       << " evaluates to " << true;
-  }, "Expected failure");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
+                           << " evaluates to " << true;
+      },
+      "Expected failure");
 }
 
 // Tests using FAIL with a streamed message.
-TEST(AssertionWithMessageTest, FAIL) {
-  EXPECT_FATAL_FAILURE(FAIL() << 0,
-                       "0");
-}
+TEST(AssertionWithMessageTest, FAIL) { EXPECT_FATAL_FAILURE(FAIL() << 0, "0"); }
 
 // Tests using SUCCEED with a streamed message.
-TEST(AssertionWithMessageTest, SUCCEED) {
-  SUCCEED() << "Success == " << 1;
-}
+TEST(AssertionWithMessageTest, SUCCEED) { SUCCEED() << "Success == " << 1; }
 
 // Tests using ASSERT_TRUE with a streamed message.
 TEST(AssertionWithMessageTest, ASSERT_TRUE) {
@@ -4414,13 +4336,16 @@ TEST(AssertionWithMessageTest, ASSERT_TRUE) {
 #if GTEST_OS_WINDOWS
 // Tests using wide strings in assertion messages.
 TEST(AssertionWithMessageTest, WideStringMessage) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_TRUE(false) << L"This failure is expected.\x8119";
-  }, "This failure is expected.");
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EQ(1, 2) << "This failure is "
-                    << L"expected too.\x8120";
-  }, "This failure is expected too.");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_TRUE(false) << L"This failure is expected.\x8119";
+      },
+      "This failure is expected.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_EQ(1, 2) << "This failure is " << L"expected too.\x8120";
+      },
+      "This failure is expected too.");
 }
 #endif  // GTEST_OS_WINDOWS
 
@@ -4436,8 +4361,7 @@ TEST(ExpectTest, EXPECT_TRUE) {
                           "Value of: 2 < 1\n"
                           "  Actual: false\n"
                           "Expected: true");
-  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
-                          "2 > 3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), "2 > 3");
 }
 
 // Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
@@ -4466,8 +4390,7 @@ TEST(ExpectTest, EXPECT_FALSE) {
                           "Value of: 2 > 1\n"
                           "  Actual: true\n"
                           "Expected: false");
-  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
-                          "2 < 3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), "2 < 3");
 }
 
 // Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
@@ -4486,19 +4409,20 @@ TEST(ExpectTest, ExpectFalseWithAssertionResult) {
 
 #ifdef __BORLANDC__
 // Restores warnings after previous "#pragma option push" suppressed them
-# pragma option pop
+#pragma option pop
 #endif
 
 // Tests EXPECT_EQ.
 TEST(ExpectTest, EXPECT_EQ) {
   EXPECT_EQ(5, 2 + 3);
+  // clang-format off
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
                           "Expected equality of these values:\n"
                           "  5\n"
                           "  2*3\n"
                           "    Which is: 6");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
-                          "2 - 3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), "2 - 3");
+  // clang-format on
 }
 
 // Tests using EXPECT_EQ on double values.  The purpose is to make
@@ -4509,8 +4433,7 @@ TEST(ExpectTest, EXPECT_EQ_Double) {
   EXPECT_EQ(5.6, 5.6);
 
   // A failure.
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
-                          "5.1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), "5.1");
 }
 
 // Tests EXPECT_EQ(NULL, pointer).
@@ -4535,8 +4458,7 @@ TEST(ExpectTest, EXPECT_EQ_0) {
   EXPECT_EQ(0, n);
 
   // A failure.
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
-                          "  0\n  5.6");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), "  0\n  5.6");
 }
 
 // Tests EXPECT_NE.
@@ -4546,19 +4468,16 @@ TEST(ExpectTest, EXPECT_NE) {
   EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
                           "Expected: ('a') != ('a'), "
                           "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
-                          "2");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), "2");
   char* const p0 = nullptr;
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
-                          "p0");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), "p0");
   // Only way to get the Nokia compiler to compile the cast
   // is to have a separate void* variable first. Putting
   // the two casts on the same line doesn't work, neither does
   // a direct C-style to char*.
   void* pv1 = (void*)0x1234;  // NOLINT
   char* const p1 = reinterpret_cast<char*>(pv1);
-  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
-                          "p1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), "p1");
 }
 
 // Tests EXPECT_LE.
@@ -4567,8 +4486,7 @@ TEST(ExpectTest, EXPECT_LE) {
   EXPECT_LE(2, 2);
   EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
                           "Expected: (2) <= (0), actual: 2 vs 0");
-  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
-                          "(1.1) <= (0.9)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), "(1.1) <= (0.9)");
 }
 
 // Tests EXPECT_LT.
@@ -4576,8 +4494,7 @@ TEST(ExpectTest, EXPECT_LT) {
   EXPECT_LT(2, 3);
   EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
                           "Expected: (2) < (2), actual: 2 vs 2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
-                          "(2) < (1)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), "(2) < (1)");
 }
 
 // Tests EXPECT_GE.
@@ -4586,8 +4503,7 @@ TEST(ExpectTest, EXPECT_GE) {
   EXPECT_GE(2, 2);
   EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
                           "Expected: (2) >= (3), actual: 2 vs 3");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
-                          "(0.9) >= (1.1)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), "(0.9) >= (1.1)");
 }
 
 // Tests EXPECT_GT.
@@ -4595,8 +4511,7 @@ TEST(ExpectTest, EXPECT_GT) {
   EXPECT_GT(2, 1);
   EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
                           "Expected: (2) > (2), actual: 2 vs 2");
-  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
-                          "(2) > (3)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), "(2) > (3)");
 }
 
 #if GTEST_HAS_EXCEPTIONS
@@ -4607,12 +4522,13 @@ TEST(ExpectTest, EXPECT_THROW) {
   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
                           "Expected: ThrowAnInteger() throws an exception of "
                           "type bool.\n  Actual: it throws a different type.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowRuntimeError("A description"),
-                                       std::logic_error),
-                          "Expected: ThrowRuntimeError(\"A description\") "
-                          "throws an exception of type std::logic_error.\n  "
-                          "Actual: it throws " ERROR_DESC " "
-                          "with description \"A description\".");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW(ThrowRuntimeError("A description"), std::logic_error),
+      "Expected: ThrowRuntimeError(\"A description\") "
+      "throws an exception of type std::logic_error.\n  "
+      "Actual: it throws " ERROR_DESC
+      " "
+      "with description \"A description\".");
   EXPECT_NONFATAL_FAILURE(
       EXPECT_THROW(ThrowNothing(), bool),
       "Expected: ThrowNothing() throws an exception of type bool.\n"
@@ -4628,17 +4544,17 @@ TEST(ExpectTest, EXPECT_NO_THROW) {
   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowRuntimeError("A description")),
                           "Expected: ThrowRuntimeError(\"A description\") "
                           "doesn't throw an exception.\n  "
-                          "Actual: it throws " ERROR_DESC " "
+                          "Actual: it throws " ERROR_DESC
+                          " "
                           "with description \"A description\".");
 }
 
 // Tests EXPECT_ANY_THROW.
 TEST(ExpectTest, EXPECT_ANY_THROW) {
   EXPECT_ANY_THROW(ThrowAnInteger());
-  EXPECT_NONFATAL_FAILURE(
-      EXPECT_ANY_THROW(ThrowNothing()),
-      "Expected: ThrowNothing() throws an exception.\n"
-      "  Actual: it doesn't.");
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()),
+                          "Expected: ThrowNothing() throws an exception.\n"
+                          "  Actual: it doesn't.");
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -4650,7 +4566,6 @@ TEST(ExpectTest, ExpectPrecedence) {
                           "  true && false\n    Which is: false");
 }
 
-
 // Tests the StreamableToString() function.
 
 // Tests using StreamableToString() on a scalar.
@@ -4688,8 +4603,7 @@ TEST(StreamableToStringTest, NullCString) {
 TEST(StreamableTest, string) {
   static const std::string str(
       "This failure message is a std::string, and is expected.");
-  EXPECT_FATAL_FAILURE(FAIL() << str,
-                       str.c_str());
+  EXPECT_FATAL_FAILURE(FAIL() << str, str.c_str());
 }
 
 // Tests that we can output strings containing embedded NULs.
@@ -4697,25 +4611,24 @@ TEST(StreamableTest, string) {
 TEST(StreamableTest, stringWithEmbeddedNUL) {
   static const char char_array_with_nul[] =
       "Here's a NUL\0 and some more string";
-  static const std::string string_with_nul(char_array_with_nul,
-                                           sizeof(char_array_with_nul)
-                                           - 1);  // drops the trailing NUL
+  static const std::string string_with_nul(
+      char_array_with_nul,
+      sizeof(char_array_with_nul) - 1);  // drops the trailing NUL
   EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
                        "Here's a NUL\\0 and some more string");
 }
 
 // Tests that we can output a NUL char.
 TEST(StreamableTest, NULChar) {
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    FAIL() << "A NUL" << '\0' << " and some more string";
-  }, "A NUL\\0 and some more string");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        FAIL() << "A NUL" << '\0' << " and some more string";
+      },
+      "A NUL\\0 and some more string");
 }
 
 // Tests using int as an assertion message.
-TEST(StreamableTest, int) {
-  EXPECT_FATAL_FAILURE(FAIL() << 900913,
-                       "900913");
-}
+TEST(StreamableTest, int) { EXPECT_FATAL_FAILURE(FAIL() << 900913, "900913"); }
 
 // Tests using NULL char pointer as an assertion message.
 //
@@ -4729,10 +4642,12 @@ TEST(StreamableTest, NullCharPtr) {
 // Tests that basic IO manipulators (endl, ends, and flush) can be
 // streamed to testing::Message.
 TEST(StreamableTest, BasicIoManip) {
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    FAIL() << "Line 1." << std::endl
-           << "A NUL char " << std::ends << std::flush << " in line 2.";
-  }, "Line 1.\nA NUL char \\0 in line 2.");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        FAIL() << "Line 1." << std::endl
+               << "A NUL char " << std::ends << std::flush << " in line 2.";
+      },
+      "Line 1.\nA NUL char \\0 in line 2.");
 }
 
 // Tests the macros that haven't been covered so far.
@@ -4746,8 +4661,7 @@ void AddFailureHelper(bool* aborted) {
 // Tests ADD_FAILURE.
 TEST(MacroTest, ADD_FAILURE) {
   bool aborted = true;
-  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
-                          "Intentional failure.");
+  EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), "Intentional failure.");
   EXPECT_FALSE(aborted);
 }
 
@@ -4768,8 +4682,7 @@ TEST(MacroTest, ADD_FAILURE_AT) {
 
 // Tests FAIL.
 TEST(MacroTest, FAIL) {
-  EXPECT_FATAL_FAILURE(FAIL(),
-                       "Failed");
+  EXPECT_FATAL_FAILURE(FAIL(), "Failed");
   EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
                        "Intentional failure.");
 }
@@ -4802,37 +4715,34 @@ TEST(MacroTest, SUCCEED) {
 
 // Tests using bool values in {EXPECT|ASSERT}_EQ.
 TEST(EqAssertionTest, Bool) {
-  EXPECT_EQ(true,  true);
-  EXPECT_FATAL_FAILURE({
-      bool false_value = false;
-      ASSERT_EQ(false_value, true);
-    }, "  false_value\n    Which is: false\n  true");
+  EXPECT_EQ(true, true);
+  EXPECT_FATAL_FAILURE(
+      {
+        bool false_value = false;
+        ASSERT_EQ(false_value, true);
+      },
+      "  false_value\n    Which is: false\n  true");
 }
 
 // Tests using int values in {EXPECT|ASSERT}_EQ.
 TEST(EqAssertionTest, Int) {
   ASSERT_EQ(32, 32);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
-                          "  32\n  33");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), "  32\n  33");
 }
 
 // Tests using time_t values in {EXPECT|ASSERT}_EQ.
 TEST(EqAssertionTest, Time_T) {
-  EXPECT_EQ(static_cast<time_t>(0),
-            static_cast<time_t>(0));
-  EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
-                                 static_cast<time_t>(1234)),
-                       "1234");
+  EXPECT_EQ(static_cast<time_t>(0), static_cast<time_t>(0));
+  EXPECT_FATAL_FAILURE(
+      ASSERT_EQ(static_cast<time_t>(0), static_cast<time_t>(1234)), "1234");
 }
 
 // Tests using char values in {EXPECT|ASSERT}_EQ.
 TEST(EqAssertionTest, Char) {
   ASSERT_EQ('z', 'z');
   const char ch = 'b';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
-                          "  ch\n    Which is: 'b'");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
-                          "  ch\n    Which is: 'b'");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), "  ch\n    Which is: 'b'");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), "  ch\n    Which is: 'b'");
 }
 
 // Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
@@ -4848,8 +4758,7 @@ TEST(EqAssertionTest, WideChar) {
 
   static wchar_t wchar;
   wchar = L'b';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
-                          "wchar");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), "wchar");
   wchar = 0x8119;
   EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
                        "  wchar\n    Which is: L'");
@@ -4868,13 +4777,11 @@ TEST(EqAssertionTest, StdString) {
 
   // Compares a const char* to an std::string that has different
   // content
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
-                          "\"test\"");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), "\"test\"");
 
   // Compares an std::string to a char* that has different content.
   char* const p1 = const_cast<char*>("foo");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
-                          "p1");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), "p1");
 
   // Compares two std::strings that have different contents, one of
   // which having a NUL character in the middle.  This should fail.
@@ -4895,28 +4802,31 @@ TEST(EqAssertionTest, StdWideString) {
 
   // Compares an std::wstring to a const wchar_t* that has identical
   // content.
-  const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
+  const wchar_t kTestX8119[] = {'T', 'e', 's', 't', 0x8119, '\0'};
   EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
 
   // Compares an std::wstring to a const wchar_t* that has different
   // content.
-  const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
-  }, "kTestX8120");
+  const wchar_t kTestX8120[] = {'T', 'e', 's', 't', 0x8120, '\0'};
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
+      },
+      "kTestX8120");
 
   // Compares two std::wstrings that have different contents, one of
   // which having a NUL character in the middle.
   ::std::wstring wstr3(wstr1);
   wstr3.at(2) = L'\0';
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
-                          "wstr3");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), "wstr3");
 
   // Compares a wchar_t* to an std::wstring that has different
   // content.
-  EXPECT_FATAL_FAILURE({  // NOLINT
-    ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
-  }, "");
+  EXPECT_FATAL_FAILURE(
+      {  // NOLINT
+        ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
+      },
+      "");
 }
 
 #endif  // GTEST_HAS_STD_WSTRING
@@ -4934,10 +4844,8 @@ TEST(EqAssertionTest, CharPointer) {
   char* const p2 = reinterpret_cast<char*>(pv2);
   ASSERT_EQ(p1, p1);
 
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
-                          "  p2\n    Which is:");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
-                          "  p2\n    Which is:");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), "  p2\n    Which is:");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), "  p2\n    Which is:");
   EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
                                  reinterpret_cast<char*>(0xABC0)),
                        "ABC0");
@@ -4956,16 +4864,13 @@ TEST(EqAssertionTest, WideCharPointer) {
   wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
   EXPECT_EQ(p0, p0);
 
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
-                          "  p2\n    Which is:");
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
-                          "  p2\n    Which is:");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), "  p2\n    Which is:");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), "  p2\n    Which is:");
   void* pv3 = (void*)0x1234;  // NOLINT
   void* pv4 = (void*)0xABC0;  // NOLINT
   const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
   const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
-  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
-                          "p4");
+  EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), "p4");
 }
 
 // Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
@@ -4987,15 +4892,11 @@ class UnprintableChar {
   bool operator!=(const UnprintableChar& rhs) const {
     return char_ != rhs.char_;
   }
-  bool operator<(const UnprintableChar& rhs) const {
-    return char_ < rhs.char_;
-  }
+  bool operator<(const UnprintableChar& rhs) const { return char_ < rhs.char_; }
   bool operator<=(const UnprintableChar& rhs) const {
     return char_ <= rhs.char_;
   }
-  bool operator>(const UnprintableChar& rhs) const {
-    return char_ > rhs.char_;
-  }
+  bool operator>(const UnprintableChar& rhs) const { return char_ > rhs.char_; }
   bool operator>=(const UnprintableChar& rhs) const {
     return char_ >= rhs.char_;
   }
@@ -5057,9 +4958,7 @@ class Foo {
 
 // Tests that the FRIEND_TEST declaration allows a TEST to access a
 // class's private members.  This should compile.
-TEST(FRIEND_TEST_Test, TEST) {
-  ASSERT_EQ(1, Foo().Bar());
-}
+TEST(FRIEND_TEST_Test, TEST) { ASSERT_EQ(1, Foo().Bar()); }
 
 // The fixture needed to test using FRIEND_TEST with TEST_F.
 class FRIEND_TEST_Test2 : public Test {
@@ -5069,9 +4968,7 @@ class FRIEND_TEST_Test2 : public Test {
 
 // Tests that the FRIEND_TEST declaration allows a TEST_F to access a
 // class's private members.  This should compile.
-TEST_F(FRIEND_TEST_Test2, TEST_F) {
-  ASSERT_EQ(1, foo.Bar());
-}
+TEST_F(FRIEND_TEST_Test2, TEST_F) { ASSERT_EQ(1, foo.Bar()); }
 
 // Tests the life cycle of Test objects.
 
@@ -5206,15 +5103,14 @@ class Base {
  public:
   explicit Base(int an_x) : x_(an_x) {}
   int x() const { return x_; }
+
  private:
   int x_;
 };
-std::ostream& operator<<(std::ostream& os,
-                         const Base& val) {
+std::ostream& operator<<(std::ostream& os, const Base& val) {
   return os << val.x();
 }
-std::ostream& operator<<(std::ostream& os,
-                         const Base* pointer) {
+std::ostream& operator<<(std::ostream& os, const Base* pointer) {
   return os << "(" << pointer->x() << ")";
 }
 
@@ -5231,7 +5127,7 @@ TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
 namespace {
 class MyTypeInUnnamedNameSpace : public Base {
  public:
-  explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
+  explicit MyTypeInUnnamedNameSpace(int an_x) : Base(an_x) {}
 };
 std::ostream& operator<<(std::ostream& os,
                          const MyTypeInUnnamedNameSpace& val) {
@@ -5256,14 +5152,12 @@ TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
 namespace namespace1 {
 class MyTypeInNameSpace1 : public Base {
  public:
-  explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
+  explicit MyTypeInNameSpace1(int an_x) : Base(an_x) {}
 };
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInNameSpace1& val) {
+std::ostream& operator<<(std::ostream& os, const MyTypeInNameSpace1& val) {
   return os << val.x();
 }
-std::ostream& operator<<(std::ostream& os,
-                         const MyTypeInNameSpace1* pointer) {
+std::ostream& operator<<(std::ostream& os, const MyTypeInNameSpace1* pointer) {
   return os << "(" << pointer->x() << ")";
 }
 }  // namespace namespace1
@@ -5281,7 +5175,7 @@ TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
 namespace namespace2 {
 class MyTypeInNameSpace2 : public ::Base {
  public:
-  explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
+  explicit MyTypeInNameSpace2(int an_x) : Base(an_x) {}
 };
 }  // namespace namespace2
 std::ostream& operator<<(std::ostream& os,
@@ -5312,21 +5206,18 @@ TEST(MessageTest, NullPointers) {
   Message* p6 = nullptr;
 
   msg << p1 << p2 << p3 << p4 << p5 << p6;
-  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
-               msg.GetString().c_str());
+  ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", msg.GetString().c_str());
 }
 
 // Tests streaming wide strings to testing::Message.
 TEST(MessageTest, WideStrings) {
   // Streams a NULL of type const wchar_t*.
   const wchar_t* const_wstr = nullptr;
-  EXPECT_STREQ("(null)",
-               (Message() << const_wstr).GetString().c_str());
+  EXPECT_STREQ("(null)", (Message() << const_wstr).GetString().c_str());
 
   // Streams a NULL of type wchar_t*.
   wchar_t* wstr = nullptr;
-  EXPECT_STREQ("(null)",
-               (Message() << wstr).GetString().c_str());
+  EXPECT_STREQ("(null)", (Message() << wstr).GetString().c_str());
 
   // Streams a non-NULL of type const wchar_t*.
   const_wstr = L"abc\x8119";
@@ -5335,11 +5226,9 @@ TEST(MessageTest, WideStrings) {
 
   // Streams a non-NULL of type wchar_t*.
   wstr = const_cast<wchar_t*>(const_wstr);
-  EXPECT_STREQ("abc\xe8\x84\x99",
-               (Message() << wstr).GetString().c_str());
+  EXPECT_STREQ("abc\xe8\x84\x99", (Message() << wstr).GetString().c_str());
 }
 
-
 // This line tests that we can define tests in the testing namespace.
 namespace testing {
 
@@ -5353,14 +5242,12 @@ class TestInfoTest : public Test {
 
     for (int i = 0; i < test_suite->total_test_count(); ++i) {
       const TestInfo* const test_info = test_suite->GetTestInfo(i);
-      if (strcmp(test_name, test_info->name()) == 0)
-        return test_info;
+      if (strcmp(test_name, test_info->name()) == 0) return test_info;
     }
     return nullptr;
   }
 
-  static const TestResult* GetTestResult(
-      const TestInfo* test_info) {
+  static const TestResult* GetTestResult(const TestInfo* test_info) {
     return test_info->result();
   }
 };
@@ -5384,26 +5271,25 @@ TEST_F(TestInfoTest, result) {
   ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
 }
 
-#define VERIFY_CODE_LOCATION \
-  const int expected_line = __LINE__ - 1; \
+#define VERIFY_CODE_LOCATION                                                \
+  const int expected_line = __LINE__ - 1;                                   \
   const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
-  ASSERT_TRUE(test_info); \
-  EXPECT_STREQ(__FILE__, test_info->file()); \
+  ASSERT_TRUE(test_info);                                                   \
+  EXPECT_STREQ(__FILE__, test_info->file());                                \
   EXPECT_EQ(expected_line, test_info->line())
 
+// clang-format off
 TEST(CodeLocationForTEST, Verify) {
   VERIFY_CODE_LOCATION;
 }
 
-class CodeLocationForTESTF : public Test {
-};
+class CodeLocationForTESTF : public Test {};
 
 TEST_F(CodeLocationForTESTF, Verify) {
   VERIFY_CODE_LOCATION;
 }
 
-class CodeLocationForTESTP : public TestWithParam<int> {
-};
+class CodeLocationForTESTP : public TestWithParam<int> {};
 
 TEST_P(CodeLocationForTESTP, Verify) {
   VERIFY_CODE_LOCATION;
@@ -5412,8 +5298,7 @@ TEST_P(CodeLocationForTESTP, Verify) {
 INSTANTIATE_TEST_SUITE_P(, CodeLocationForTESTP, Values(0));
 
 template <typename T>
-class CodeLocationForTYPEDTEST : public Test {
-};
+class CodeLocationForTYPEDTEST : public Test {};
 
 TYPED_TEST_SUITE(CodeLocationForTYPEDTEST, int);
 
@@ -5422,8 +5307,7 @@ TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
 }
 
 template <typename T>
-class CodeLocationForTYPEDTESTP : public Test {
-};
+class CodeLocationForTYPEDTESTP : public Test {};
 
 TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP);
 
@@ -5436,6 +5320,7 @@ REGISTER_TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP, Verify);
 INSTANTIATE_TYPED_TEST_SUITE_P(My, CodeLocationForTYPEDTESTP, int);
 
 #undef VERIFY_CODE_LOCATION
+// clang-format on
 
 // Tests setting up and tearing down a test case.
 // Legacy API is deprecated but still available
@@ -5495,9 +5380,7 @@ const char* SetUpTestCaseTest::shared_resource_ = nullptr;
 TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resource_); }
 
 // Another test that uses the shared resource.
-TEST_F(SetUpTestCaseTest, Test2) {
-  EXPECT_STREQ("123", shared_resource_);
-}
+TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource_); }
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
 // Tests SetupTestSuite/TearDown TestSuite
@@ -5580,6 +5463,7 @@ struct Flags {
         print_time(true),
         random_seed(0),
         repeat(1),
+        recreate_environments_when_repeating(true),
         shuffle(false),
         stack_trace_depth(kMaxStackTraceDepth),
         stream_result_to(""),
@@ -5683,6 +5567,16 @@ struct Flags {
     return flags;
   }
 
+  // Creates a Flags struct where the gtest_recreate_environments_when_repeating
+  // flag has the given value.
+  static Flags RecreateEnvironmentsWhenRepeating(
+      bool recreate_environments_when_repeating) {
+    Flags flags;
+    flags.recreate_environments_when_repeating =
+        recreate_environments_when_repeating;
+    return flags;
+  }
+
   // Creates a Flags struct where the gtest_shuffle flag has the given
   // value.
   static Flags Shuffle(bool shuffle) {
@@ -5728,6 +5622,7 @@ struct Flags {
   bool print_time;
   int32_t random_seed;
   int32_t repeat;
+  bool recreate_environments_when_repeating;
   bool shuffle;
   int32_t stack_trace_depth;
   const char* stream_result_to;
@@ -5739,22 +5634,23 @@ class ParseFlagsTest : public Test {
  protected:
   // Clears the flags before each test.
   void SetUp() override {
-    GTEST_FLAG(also_run_disabled_tests) = false;
-    GTEST_FLAG(break_on_failure) = false;
-    GTEST_FLAG(catch_exceptions) = false;
-    GTEST_FLAG(death_test_use_fork) = false;
-    GTEST_FLAG(fail_fast) = false;
-    GTEST_FLAG(filter) = "";
-    GTEST_FLAG(list_tests) = false;
-    GTEST_FLAG(output) = "";
-    GTEST_FLAG(brief) = false;
-    GTEST_FLAG(print_time) = true;
-    GTEST_FLAG(random_seed) = 0;
-    GTEST_FLAG(repeat) = 1;
-    GTEST_FLAG(shuffle) = false;
-    GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
-    GTEST_FLAG(stream_result_to) = "";
-    GTEST_FLAG(throw_on_failure) = false;
+    GTEST_FLAG_SET(also_run_disabled_tests, false);
+    GTEST_FLAG_SET(break_on_failure, false);
+    GTEST_FLAG_SET(catch_exceptions, false);
+    GTEST_FLAG_SET(death_test_use_fork, false);
+    GTEST_FLAG_SET(fail_fast, false);
+    GTEST_FLAG_SET(filter, "");
+    GTEST_FLAG_SET(list_tests, false);
+    GTEST_FLAG_SET(output, "");
+    GTEST_FLAG_SET(brief, false);
+    GTEST_FLAG_SET(print_time, true);
+    GTEST_FLAG_SET(random_seed, 0);
+    GTEST_FLAG_SET(repeat, 1);
+    GTEST_FLAG_SET(recreate_environments_when_repeating, true);
+    GTEST_FLAG_SET(shuffle, false);
+    GTEST_FLAG_SET(stack_trace_depth, kMaxStackTraceDepth);
+    GTEST_FLAG_SET(stream_result_to, "");
+    GTEST_FLAG_SET(throw_on_failure, false);
   }
 
   // Asserts that two narrow or wide string arrays are equal.
@@ -5771,45 +5667,48 @@ class ParseFlagsTest : public Test {
   // Verifies that the flag values match the expected values.
   static void CheckFlags(const Flags& expected) {
     EXPECT_EQ(expected.also_run_disabled_tests,
-              GTEST_FLAG(also_run_disabled_tests));
-    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
-    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
-    EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
-    EXPECT_EQ(expected.fail_fast, GTEST_FLAG(fail_fast));
-    EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
-    EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
-    EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
-    EXPECT_EQ(expected.brief, GTEST_FLAG(brief));
-    EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
-    EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
-    EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
-    EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
-    EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
+              GTEST_FLAG_GET(also_run_disabled_tests));
+    EXPECT_EQ(expected.break_on_failure, GTEST_FLAG_GET(break_on_failure));
+    EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG_GET(catch_exceptions));
+    EXPECT_EQ(expected.death_test_use_fork,
+              GTEST_FLAG_GET(death_test_use_fork));
+    EXPECT_EQ(expected.fail_fast, GTEST_FLAG_GET(fail_fast));
+    EXPECT_STREQ(expected.filter, GTEST_FLAG_GET(filter).c_str());
+    EXPECT_EQ(expected.list_tests, GTEST_FLAG_GET(list_tests));
+    EXPECT_STREQ(expected.output, GTEST_FLAG_GET(output).c_str());
+    EXPECT_EQ(expected.brief, GTEST_FLAG_GET(brief));
+    EXPECT_EQ(expected.print_time, GTEST_FLAG_GET(print_time));
+    EXPECT_EQ(expected.random_seed, GTEST_FLAG_GET(random_seed));
+    EXPECT_EQ(expected.repeat, GTEST_FLAG_GET(repeat));
+    EXPECT_EQ(expected.recreate_environments_when_repeating,
+              GTEST_FLAG_GET(recreate_environments_when_repeating));
+    EXPECT_EQ(expected.shuffle, GTEST_FLAG_GET(shuffle));
+    EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG_GET(stack_trace_depth));
     EXPECT_STREQ(expected.stream_result_to,
-                 GTEST_FLAG(stream_result_to).c_str());
-    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
+                 GTEST_FLAG_GET(stream_result_to).c_str());
+    EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG_GET(throw_on_failure));
   }
 
   // Parses a command line (specified by argc1 and argv1), then
   // verifies that the flag values are expected and that the
   // recognized flags are removed from the command line.
   template <typename CharType>
-  static void TestParsingFlags(int argc1, const CharType** argv1,
-                               int argc2, const CharType** argv2,
-                               const Flags& expected, bool should_print_help) {
+  static void TestParsingFlags(int argc1, const CharType** argv1, int argc2,
+                               const CharType** argv2, const Flags& expected,
+                               bool should_print_help) {
     const bool saved_help_flag = ::testing::internal::g_help_flag;
     ::testing::internal::g_help_flag = false;
 
-# if GTEST_HAS_STREAM_REDIRECTION
+#if GTEST_HAS_STREAM_REDIRECTION
     CaptureStdout();
-# endif
+#endif
 
     // Parses the command line.
     internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
 
-# if GTEST_HAS_STREAM_REDIRECTION
+#if GTEST_HAS_STREAM_REDIRECTION
     const std::string captured_stdout = GetCapturedStdout();
-# endif
+#endif
 
     // Verifies the flag values.
     CheckFlags(expected);
@@ -5822,16 +5721,16 @@ class ParseFlagsTest : public Test {
     // help message for the flags it recognizes.
     EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
 
-# if GTEST_HAS_STREAM_REDIRECTION
+#if GTEST_HAS_STREAM_REDIRECTION
     const char* const expected_help_fragment =
         "This program contains tests written using";
     if (should_print_help) {
       EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
     } else {
-      EXPECT_PRED_FORMAT2(IsNotSubstring,
-                          expected_help_fragment, captured_stdout);
+      EXPECT_PRED_FORMAT2(IsNotSubstring, expected_help_fragment,
+                          captured_stdout);
     }
-# endif  // GTEST_HAS_STREAM_REDIRECTION
+#endif  // GTEST_HAS_STREAM_REDIRECTION
 
     ::testing::internal::g_help_flag = saved_help_flag;
   }
@@ -5839,10 +5738,10 @@ class ParseFlagsTest : public Test {
   // This macro wraps TestParsingFlags s.t. the user doesn't need
   // to specify the array sizes.
 
-# define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
-  TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
-                   sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
-                   expected, should_print_help)
+#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
+  TestParsingFlags(sizeof(argv1) / sizeof(*argv1) - 1, argv1,                \
+                   sizeof(argv2) / sizeof(*argv2) - 1, argv2, expected,      \
+                   should_print_help)
 };
 
 // Tests parsing an empty command line.
@@ -5872,15 +5771,6 @@ TEST_F(ParseFlagsTest, FailFast) {
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::FailFast(true), false);
 }
 
-// Tests parsing a bad --gtest_filter flag.
-TEST_F(ParseFlagsTest, FilterBad) {
-  const char* argv[] = {"foo.exe", "--gtest_filter", nullptr};
-
-  const char* argv2[] = {"foo.exe", "--gtest_filter", nullptr};
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
-}
-
 // Tests parsing an empty --gtest_filter flag.
 TEST_F(ParseFlagsTest, FilterEmpty) {
   const char* argv[] = {"foo.exe", "--gtest_filter=", nullptr};
@@ -6033,15 +5923,6 @@ TEST_F(ParseFlagsTest, ListTestsFalse_F) {
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
 }
 
-// Tests parsing --gtest_output (invalid).
-TEST_F(ParseFlagsTest, OutputEmpty) {
-  const char* argv[] = {"foo.exe", "--gtest_output", nullptr};
-
-  const char* argv2[] = {"foo.exe", "--gtest_output", nullptr};
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
-}
-
 // Tests parsing --gtest_output=xml
 TEST_F(ParseFlagsTest, OutputXml) {
   const char* argv[] = {"foo.exe", "--gtest_output=xml", nullptr};
@@ -6067,8 +5948,8 @@ TEST_F(ParseFlagsTest, OutputXmlDirectory) {
 
   const char* argv2[] = {"foo.exe", nullptr};
 
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2,
-                            Flags::Output("xml:directory/path/"), false);
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/"),
+                            false);
 }
 
 // Tests having a --gtest_brief flag
@@ -6161,6 +6042,20 @@ TEST_F(ParseFlagsTest, Repeat) {
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
 }
 
+// Tests parsing --gtest_recreate_environments_when_repeating
+TEST_F(ParseFlagsTest, RecreateEnvironmentsWhenRepeating) {
+  const char* argv[] = {
+      "foo.exe",
+      "--gtest_recreate_environments_when_repeating=0",
+      nullptr,
+  };
+
+  const char* argv2[] = {"foo.exe", nullptr};
+
+  GTEST_TEST_PARSING_FLAGS_(
+      argv, argv2, Flags::RecreateEnvironmentsWhenRepeating(false), false);
+}
+
 // Tests having a --gtest_also_run_disabled_tests flag
 TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
   const char* argv[] = {"foo.exe", "--gtest_also_run_disabled_tests", nullptr};
@@ -6235,8 +6130,8 @@ TEST_F(ParseFlagsTest, StreamResultTo) {
 
   const char* argv2[] = {"foo.exe", nullptr};
 
-  GTEST_TEST_PARSING_FLAGS_(
-      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2,
+                            Flags::StreamResultTo("localhost:1234"), false);
 }
 
 // Tests parsing --gtest_throw_on_failure.
@@ -6267,23 +6162,69 @@ TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
 }
 
-# if GTEST_OS_WINDOWS
+// Tests parsing a bad --gtest_filter flag.
+TEST_F(ParseFlagsTest, FilterBad) {
+  const char* argv[] = {"foo.exe", "--gtest_filter", nullptr};
+
+  const char* argv2[] = {"foo.exe", "--gtest_filter", nullptr};
+
+#if GTEST_HAS_ABSL && GTEST_HAS_DEATH_TEST
+  // Invalid flag arguments are a fatal error when using the Abseil Flags.
+  EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true),
+              testing::ExitedWithCode(1),
+              "ERROR: Missing the value for the flag 'gtest_filter'");
+#elif !GTEST_HAS_ABSL
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
+#else
+  static_cast<void>(argv);
+  static_cast<void>(argv2);
+#endif
+}
+
+// Tests parsing --gtest_output (invalid).
+TEST_F(ParseFlagsTest, OutputEmpty) {
+  const char* argv[] = {"foo.exe", "--gtest_output", nullptr};
+
+  const char* argv2[] = {"foo.exe", "--gtest_output", nullptr};
+
+#if GTEST_HAS_ABSL && GTEST_HAS_DEATH_TEST
+  // Invalid flag arguments are a fatal error when using the Abseil Flags.
+  EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true),
+              testing::ExitedWithCode(1),
+              "ERROR: Missing the value for the flag 'gtest_output'");
+#elif !GTEST_HAS_ABSL
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
+#else
+  static_cast<void>(argv);
+  static_cast<void>(argv2);
+#endif
+}
+
+#if GTEST_HAS_ABSL
+TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
+  const char* argv[] = {"foo.exe", "--gtest_throw_on_failure=1", "--",
+                        "--other_flag", nullptr};
+
+  // When using Abseil flags, it should be possible to pass flags not recognized
+  // using "--" to delimit positional arguments. These flags should be returned
+  // though argv.
+  const char* argv2[] = {"foo.exe", "--other_flag", nullptr};
+
+  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
+}
+#endif
+
+#if GTEST_OS_WINDOWS
 // Tests parsing wide strings.
 TEST_F(ParseFlagsTest, WideStrings) {
-  const wchar_t* argv[] = {
-    L"foo.exe",
-    L"--gtest_filter=Foo*",
-    L"--gtest_list_tests=1",
-    L"--gtest_break_on_failure",
-    L"--non_gtest_flag",
-    NULL
-  };
+  const wchar_t* argv[] = {L"foo.exe",
+                           L"--gtest_filter=Foo*",
+                           L"--gtest_list_tests=1",
+                           L"--gtest_break_on_failure",
+                           L"--non_gtest_flag",
+                           NULL};
 
-  const wchar_t* argv2[] = {
-    L"foo.exe",
-    L"--non_gtest_flag",
-    NULL
-  };
+  const wchar_t* argv2[] = {L"foo.exe", L"--non_gtest_flag", NULL};
 
   Flags expected_flags;
   expected_flags.break_on_failure = true;
@@ -6292,7 +6233,7 @@ TEST_F(ParseFlagsTest, WideStrings) {
 
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
 }
-# endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_OS_WINDOWS
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
 class FlagfileTest : public ParseFlagsTest {
@@ -6340,8 +6281,8 @@ TEST_F(FlagfileTest, Empty) {
 
 // Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
 TEST_F(FlagfileTest, FilterNonEmpty) {
-  internal::FilePath flagfile_path(CreateFlagfile(
-      "--"  GTEST_FLAG_PREFIX_  "filter=abc"));
+  internal::FilePath flagfile_path(
+      CreateFlagfile("--" GTEST_FLAG_PREFIX_ "filter=abc"));
   std::string flagfile_flag =
       std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
 
@@ -6354,10 +6295,10 @@ TEST_F(FlagfileTest, FilterNonEmpty) {
 
 // Tests passing several flags via --gtest_flagfile.
 TEST_F(FlagfileTest, SeveralFlags) {
-  internal::FilePath flagfile_path(CreateFlagfile(
-      "--"  GTEST_FLAG_PREFIX_  "filter=abc\n"
-      "--"  GTEST_FLAG_PREFIX_  "break_on_failure\n"
-      "--"  GTEST_FLAG_PREFIX_  "list_tests"));
+  internal::FilePath flagfile_path(
+      CreateFlagfile("--" GTEST_FLAG_PREFIX_ "filter=abc\n"
+                     "--" GTEST_FLAG_PREFIX_ "break_on_failure\n"
+                     "--" GTEST_FLAG_PREFIX_ "list_tests"));
   std::string flagfile_flag =
       std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
 
@@ -6381,8 +6322,7 @@ class CurrentTestInfoTest : public Test {
   // the test case is run.
   static void SetUpTestSuite() {
     // There should be no tests running at this point.
-    const TestInfo* test_info =
-      UnitTest::GetInstance()->current_test_info();
+    const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
     EXPECT_TRUE(test_info == nullptr)
         << "There should be no tests running at this point.";
   }
@@ -6390,8 +6330,7 @@ class CurrentTestInfoTest : public Test {
   // Tests that current_test_info() returns NULL after the last test in
   // the test case has run.
   static void TearDownTestSuite() {
-    const TestInfo* test_info =
-      UnitTest::GetInstance()->current_test_info();
+    const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
     EXPECT_TRUE(test_info == nullptr)
         << "There should be no tests running at this point.";
   }
@@ -6400,8 +6339,7 @@ class CurrentTestInfoTest : public Test {
 // Tests that current_test_info() returns TestInfo for currently running
 // test by checking the expected test name against the actual one.
 TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
-  const TestInfo* test_info =
-    UnitTest::GetInstance()->current_test_info();
+  const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
   ASSERT_TRUE(nullptr != test_info)
       << "There is a test running so we should have a valid TestInfo.";
   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
@@ -6415,8 +6353,7 @@ TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
 // use this test to see that the TestInfo object actually changed from
 // the previous invocation.
 TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
-  const TestInfo* test_info =
-    UnitTest::GetInstance()->current_test_info();
+  const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
   ASSERT_TRUE(nullptr != test_info)
       << "There is a test running so we should have a valid TestInfo.";
   EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
@@ -6427,7 +6364,6 @@ TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
 
 }  // namespace testing
 
-
 // These two lines test that we can define tests in a namespace that
 // has the name "testing" and is nested in another namespace.
 namespace my_namespace {
@@ -6476,13 +6412,12 @@ TEST(StreamingAssertionsTest, Unconditional) {
   SUCCEED() << "expected success";
   EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
                           "expected failure");
-  EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
-                       "expected failure");
+  EXPECT_FATAL_FAILURE(FAIL() << "expected failure", "expected failure");
 }
 
 #ifdef __BORLANDC__
 // Silences warnings: "Condition is always true", "Unreachable code"
-# pragma option push -w-ccc -w-rch
+#pragma option push -w-ccc -w-rch
 #endif
 
 TEST(StreamingAssertionsTest, Truth) {
@@ -6505,7 +6440,7 @@ TEST(StreamingAssertionsTest, Truth2) {
 
 #ifdef __BORLANDC__
 // Restores warnings after previous "#pragma option push" suppressed them
-# pragma option pop
+#pragma option pop
 #endif
 
 TEST(StreamingAssertionsTest, IntegerEquals) {
@@ -6576,28 +6511,32 @@ TEST(StreamingAssertionsTest, FloatingPointEquals) {
 TEST(StreamingAssertionsTest, Throw) {
   EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
   ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
-                       "expected failure", "expected failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool)
+                              << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool)
+                           << "expected failure",
+                       "expected failure");
 }
 
 TEST(StreamingAssertionsTest, NoThrow) {
   EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
   ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
-                       "expected failure", "expected failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger())
+                              << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << "expected failure",
+                       "expected failure");
 }
 
 TEST(StreamingAssertionsTest, AnyThrow) {
   EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
   ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
-  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
-                          "expected failure", "expected failure");
-  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
-                       "expected failure", "expected failure");
+  EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing())
+                              << "expected failure",
+                          "expected failure");
+  EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << "expected failure",
+                       "expected failure");
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -6605,65 +6544,65 @@ TEST(StreamingAssertionsTest, AnyThrow) {
 // Tests that Google Test correctly decides whether to use colors in the output.
 
 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
-  GTEST_FLAG(color) = "yes";
+  GTEST_FLAG_SET(color, "yes");
 
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  SetEnv("TERM", "xterm");             // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));   // Stdout is a TTY.
   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
 
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  SetEnv("TERM", "dumb");              // TERM doesn't support colors.
+  EXPECT_TRUE(ShouldUseColor(true));   // Stdout is a TTY.
   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
 }
 
 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
   SetEnv("TERM", "dumb");  // TERM doesn't support colors.
 
-  GTEST_FLAG(color) = "True";
+  GTEST_FLAG_SET(color, "True");
   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
 
-  GTEST_FLAG(color) = "t";
+  GTEST_FLAG_SET(color, "t");
   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
 
-  GTEST_FLAG(color) = "1";
+  GTEST_FLAG_SET(color, "1");
   EXPECT_TRUE(ShouldUseColor(false));  // Stdout is not a TTY.
 }
 
 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
-  GTEST_FLAG(color) = "no";
+  GTEST_FLAG_SET(color, "no");
 
-  SetEnv("TERM", "xterm");  // TERM supports colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  SetEnv("TERM", "xterm");              // TERM supports colors.
+  EXPECT_FALSE(ShouldUseColor(true));   // Stdout is a TTY.
   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
 
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
-  EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
+  SetEnv("TERM", "dumb");               // TERM doesn't support colors.
+  EXPECT_FALSE(ShouldUseColor(true));   // Stdout is a TTY.
   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
 }
 
 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
   SetEnv("TERM", "xterm");  // TERM supports colors.
 
-  GTEST_FLAG(color) = "F";
+  GTEST_FLAG_SET(color, "F");
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  GTEST_FLAG(color) = "0";
+  GTEST_FLAG_SET(color, "0");
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  GTEST_FLAG(color) = "unknown";
+  GTEST_FLAG_SET(color, "unknown");
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 }
 
 TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
-  GTEST_FLAG(color) = "auto";
+  GTEST_FLAG_SET(color, "auto");
 
-  SetEnv("TERM", "xterm");  // TERM supports colors.
+  SetEnv("TERM", "xterm");              // TERM supports colors.
   EXPECT_FALSE(ShouldUseColor(false));  // Stdout is not a TTY.
   EXPECT_TRUE(ShouldUseColor(true));    // Stdout is a TTY.
 }
 
 TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
-  GTEST_FLAG(color) = "auto";
+  GTEST_FLAG_SET(color, "auto");
 
 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
   // On Windows, we ignore the TERM variable as it's usually not set.
@@ -6680,49 +6619,52 @@ TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
   // On non-Windows platforms, we rely on TERM to determine if the
   // terminal supports colors.
 
-  SetEnv("TERM", "dumb");  // TERM doesn't support colors.
+  SetEnv("TERM", "dumb");              // TERM doesn't support colors.
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "emacs");  // TERM doesn't support colors.
+  SetEnv("TERM", "emacs");             // TERM doesn't support colors.
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "vt100");  // TERM doesn't support colors.
+  SetEnv("TERM", "vt100");             // TERM doesn't support colors.
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "xterm-mono");  // TERM doesn't support colors.
+  SetEnv("TERM", "xterm-mono");        // TERM doesn't support colors.
   EXPECT_FALSE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "xterm");  // TERM supports colors.
+  SetEnv("TERM", "xterm");            // TERM supports colors.
+  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+
+  SetEnv("TERM", "xterm-color");      // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "xterm-color");  // TERM supports colors.
+  SetEnv("TERM", "xterm-kitty");      // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "xterm-256color");  // TERM supports colors.
+  SetEnv("TERM", "xterm-256color");   // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "screen");  // TERM supports colors.
+  SetEnv("TERM", "screen");           // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
   SetEnv("TERM", "screen-256color");  // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "tmux");  // TERM supports colors.
+  SetEnv("TERM", "tmux");             // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "tmux-256color");  // TERM supports colors.
+  SetEnv("TERM", "tmux-256color");    // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "rxvt-unicode");  // TERM supports colors.
+  SetEnv("TERM", "rxvt-unicode");     // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
   SetEnv("TERM", "rxvt-unicode-256color");  // TERM supports colors.
-  EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
+  EXPECT_TRUE(ShouldUseColor(true));        // Stdout is a TTY.
 
-  SetEnv("TERM", "linux");  // TERM supports colors.
+  SetEnv("TERM", "linux");            // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 
-  SetEnv("TERM", "cygwin");  // TERM supports colors.
+  SetEnv("TERM", "cygwin");           // TERM supports colors.
   EXPECT_TRUE(ShouldUseColor(true));  // Stdout is a TTY.
 #endif  // GTEST_OS_WINDOWS
 }
@@ -6842,12 +6784,10 @@ class TestListener : public EmptyTestEventListener {
  public:
   TestListener() : on_start_counter_(nullptr), is_destroyed_(nullptr) {}
   TestListener(int* on_start_counter, bool* is_destroyed)
-      : on_start_counter_(on_start_counter),
-        is_destroyed_(is_destroyed) {}
+      : on_start_counter_(on_start_counter), is_destroyed_(is_destroyed) {}
 
   ~TestListener() override {
-    if (is_destroyed_)
-      *is_destroyed_ = true;
+    if (is_destroyed_) *is_destroyed_ = true;
   }
 
  protected:
@@ -6904,8 +6844,8 @@ TEST(TestEventListenersTest, Append) {
   {
     TestEventListeners listeners;
     listeners.Append(listener);
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
+    TestEventListenersAccessor::GetRepeater(&listeners)
+        ->OnTestProgramStart(*UnitTest::GetInstance());
     EXPECT_EQ(1, on_start_counter);
   }
   EXPECT_TRUE(is_destroyed);
@@ -6948,7 +6888,8 @@ class SequenceTestingListener : public EmptyTestEventListener {
   std::vector<std::string>* vector_;
   const char* const id_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
+  SequenceTestingListener(const SequenceTestingListener&) = delete;
+  SequenceTestingListener& operator=(const SequenceTestingListener&) = delete;
 };
 
 TEST(EventListenerTest, AppendKeepsOrder) {
@@ -6958,32 +6899,32 @@ TEST(EventListenerTest, AppendKeepsOrder) {
   listeners.Append(new SequenceTestingListener(&vec, "2nd"));
   listeners.Append(new SequenceTestingListener(&vec, "3rd"));
 
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
   ASSERT_EQ(3U, vec.size());
   EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
   EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
   EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
 
   vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramEnd(*UnitTest::GetInstance());
   ASSERT_EQ(3U, vec.size());
   EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
   EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
   EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
 
   vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
-      *UnitTest::GetInstance(), 0);
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestIterationStart(*UnitTest::GetInstance(), 0);
   ASSERT_EQ(3U, vec.size());
   EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
   EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
   EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
 
   vec.clear();
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
-      *UnitTest::GetInstance(), 0);
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestIterationEnd(*UnitTest::GetInstance(), 0);
   ASSERT_EQ(3U, vec.size());
   EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
   EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
@@ -7003,8 +6944,8 @@ TEST(TestEventListenersTest, Release) {
     TestEventListeners listeners;
     listeners.Append(listener);
     EXPECT_EQ(listener, listeners.Release(listener));
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
+    TestEventListenersAccessor::GetRepeater(&listeners)
+        ->OnTestProgramStart(*UnitTest::GetInstance());
     EXPECT_TRUE(listeners.Release(listener) == nullptr);
   }
   EXPECT_EQ(0, on_start_counter);
@@ -7022,17 +6963,20 @@ TEST(EventListenerTest, SuppressEventForwarding) {
   ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
   TestEventListenersAccessor::SuppressEventForwarding(&listeners);
   ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
   EXPECT_EQ(0, on_start_counter);
 }
 
 // Tests that events generated by Google Test are not forwarded in
 // death test subprocesses.
 TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
-  EXPECT_DEATH_IF_SUPPORTED({
-      GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
-          *GetUnitTestImpl()->listeners())) << "expected failure";},
+  EXPECT_DEATH_IF_SUPPORTED(
+      {
+        GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
+            *GetUnitTestImpl()->listeners()))
+            << "expected failure";
+      },
       "expected failure");
 }
 
@@ -7049,8 +6993,8 @@ TEST(EventListenerTest, default_result_printer) {
 
   EXPECT_EQ(listener, listeners.default_result_printer());
 
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
 
   EXPECT_EQ(1, on_start_counter);
 
@@ -7063,8 +7007,8 @@ TEST(EventListenerTest, default_result_printer) {
 
   // After broadcasting an event the counter is still the same, indicating
   // the listener is not in the list anymore.
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
   EXPECT_EQ(1, on_start_counter);
 }
 
@@ -7086,8 +7030,8 @@ TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
     EXPECT_FALSE(is_destroyed);
 
     // Broadcasting events now should not affect default_result_printer.
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
+    TestEventListenersAccessor::GetRepeater(&listeners)
+        ->OnTestProgramStart(*UnitTest::GetInstance());
     EXPECT_EQ(0, on_start_counter);
   }
   // Destroying the list should not affect the listener now, too.
@@ -7108,8 +7052,8 @@ TEST(EventListenerTest, default_xml_generator) {
 
   EXPECT_EQ(listener, listeners.default_xml_generator());
 
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
 
   EXPECT_EQ(1, on_start_counter);
 
@@ -7122,8 +7066,8 @@ TEST(EventListenerTest, default_xml_generator) {
 
   // After broadcasting an event the counter is still the same, indicating
   // the listener is not in the list anymore.
-  TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-      *UnitTest::GetInstance());
+  TestEventListenersAccessor::GetRepeater(&listeners)
+      ->OnTestProgramStart(*UnitTest::GetInstance());
   EXPECT_EQ(1, on_start_counter);
 }
 
@@ -7145,8 +7089,8 @@ TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
     EXPECT_FALSE(is_destroyed);
 
     // Broadcasting events now should not affect default_xml_generator.
-    TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
-        *UnitTest::GetInstance());
+    TestEventListenersAccessor::GetRepeater(&listeners)
+        ->OnTestProgramStart(*UnitTest::GetInstance());
     EXPECT_EQ(0, on_start_counter);
   }
   // Destroying the list should not affect the listener now, too.
@@ -7154,7 +7098,7 @@ TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
   delete listener;
 }
 
-// Sanity tests to ensure that the alternative, verbose spellings of
+// Tests to ensure that the alternative, verbose spellings of
 // some of the macros work.  We don't test them thoroughly as that
 // would be quite involved.  Since their implementations are
 // straightforward, and they are rarely used, we'll just rely on the
@@ -7234,28 +7178,26 @@ struct IncompleteType;
 // Tests that HasDebugStringAndShortDebugString<T>::value is a compile-time
 // constant.
 TEST(HasDebugStringAndShortDebugStringTest, ValueIsCompileTimeConstant) {
-  GTEST_COMPILE_ASSERT_(
-      HasDebugStringAndShortDebugString<HasDebugStringMethods>::value,
-      const_true);
-  GTEST_COMPILE_ASSERT_(
+  static_assert(HasDebugStringAndShortDebugString<HasDebugStringMethods>::value,
+                "const_true");
+  static_assert(
       HasDebugStringAndShortDebugString<InheritsDebugStringMethods>::value,
-      const_true);
-  GTEST_COMPILE_ASSERT_(HasDebugStringAndShortDebugString<
-                            const InheritsDebugStringMethods>::value,
-                        const_true);
-  GTEST_COMPILE_ASSERT_(
+      "const_true");
+  static_assert(HasDebugStringAndShortDebugString<
+                    const InheritsDebugStringMethods>::value,
+                "const_true");
+  static_assert(
       !HasDebugStringAndShortDebugString<WrongTypeDebugStringMethod>::value,
-      const_false);
-  GTEST_COMPILE_ASSERT_(
+      "const_false");
+  static_assert(
       !HasDebugStringAndShortDebugString<NotConstDebugStringMethod>::value,
-      const_false);
-  GTEST_COMPILE_ASSERT_(
+      "const_false");
+  static_assert(
       !HasDebugStringAndShortDebugString<MissingDebugStringMethod>::value,
-      const_false);
-  GTEST_COMPILE_ASSERT_(
-      !HasDebugStringAndShortDebugString<IncompleteType>::value, const_false);
-  GTEST_COMPILE_ASSERT_(!HasDebugStringAndShortDebugString<int>::value,
-                        const_false);
+      "const_false");
+  static_assert(!HasDebugStringAndShortDebugString<IncompleteType>::value,
+                "const_false");
+  static_assert(!HasDebugStringAndShortDebugString<int>::value, "const_false");
 }
 
 // Tests that HasDebugStringAndShortDebugString<T>::value is true when T has
@@ -7306,7 +7248,6 @@ TEST(GTestReferenceToConstTest, Works) {
   TestGTestReferenceToConst<const std::string&, const std::string&>();
 }
 
-
 // Tests IsContainerTest.
 
 class NonContainer {};
@@ -7318,10 +7259,9 @@ TEST(IsContainerTestTest, WorksForNonContainer) {
 }
 
 TEST(IsContainerTestTest, WorksForContainer) {
+  EXPECT_EQ(sizeof(IsContainer), sizeof(IsContainerTest<std::vector<bool>>(0)));
   EXPECT_EQ(sizeof(IsContainer),
-            sizeof(IsContainerTest<std::vector<bool> >(0)));
-  EXPECT_EQ(sizeof(IsContainer),
-            sizeof(IsContainerTest<std::map<int, double> >(0)));
+            sizeof(IsContainerTest<std::map<int, double>>(0)));
 }
 
 struct ConstOnlyContainerWithPointerIterator {
@@ -7370,8 +7310,8 @@ TEST(ArrayEqTest, WorksForDegeneratedArrays) {
 
 TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
   // Note that a and b are distinct but compatible types.
-  const int a[] = { 0, 1 };
-  long b[] = { 0, 1 };
+  const int a[] = {0, 1};
+  long b[] = {0, 1};
   EXPECT_TRUE(ArrayEq(a, b));
   EXPECT_TRUE(ArrayEq(a, 2, b));
 
@@ -7381,9 +7321,9 @@ TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
 }
 
 TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
-  const char a[][3] = { "hi", "lo" };
-  const char b[][3] = { "hi", "lo" };
-  const char c[][3] = { "hi", "li" };
+  const char a[][3] = {"hi", "lo"};
+  const char b[][3] = {"hi", "lo"};
+  const char c[][3] = {"hi", "li"};
 
   EXPECT_TRUE(ArrayEq(a, b));
   EXPECT_TRUE(ArrayEq(a, 2, b));
@@ -7401,11 +7341,11 @@ TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
 }
 
 TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
-  int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
-  const int b[2] = { 2, 3 };
+  int a[][2] = {{0, 1}, {2, 3}, {4, 5}};
+  const int b[2] = {2, 3};
   EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
 
-  const int c[2] = { 6, 7 };
+  const int c[2] = {6, 7};
   EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
 }
 
@@ -7431,7 +7371,7 @@ TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
 }
 
 TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
-  const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
+  const int a[2][3] = {{0, 1, 2}, {3, 4, 5}};
   int b[2][3];
 #ifndef __BORLANDC__  // C++Builder cannot compile some array size deductions.
   CopyArray(a, &b);
@@ -7446,7 +7386,7 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
 // Tests NativeArray.
 
 TEST(NativeArrayTest, ConstructorFromArrayWorks) {
-  const int a[3] = { 0, 1, 2 };
+  const int a[3] = {0, 1, 2};
   NativeArray<int> na(a, 3, RelationToSourceReference());
   EXPECT_EQ(3U, na.size());
   EXPECT_EQ(a, na.begin());
@@ -7476,7 +7416,7 @@ TEST(NativeArrayTest, TypeMembersAreCorrect) {
 }
 
 TEST(NativeArrayTest, MethodsWork) {
-  const int a[3] = { 0, 1, 2 };
+  const int a[3] = {0, 1, 2};
   NativeArray<int> na(a, 3, RelationToSourceCopy());
   ASSERT_EQ(3U, na.size());
   EXPECT_EQ(3, na.end() - na.begin());
@@ -7495,14 +7435,14 @@ TEST(NativeArrayTest, MethodsWork) {
   NativeArray<int> na2(a, 3, RelationToSourceReference());
   EXPECT_TRUE(na == na2);
 
-  const int b1[3] = { 0, 1, 1 };
-  const int b2[4] = { 0, 1, 2, 3 };
+  const int b1[3] = {0, 1, 1};
+  const int b2[4] = {0, 1, 2, 3};
   EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
   EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
 }
 
 TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
-  const char a[2][3] = { "hi", "lo" };
+  const char a[2][3] = {"hi", "lo"};
   NativeArray<char[3]> na(a, 2, RelationToSourceReference());
   ASSERT_EQ(2U, na.size());
   EXPECT_EQ(a, na.begin());
@@ -7767,7 +7707,7 @@ auto* dynamic_test = testing::RegisterTest(
     __LINE__, []() -> DynamicUnitTestFixture* { return new DynamicTest; });
 
 TEST(RegisterTest, WasRegistered) {
-  auto* unittest = testing::UnitTest::GetInstance();
+  const auto& unittest = testing::UnitTest::GetInstance();
   for (int i = 0; i < unittest->total_test_suite_count(); ++i) {
     auto* tests = unittest->GetTestSuite(i);
     if (tests->name() != std::string("DynamicUnitTestFixture")) continue;
@@ -7782,3 +7722,35 @@ TEST(RegisterTest, WasRegistered) {
 
   FAIL() << "Didn't find the test!";
 }
+
+// Test that the pattern globbing algorithm is linear. If not, this test should
+// time out.
+TEST(PatternGlobbingTest, MatchesFilterLinearRuntime) {
+  std::string name(100, 'a');  // Construct the string (a^100)b
+  name.push_back('b');
+
+  std::string pattern;  // Construct the string ((a*)^100)b
+  for (int i = 0; i < 100; ++i) {
+    pattern.append("a*");
+  }
+  pattern.push_back('b');
+
+  EXPECT_TRUE(
+      testing::internal::UnitTestOptions::MatchesFilter(name, pattern.c_str()));
+}
+
+TEST(PatternGlobbingTest, MatchesFilterWithMultiplePatterns) {
+  const std::string name = "aaaa";
+  EXPECT_TRUE(testing::internal::UnitTestOptions::MatchesFilter(name, "a*"));
+  EXPECT_TRUE(testing::internal::UnitTestOptions::MatchesFilter(name, "a*:"));
+  EXPECT_FALSE(testing::internal::UnitTestOptions::MatchesFilter(name, "ab"));
+  EXPECT_FALSE(testing::internal::UnitTestOptions::MatchesFilter(name, "ab:"));
+  EXPECT_TRUE(testing::internal::UnitTestOptions::MatchesFilter(name, "ab:a*"));
+}
+
+TEST(PatternGlobbingTest, MatchesFilterEdgeCases) {
+  EXPECT_FALSE(testing::internal::UnitTestOptions::MatchesFilter("", "*a"));
+  EXPECT_TRUE(testing::internal::UnitTestOptions::MatchesFilter("", "*"));
+  EXPECT_FALSE(testing::internal::UnitTestOptions::MatchesFilter("a", ""));
+  EXPECT_TRUE(testing::internal::UnitTestOptions::MatchesFilter("", ""));
+}
diff --git a/googletest/googletest/test/gtest_xml_outfile2_test_.cc b/googletest/googletest/test/gtest_xml_outfile2_test_.cc
index f9a2a6e9846ddcd95dbdb88d8c74d07c4bc9dffb..f743b31b7206ecc480aeac5f3564e1811458ecec 100644
--- a/googletest/googletest/test/gtest_xml_outfile2_test_.cc
+++ b/googletest/googletest/test/gtest_xml_outfile2_test_.cc
@@ -39,5 +39,7 @@ class PropertyTwo : public testing::Test {
 };
 
 TEST_F(PropertyTwo, TestSomeProperties) {
-  RecordProperty("TestSomeProperty", 2);
+  // Validate we can write an unsigned size_t as a property
+  size_t prop_two = 2;
+  RecordProperty("TestSomeProperty", prop_two);
 }
diff --git a/googletest/googletest/test/gtest_xml_outfiles_test.py b/googletest/googletest/test/gtest_xml_outfiles_test.py
index ac66feb66719e62cfa16c79a17f63de990f277c1..c129e64b90515ffa404a9ac505e0366bd109e013 100644
--- a/googletest/googletest/test/gtest_xml_outfiles_test.py
+++ b/googletest/googletest/test/gtest_xml_outfiles_test.py
@@ -33,8 +33,8 @@
 
 import os
 from xml.dom import minidom, Node
-import gtest_test_utils
-import gtest_xml_test_utils
+from googletest.test import gtest_test_utils
+from googletest.test import gtest_xml_test_utils
 
 GTEST_OUTPUT_SUBDIR = "xml_outfiles"
 GTEST_OUTPUT_1_TEST = "gtest_xml_outfile1_test_"
@@ -43,7 +43,7 @@ GTEST_OUTPUT_2_TEST = "gtest_xml_outfile2_test_"
 EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
   <testsuite name="PropertyOne" tests="1" failures="0" skipped="0" disabled="0" errors="0" time="*" timestamp="*">
-    <testcase name="TestSomeProperties" status="run" result="completed" time="*" timestamp="*" classname="PropertyOne">
+    <testcase name="TestSomeProperties" file="gtest_xml_outfile1_test_.cc" line="41" status="run" result="completed" time="*" timestamp="*" classname="PropertyOne">
       <properties>
         <property name="SetUpProp" value="1"/>
         <property name="TestSomeProperty" value="1"/>
@@ -57,7 +57,7 @@ EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
 EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
   <testsuite name="PropertyTwo" tests="1" failures="0" skipped="0" disabled="0" errors="0" time="*" timestamp="*">
-    <testcase name="TestSomeProperties" status="run" result="completed" time="*" timestamp="*" classname="PropertyTwo">
+    <testcase name="TestSomeProperties" file="gtest_xml_outfile2_test_.cc" line="41" status="run" result="completed" time="*" timestamp="*" classname="PropertyTwo">
       <properties>
         <property name="SetUpProp" value="2"/>
         <property name="TestSomeProperty" value="2"/>
diff --git a/googletest/googletest/test/gtest_xml_output_unittest.py b/googletest/googletest/test/gtest_xml_output_unittest.py
index eade7aac88f59e6bb6f5ba341828bae46fcd006f..e1b7f1fc83d44501ba3b5f2d4ac5993422464a9d 100644
--- a/googletest/googletest/test/gtest_xml_output_unittest.py
+++ b/googletest/googletest/test/gtest_xml_output_unittest.py
@@ -38,8 +38,8 @@ import re
 import sys
 from xml.dom import minidom, Node
 
-import gtest_test_utils
-import gtest_xml_test_utils
+from googletest.test import gtest_test_utils
+from googletest.test import gtest_xml_test_utils
 
 GTEST_FILTER_FLAG = '--gtest_filter'
 GTEST_LIST_TESTS_FLAG = '--gtest_list_tests'
@@ -67,10 +67,10 @@ else:
 EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="26" failures="5" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
   <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="Succeeds" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
+    <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
   </testsuite>
   <testsuite name="FailedTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="Fails" status="run" result="completed" time="*" timestamp="*" classname="FailedTest">
+    <testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="59" status="run" result="completed" time="*" timestamp="*" classname="FailedTest">
       <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A;  1&#x0A;  2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 Expected equality of these values:
   1
@@ -78,8 +78,8 @@ Expected equality of these values:
     </testcase>
   </testsuite>
   <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="Succeeds" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest"/>
-    <testcase name="Fails" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest">
+    <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="86" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest"/>
+    <testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="91" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest">
       <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A;  1&#x0A;  2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 Expected equality of these values:
   1
@@ -89,35 +89,35 @@ Expected equality of these values:
   2
   3%(stack)s]]></failure>
     </testcase>
-    <testcase name="DISABLED_test" status="notrun" result="suppressed" time="*" timestamp="*" classname="MixedResultTest"/>
+    <testcase name="DISABLED_test" file="gtest_xml_output_unittest_.cc" line="96" status="notrun" result="suppressed" time="*" timestamp="*" classname="MixedResultTest"/>
   </testsuite>
   <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="OutputsCData" status="run" result="completed" time="*" timestamp="*" classname="XmlQuotingTest">
+    <testcase name="OutputsCData" file="gtest_xml_output_unittest_.cc" line="100" status="run" result="completed" time="*" timestamp="*" classname="XmlQuotingTest">
       <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 Failed
 XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>
     </testcase>
   </testsuite>
   <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="InvalidCharactersInMessage" status="run" result="completed" time="*" timestamp="*" classname="InvalidCharactersTest">
+    <testcase name="InvalidCharactersInMessage" file="gtest_xml_output_unittest_.cc" line="107" status="run" result="completed" time="*" timestamp="*" classname="InvalidCharactersTest">
       <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 Failed
 Invalid characters in brackets []%(stack)s]]></failure>
     </testcase>
   </testsuite>
   <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="DISABLED_test_not_run" status="notrun" result="suppressed" time="*" timestamp="*" classname="DisabledTest"/>
+    <testcase name="DISABLED_test_not_run" file="gtest_xml_output_unittest_.cc" line="66" status="notrun" result="suppressed" time="*" timestamp="*" classname="DisabledTest"/>
   </testsuite>
   <testsuite name="SkippedTest" tests="3" failures="1" disabled="0" skipped="2" errors="0" time="*" timestamp="*">
-    <testcase name="Skipped" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest">
+    <testcase name="Skipped" status="run" file="gtest_xml_output_unittest_.cc" line="73" result="skipped" time="*" timestamp="*" classname="SkippedTest">
       <skipped message="gtest_xml_output_unittest_.cc:*&#x0A;"><![CDATA[gtest_xml_output_unittest_.cc:*
 %(stack)s]]></skipped>
     </testcase>
-    <testcase name="SkippedWithMessage" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest">
+    <testcase name="SkippedWithMessage" file="gtest_xml_output_unittest_.cc" line="77" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest">
       <skipped message="gtest_xml_output_unittest_.cc:*&#x0A;It is good practice to tell why you skip a test."><![CDATA[gtest_xml_output_unittest_.cc:*
 It is good practice to tell why you skip a test.%(stack)s]]></skipped>
     </testcase>
-    <testcase name="SkippedAfterFailure" status="run" result="completed" time="*" timestamp="*" classname="SkippedTest">
+    <testcase name="SkippedAfterFailure" file="gtest_xml_output_unittest_.cc" line="81" status="run" result="completed" time="*" timestamp="*" classname="SkippedTest">
       <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A;  1&#x0A;  2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
 Expected equality of these values:
   1
@@ -128,63 +128,63 @@ It is good practice to tell why you skip a test.%(stack)s]]></skipped>
 
   </testsuite>
   <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
-    <testcase name="OneProperty" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+    <testcase name="OneProperty" file="gtest_xml_output_unittest_.cc" line="119" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
       <properties>
         <property name="key_1" value="1"/>
       </properties>
     </testcase>
-    <testcase name="IntValuedProperty" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+    <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="123" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
       <properties>
         <property name="key_int" value="1"/>
       </properties>
     </testcase>
-    <testcase name="ThreeProperties" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+    <testcase name="ThreeProperties" file="gtest_xml_output_unittest_.cc" line="127" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
       <properties>
         <property name="key_1" value="1"/>
         <property name="key_2" value="2"/>
         <property name="key_3" value="3"/>
       </properties>
     </testcase>
-    <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+    <testcase name="TwoValuesForOneKeyUsesLastValue" file="gtest_xml_output_unittest_.cc" line="133" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
       <properties>
         <property name="key_1" value="2"/>
       </properties>
     </testcase>
   </testsuite>
   <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-     <testcase name="RecordProperty" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+     <testcase name="RecordProperty" file="gtest_xml_output_unittest_.cc" line="138" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
        <properties>
          <property name="key" value="1"/>
        </properties>
      </testcase>
-     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+     <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" file="gtest_xml_output_unittest_.cc" line="151" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
        <properties>
          <property name="key_for_utility_int" value="1"/>
        </properties>
      </testcase>
-     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+     <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" file="gtest_xml_output_unittest_.cc" line="155" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
        <properties>
          <property name="key_for_utility_string" value="1"/>
        </properties>
      </testcase>
   </testsuite>
   <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
-    <testcase name="HasValueParamAttribute/1" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
-    <testcase name="AnotherTestThatHasValueParamAttribute/0" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
-    <testcase name="AnotherTestThatHasValueParamAttribute/1" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+    <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="162" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+    <testcase name="HasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="162" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="163" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+    <testcase name="AnotherTestThatHasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="163" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
   </testsuite>
   <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" />
+    <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="171" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" />
   </testsuite>
   <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" />
+    <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="171" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" />
   </testsuite>
   <testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
+    <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="178" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
   </testsuite>
   <testsuite name="Single/TypeParameterizedTestSuite/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasTypeParamAttribute" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" />
+    <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="178" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" />
   </testsuite>
 </testsuites>""" % {
     'stack': STACK_TRACE_TEMPLATE
@@ -195,24 +195,24 @@ EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
             timestamp="*" name="AllTests" ad_hoc_property="42">
   <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0"
              errors="0" time="*" timestamp="*">
-    <testcase name="Succeeds" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
+    <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
   </testsuite>
 </testsuites>"""
 
 EXPECTED_SHARDED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="3" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
   <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="Succeeds" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
+    <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
   </testsuite>
   <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
-    <testcase name="IntValuedProperty" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+    <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="123" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
       <properties>
         <property name="key_int" value="1"/>
       </properties>
     </testcase>
   </testsuite>
   <testsuite name="Single/ValueParamTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
-    <testcase name="HasValueParamAttribute/0" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+    <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="162" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
   </testsuite>
 </testsuites>"""
 
diff --git a/googletest/googletest/test/gtest_xml_output_unittest_.cc b/googletest/googletest/test/gtest_xml_output_unittest_.cc
index c0036aaef9df27654ae6a6ce1ded07642ca2d391..4bdb0c7e8acc71abfb8efd06f4dd7ff1b74d9c14 100644
--- a/googletest/googletest/test/gtest_xml_output_unittest_.cc
+++ b/googletest/googletest/test/gtest_xml_output_unittest_.cc
@@ -35,18 +35,18 @@
 //
 // This program will be invoked from a Python unit test.  Don't run it
 // directly.
+// clang-format off
 
 #include "gtest/gtest.h"
 
 using ::testing::InitGoogleTest;
+using ::testing::Test;
 using ::testing::TestEventListeners;
 using ::testing::TestWithParam;
 using ::testing::UnitTest;
-using ::testing::Test;
 using ::testing::Values;
 
-class SuccessfulTest : public Test {
-};
+class SuccessfulTest : public Test {};
 
 TEST_F(SuccessfulTest, Succeeds) {
   SUCCEED() << "This is a success.";
@@ -191,3 +191,5 @@ int main(int argc, char** argv) {
   testing::Test::RecordProperty("ad_hoc_property", "42");
   return RUN_ALL_TESTS();
 }
+
+// clang-format on
diff --git a/googletest/googletest/test/gtest_xml_test_utils.py b/googletest/googletest/test/gtest_xml_test_utils.py
index ec42c62c3b0593b3df0c0ac42880dcb3a6b8faf8..c6fb9f4438cc2979260be28b23e15bd37485d22c 100644
--- a/googletest/googletest/test/gtest_xml_test_utils.py
+++ b/googletest/googletest/test/gtest_xml_test_utils.py
@@ -31,7 +31,7 @@
 
 import re
 from xml.dom import minidom, Node
-import gtest_test_utils
+from googletest.test import gtest_test_utils
 
 GTEST_DEFAULT_OUTPUT_FILE = 'test_detail.xml'
 
@@ -170,6 +170,10 @@ class GTestXMLTestCase(gtest_test_utils.TestCase):
     *  The stack traces are removed.
     """
 
+    if element.tagName == 'testcase':
+      source_file = element.getAttributeNode('file')
+      if source_file:
+        source_file.value = re.sub(r'^.*[/\\](.*)', '\\1', source_file.value)
     if element.tagName in ('testsuites', 'testsuite', 'testcase'):
       timestamp = element.getAttributeNode('timestamp')
       timestamp.value = re.sub(r'^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d\d\d$',
diff --git a/googletest/googletest/test/production.h b/googletest/googletest/test/production.h
index 41a547225423d8331a649da95f28e1fd3c5ae774..4dec8d46e247490d6b1666d870c11144d3085048 100644
--- a/googletest/googletest/test/production.h
+++ b/googletest/googletest/test/production.h
@@ -46,6 +46,7 @@ class PrivateCode {
   PrivateCode();
 
   int x() const { return x_; }
+
  private:
   void set_x(int an_x) { x_ = an_x; }
   int x_;
diff --git a/interface_sdk/api/@ohos.application.DataShareExtensionAbility.d.ts b/interface_sdk/api/@ohos.application.DataShareExtensionAbility.d.ts
index 72557ae3ec05191482ad8e7a02a6a4b59a54d2a4..4dc30e5505a39452b36c2af1f660fe9ae539a23c 100644
--- a/interface_sdk/api/@ohos.application.DataShareExtensionAbility.d.ts
+++ b/interface_sdk/api/@ohos.application.DataShareExtensionAbility.d.ts
@@ -28,6 +28,7 @@ import dataShare from './@ohos.data.dataShare';
 /**
    * Struct for a batch update operation.
    *
+   * @typedef { dataShare.UpdateOperation }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Provider
    * @systemapi
    * @stagemodelonly
diff --git a/interface_sdk/api/@ohos.data.DataShareResultSet.d.ts b/interface_sdk/api/@ohos.data.DataShareResultSet.d.ts
index 0b831f95430e3c65d4242089c9784782dc0ceef6..e41a4cb295679944379f0832ee1fb5a6eb871856 100644
--- a/interface_sdk/api/@ohos.data.DataShareResultSet.d.ts
+++ b/interface_sdk/api/@ohos.data.DataShareResultSet.d.ts
@@ -95,6 +95,7 @@ export default interface DataShareResultSet {
    * The column or key names are returned as a string array, in which the strings are in the same order
    * as the columns or keys in the result set.
    *
+   * @type { Array<string> }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Core
    * @systemapi
    * @StageModelOnly
@@ -106,6 +107,7 @@ export default interface DataShareResultSet {
    * Obtains the number of columns or keys in the result set.
    * The returned number is equal to the length of the string array returned by the columnCount method.
    *
+   * @type { number }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Core
    * @systemapi
    * @StageModelOnly
@@ -116,6 +118,7 @@ export default interface DataShareResultSet {
   /**
    * Obtains the number of rows in the result set.
    *
+   * @type { number }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Core
    * @systemapi
    * @StageModelOnly
@@ -127,6 +130,7 @@ export default interface DataShareResultSet {
    * Checks whether the current result set is closed.
    * If the result set is closed by calling the close method, true will be returned.
    *
+   * @type { boolean }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Core
    * @systemapi
    * @StageModelOnly
diff --git a/interface_sdk/api/@ohos.data.ValuesBucket.d.ts b/interface_sdk/api/@ohos.data.ValuesBucket.d.ts
index cae9944357ea3fb3ed62adb4f27202b1334e6e7e..a3951e9089e81abbfd92db2e99d3d96cae236371 100644
--- a/interface_sdk/api/@ohos.data.ValuesBucket.d.ts
+++ b/interface_sdk/api/@ohos.data.ValuesBucket.d.ts
@@ -25,11 +25,21 @@
  * @stagemodelonly
  * @since 10
  */
+/**
+ * Indicates possible value types
+ *
+ * @typedef { number | string | boolean }
+ * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+ * @stagemodelonly
+ * @crossplatform
+ * @since 12
+ */
 export type ValueType = number | string | boolean;
 
 /**
  * Values in buckets are stored in key-value pairs
  *
+ * @typedef { Record<string, ValueType | Uint8Array | null> }
  * @syscap SystemCapability.DistributedDataManager.DataShare.Core
  * @stagemodelonly
  * @since 10
diff --git a/interface_sdk/api/@ohos.data.cloudExtension.d.ts b/interface_sdk/api/@ohos.data.cloudExtension.d.ts
index 51c300aed92aa8ca6709ef0a2e3dfb65cf7b5202..d983c4773aeb184c7cffa71d4470f2b7f2195f01 100644
--- a/interface_sdk/api/@ohos.data.cloudExtension.d.ts
+++ b/interface_sdk/api/@ohos.data.cloudExtension.d.ts
@@ -63,6 +63,7 @@ declare namespace cloudExtension {
   /**
    * Indicates cloud assets in one column.
    *
+   * @typedef { Array<CloudAsset> } CloudAssets
    * @syscap SystemCapability.DistributedDataManager.CloudSync.Server
    * @systemapi
    * @since 11
@@ -72,6 +73,7 @@ declare namespace cloudExtension {
   /**
    * Indicates possible cloud types.
    *
+   * @typedef { null | number | string | boolean | Uint8Array | CloudAsset | CloudAssets } CloudType
    * @syscap SystemCapability.DistributedDataManager.CloudSync.Server
    * @systemapi
    * @since 11
diff --git a/interface_sdk/api/@ohos.data.commonType.d.ts b/interface_sdk/api/@ohos.data.commonType.d.ts
index 112b97db21ca0cad0f62ec1e849ea6011868538d..cb99620242c6d9964c610848c1f8bdbb5c9fbcd4 100644
--- a/interface_sdk/api/@ohos.data.commonType.d.ts
+++ b/interface_sdk/api/@ohos.data.commonType.d.ts
@@ -107,14 +107,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The name of asset.
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    name: string | undefined;
+    name: string;
 
     /**
      * The uri of asset.
@@ -124,15 +117,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The uri of asset.
-     *
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    uri: string | undefined;
+    uri: string;
 
     /**
      * The path of asset.
@@ -142,15 +127,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The path of asset.
-     *
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    path: string | undefined;
+    path: string;
 
     /**
      * The created time of asset.
@@ -160,15 +137,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The created time of asset.
-     *
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    createTime: string | undefined;
+    createTime: string;
 
     /**
      * The modified time of asset. If this field changes, the asset is considered to have changed.
@@ -178,15 +147,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The modified time of asset. If this field changes, the asset is considered to have changed.
-     *
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    modifyTime: string | undefined;
+    modifyTime: string;
 
     /**
      * The size of asset. If this field changes, the asset is considered to have changed.
@@ -196,15 +157,7 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The size of asset. If this field changes, the asset is considered to have changed.
-     *
-     * @type { string | undefined }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    size: string | undefined;
+    size: string;
 
     /**
      * The status of asset.
@@ -214,20 +167,13 @@ declare namespace commonType {
      * @crossplatform
      * @since 11
      */
-    /**
-     * The status of asset.
-     *
-     * @type { ?(AssetStatus | undefined) }
-     * @syscap SystemCapability.DistributedDataManager.CommonType
-     * @crossplatform
-     * @since 12
-     */
-    status?: AssetStatus | undefined;
+    status?: AssetStatus;
   }
 
   /**
    * Indicates several assets
    *
+   * @typedef { Array<Asset> }
    * @syscap SystemCapability.DistributedDataManager.CommonType
    * @crossplatform
    * @since 11
@@ -237,6 +183,7 @@ declare namespace commonType {
   /**
    * Indicates possible value types.
    *
+   * @typedef { null | number | string | boolean | Uint8Array | Asset | Assets }
    * @syscap SystemCapability.DistributedDataManager.CommonType
    * @crossplatform
    * @since 11
@@ -246,6 +193,7 @@ declare namespace commonType {
   /**
    * Values in buckets are stored in key-value pairs.
    *
+   * @typedef { Record<string, ValueType> }
    * @syscap SystemCapability.DistributedDataManager.CommonType
    * @crossplatform
    * @since 11
diff --git a/interface_sdk/api/@ohos.data.dataAbility.d.ts b/interface_sdk/api/@ohos.data.dataAbility.d.ts
index 5f9a92b3923e7952f0ccbee92f375f0480cb1666..b1fb0324bb01294eb047119acea3fe4be6907782 100644
--- a/interface_sdk/api/@ohos.data.dataAbility.d.ts
+++ b/interface_sdk/api/@ohos.data.dataAbility.d.ts
@@ -374,6 +374,7 @@ declare namespace dataAbility {
   /**
    * Indicates possible value types
    *
+   * @typedef { number | string | boolean }
    * @syscap SystemCapability.DistributedDataManager.DataShare.Core
    * @since 7
    */
diff --git a/interface_sdk/api/@ohos.data.dataShare.d.ts b/interface_sdk/api/@ohos.data.dataShare.d.ts
index 93316ad30b9b2cdc56a4a747fb1f9f095a4f564e..67e04fe777472f005e6c19faa2f9c8285b403b1e 100644
--- a/interface_sdk/api/@ohos.data.dataShare.d.ts
+++ b/interface_sdk/api/@ohos.data.dataShare.d.ts
@@ -48,6 +48,7 @@ declare namespace dataShare {
      * Specifies whether the {@link DataShareHelper} in proxy mode.
      * If value is true, the {@link DataShareHelper} to be created is in proxy mode, and all operations will not open provider APP as possible
      *
+     * @type { ?boolean }
      * @default false
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
@@ -177,6 +178,7 @@ declare namespace dataShare {
      * Specifies the id of subscriber, who process the callback
      * Same as subscriberId in {@link DataShareHelper#addTemplate}
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -187,6 +189,7 @@ declare namespace dataShare {
      * Specifies the bundleName of template owner, who create the template
      * Same as the caller's bundleName of {@link DataShareHelper#addTemplate}
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -208,6 +211,7 @@ declare namespace dataShare {
     /**
      * Specifies the key of the published data
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -218,6 +222,7 @@ declare namespace dataShare {
      * Specifies the published data
      * If the data is large, use ArrayBuffer.
      *
+     * @type { string | ArrayBuffer }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -227,6 +232,7 @@ declare namespace dataShare {
     /**
      * Specifies the subscriber id
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -248,6 +254,7 @@ declare namespace dataShare {
     /**
      * Specifies the uri of the callback.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -257,6 +264,7 @@ declare namespace dataShare {
     /**
      * Specifies the templateId of the callback.
      *
+     * @type { TemplateId }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -268,6 +276,7 @@ declare namespace dataShare {
      * every node is a json, json's key is [key of {@link Template#predicates}
      * and value is the query result from rdb store query by value of{@link Template#predicates}].
      *
+     * @type { Array<string> }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -289,6 +298,7 @@ declare namespace dataShare {
     /**
      * Specifies the bundleName of the callback.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -298,6 +308,7 @@ declare namespace dataShare {
     /**
      * Specifies the datas of the callback.
      *
+     * @type { Array<PublishedItem> }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -344,6 +355,7 @@ declare namespace dataShare {
      * Specifies the scheduler sql of the template.
      * When modify the subscribed uri's data, scheduler is auto called.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -364,6 +376,7 @@ declare namespace dataShare {
     /**
      * Specifies the key of the operation result.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -374,6 +387,7 @@ declare namespace dataShare {
     /**
      * Specifies the operation result.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -395,6 +409,7 @@ declare namespace dataShare {
     /**
      * Indicates the data to update.
      * 
+     * @type { ValuesBucket }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -405,6 +420,7 @@ declare namespace dataShare {
     /**
      * Indicates filter criteria.
      * 
+     * @type { dataSharePredicates.DataSharePredicates }
      * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
      * @systemapi
      * @stagemodelonly
@@ -486,6 +502,7 @@ declare namespace dataShare {
       /**
        * Type of the data change.
        *
+       * @type { ChangeType }
        * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
        * @systemapi
        * @stagemodelonly
@@ -496,6 +513,7 @@ declare namespace dataShare {
       /**
        * URI of the data changed.
        *
+       * @type { string }
        * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
        * @systemapi
        * @stagemodelonly
@@ -505,6 +523,7 @@ declare namespace dataShare {
       /**
         * Data changed.
         *
+        * @type { Array<ValuesBucket> }
         * @syscap SystemCapability.DistributedDataManager.DataShare.Consumer
         * @systemapi
         * @stagemodelonly
diff --git a/interface_sdk/api/@ohos.data.dataSharePredicates.d.ts b/interface_sdk/api/@ohos.data.dataSharePredicates.d.ts
index aa7cf3f6e2998791afac831b14efa96e41884c3c..19fb6d0ee11f8ad5acd7025f3a093c002187141b 100644
--- a/interface_sdk/api/@ohos.data.dataSharePredicates.d.ts
+++ b/interface_sdk/api/@ohos.data.dataSharePredicates.d.ts
@@ -28,6 +28,15 @@ import { ValueType } from './@ohos.data.ValuesBucket';
  * @StageModelOnly
  * @since 10
  */
+/**
+ * This module provides data share services based on the ExtensionAbility.
+ *
+ * @namespace dataSharePredicates
+ * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+ * @StageModelOnly
+ * @crossplatform
+ * @since 12
+ */
 declare namespace dataSharePredicates {
   /**
    * Manages relational database configurations.
@@ -36,6 +45,14 @@ declare namespace dataSharePredicates {
    * @StageModelOnly
    * @since 10
    */
+  /**
+   * Manages relational database configurations.
+   *
+   * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+   * @StageModelOnly
+   * @crossplatform
+   * @since 12
+   */
   class DataSharePredicates {
     /**
      * Configure the DataSharePredicates to match the field whose data type is ValueType and value is equal
@@ -49,6 +66,19 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Configure the DataSharePredicates to match the field whose data type is ValueType and value is equal
+     * to a specified value.
+     * This method is similar to = of the SQL statement.
+     *
+     * @param { string } field - Indicates the column name in the database table.
+     * @param { ValueType } value - Indicates the value to match with the DataSharePredicates.
+     * @returns { DataSharePredicates } Returns the DataSharePredicates that match the specified field.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     equalTo(field: string, value: ValueType): DataSharePredicates;
 
     /**
@@ -112,6 +142,16 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Adds an and condition to the DataSharePredicates.
+     * This method is similar to and of the SQL statement.
+     *
+     * @returns { DataSharePredicates } Returns the DataSharePredicates with the and condition.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     and(): DataSharePredicates;
 
     /**
@@ -323,6 +363,17 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Restricts the ascending order of the return list. When there are several orders,
+     * the one close to the head has the highest priority.
+     *
+     * @param { string } field - Indicates the column name for sorting the return list.
+     * @returns { DataSharePredicates } Returns the SQL query statement with the specified DataSharePredicates.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     orderByAsc(field: string): DataSharePredicates;
 
     /**
@@ -335,6 +386,17 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Restricts the descending order of the return list. When there are several orders,
+     * the one close to the head has the highest priority.
+     *
+     * @param { string } field - Indicates the column name for sorting the return list.
+     * @returns { DataSharePredicates } Returns the SQL query statement with the specified DataSharePredicates.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     orderByDesc(field: string): DataSharePredicates;
 
     /**
@@ -358,6 +420,17 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Construct a query object to specify the number of results and the starting position.
+     *
+     * @param { number } total - Represents the specified number of results.
+     * @param { number } offset - Indicates the starting position.
+     * @returns { DataSharePredicates } Returns the query object.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     limit(total: number, offset: number): DataSharePredicates;
 
     /**
@@ -396,6 +469,18 @@ declare namespace dataSharePredicates {
      * @StageModelOnly
      * @since 10
      */
+    /**
+     * Configure {@code DataSharePredicates} to match the specified field whose data type is ValueType array and values
+     * are within a given range.
+     *
+     * @param { string } field - Indicates the column name in the database table.
+     * @param { Array<ValueType> } value - Indicates the values to match with DataSharePredicates.
+     * @returns { DataSharePredicates } Returns DataSharePredicates that matches the specified field.
+     * @syscap SystemCapability.DistributedDataManager.DataShare.Core
+     * @StageModelOnly
+     * @crossplatform
+     * @since 12
+     */
     in(field: string, value: Array<ValueType>): DataSharePredicates;
 
     /**
diff --git a/interface_sdk/api/@ohos.data.distributedData.d.ts b/interface_sdk/api/@ohos.data.distributedData.d.ts
index d5d426b02f2767647a4bde382669067dd384a3e4..c68a135f1ca4abd2fe3e8139c88784c1617ec02b 100644
--- a/interface_sdk/api/@ohos.data.distributedData.d.ts
+++ b/interface_sdk/api/@ohos.data.distributedData.d.ts
@@ -22,6 +22,8 @@ import { AsyncCallback, Callback } from './@ohos.base';
 
 /**
  * Providers interfaces to creat a {@link KVManager} instance.
+ *
+ * @namespace distributedData
  * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
  * @since 7
  * @deprecated since 9
@@ -103,6 +105,7 @@ declare namespace distributedData {
   /**
    * KVStore constants
    *
+   * @namespace Constants
    * @syscap SystemCapability.DistributedDataManager.KVStore.Core
    * @since 7
    * @deprecated since 9
@@ -1294,6 +1297,22 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#put
      */
     put(key: string, value: Uint8Array | string | number | boolean, callback: AsyncCallback<void>): void;
+
+    /**
+     * Writes a key-value pair of the string type into the {@code KvStore} database.
+     *
+     * <p>If you do not want to synchronize this key-value pair to other devices, set the write option in the local database.
+     *
+     * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
+     * Spaces before and after the key will be cleared.
+     * @param value Indicates the string value, which must be less than 4 MB as a UTF-8 byte array.
+     * @throws Throws this exception if any of the following errors
+     * occurs: {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 7
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#put
+     */
     put(key: string, value: Uint8Array | string | number | boolean): Promise<void>;
 
     /**
@@ -1310,6 +1329,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#delete
      */
     delete(key: string, callback: AsyncCallback<void>): void;
+
+    /**
+     * Deletes the key-value pair based on a specified key.
+     *
+     * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
+     * Spaces before and after the key will be cleared.
+     * @throws Throws this exception if any of the following errors
+     * occurs: {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and
+     * {@code DB_ERROR}, and {@code KEY_NOT_FOUND}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 7
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#delete
+     */
     delete(key: string): Promise<void>;
 
     /**
@@ -1380,6 +1413,17 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#putBatch
      */
     putBatch(entries: Entry[], callback: AsyncCallback<void>): void;
+
+    /**
+     * Inserts key-value pairs into the {@code KvStore} database in batches.
+     *
+     * @param entries Indicates the key-value pairs to be inserted in batches.
+     * @throws Throws this exception if a database error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#putBatch
+     */
     putBatch(entries: Entry[]): Promise<void>;
 
     /**
@@ -1393,6 +1437,17 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#deleteBatch
      */
     deleteBatch(keys: string[], callback: AsyncCallback<void>): void;
+
+    /**
+     * Deletes key-value pairs in batches from the {@code KvStore} database.
+     *
+     * @param keys Indicates the key-value pairs to be deleted in batches.
+     * @throws Throws this exception if a database error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#deleteBatch
+     */
     deleteBatch(keys: string[]): Promise<void>;
 
     /**
@@ -1407,6 +1462,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#startTransaction
      */
     startTransaction(callback: AsyncCallback<void>): void;
+
+    /**
+     * Starts a transaction operation in the {@code KvStore} database.
+     *
+     * <p>After the database transaction is started, you can submit or roll back the operation.
+     *
+     * @throws Throws this exception if a database error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#startTransaction
+     */
     startTransaction(): Promise<void>;
 
     /**
@@ -1420,6 +1487,17 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#commit
      */
     commit(callback: AsyncCallback<void>): void;
+
+    /**
+     * Submits a transaction operation in the {@code KvStore} database.
+     *
+     * @param callback
+     * @throws Throws this exception if a database error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#commit
+     */
     commit(): Promise<void>;
 
     /**
@@ -1432,6 +1510,16 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#rollback
      */
     rollback(callback: AsyncCallback<void>): void;
+
+    /**
+     * Rolls back a transaction operation in the {@code KvStore} database.
+     *
+     * @throws Throws this exception if a database error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#rollback
+     */
     rollback(): Promise<void>;
 
     /**
@@ -1446,6 +1534,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#enableSync
      */
     enableSync(enabled: boolean, callback: AsyncCallback<void>): void;
+
+    /**
+     * Sets whether to enable synchronization.
+     *
+     * @param enabled Specifies whether to enable synchronization. The value true means to enable
+     * synchronization, and false means the opposite.
+     * @throws Throws this exception if an internal service error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#enableSync
+     */
     enableSync(enabled: boolean): Promise<void>;
 
     /**
@@ -1462,6 +1562,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#setSyncRange
      */
     setSyncRange(localLabels: string[], remoteSupportLabels: string[], callback: AsyncCallback<void>): void;
+
+    /**
+     * Sets synchronization range labels.
+     *
+     * <p>The labels determine the devices with which data will be synchronized.
+     *
+     * @param localLabels Indicates the synchronization labels of the local device.
+     * @param remoteSupportLabels Indicates the labels of the devices with which data will be synchronized.
+     * @throws Throws this exception if an internal service error occurs.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#setSyncRange
+     */
     setSyncRange(localLabels: string[], remoteSupportLabels: string[]): Promise<void>;
   }
 
@@ -1494,6 +1608,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#get
      */
     get(key: string, callback: AsyncCallback<Uint8Array | string | boolean | number>): void;
+
+    /**
+     * Obtains the {@code String} value of a specified key.
+     *
+     * @param key Indicates the key of the boolean value to be queried.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}, and {@code KEY_NOT_FOUND}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 7
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#get
+     */
     get(key: string): Promise<Uint8Array | string | boolean | number>;
 
     /**
@@ -1509,6 +1635,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getEntries
      */
     getEntries(keyPrefix: string, callback: AsyncCallback<Entry[]>): void;
+
+    /**
+     * Obtains all key-value pairs that match a specified key prefix.
+     *
+     * @param keyPrefix Indicates the key prefix to match.
+     * @returns Returns the list of all key-value pairs that match the specified key prefix.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getEntries
+     */
     getEntries(keyPrefix: string): Promise<Entry[]>;
 
     /**
@@ -1524,6 +1663,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getEntries
      */
     getEntries(query: Query, callback: AsyncCallback<Entry[]>): void;
+
+    /**
+     * Obtains the list of key-value pairs matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the list of key-value pairs matching the specified {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getEntries
+     */
     getEntries(query: Query): Promise<Entry[]>;
 
     /**
@@ -1542,6 +1694,22 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSet
      */
     getResultSet(keyPrefix: string, callback: AsyncCallback<KvStoreResultSet>): void;
+
+    /**
+     * Obtains the result sets with a specified prefix from a {@code KvStore} database. The {@code KvStoreResultSet} object can be used to
+     * query all key-value pairs that meet the search criteria. Each {@code KvStore} instance can have a maximum of four
+     * {@code KvStoreResultSet} objects at the same time. If you have created four objects, calling this method will return a
+     * failure. Therefore, you are advised to call the closeResultSet method to close unnecessary {@code KvStoreResultSet} objects
+     * in a timely manner.
+     *
+     * @param keyPrefix Indicates the key prefix to match.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSet
+     */
     getResultSet(keyPrefix: string): Promise<KvStoreResultSet>;
 
     /**
@@ -1556,6 +1724,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSet
      */
     getResultSet(query: Query, callback: AsyncCallback<KvStoreResultSet>): void;
+
+    /**
+     * Obtains the {@code KvStoreResultSet} object matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSet
+     */
     getResultSet(query: Query): Promise<KvStoreResultSet>;
 
     /**
@@ -1570,6 +1750,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#closeResultSet
      */
     closeResultSet(resultSet: KvStoreResultSet, callback: AsyncCallback<void>): void;
+
+    /**
+     * Closes a {@code KvStoreResultSet} object returned by getResultSet.
+     *
+     * @param resultSet Indicates the {@code KvStoreResultSet} object to close.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#closeResultSet
+     */
     closeResultSet(resultSet: KvStoreResultSet): Promise<void>;
 
     /**
@@ -1585,6 +1777,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSize
      */
     getResultSize(query: Query, callback: AsyncCallback<number>): void;
+
+    /**
+     * Obtains the number of results matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the number of results matching the specified {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getResultSize
+     */
     getResultSize(query: Query): Promise<number>;
 
     /**
@@ -1596,6 +1801,15 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#removeDeviceData
      */
     removeDeviceData(deviceId: string, callback: AsyncCallback<void>): void;
+
+    /**
+     * void removeDeviceData​({@link String} deviceId) throws {@link KvStoreException}
+     *
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#removeDeviceData
+     */
     removeDeviceData(deviceId: string): Promise<void>;
 
     /**
@@ -1679,6 +1893,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#setSyncParam
      */
     setSyncParam(defaultAllowedDelayMs: number, callback: AsyncCallback<void>): void;
+
+    /**
+     * Sets the default delay allowed for database synchronization
+     *
+     * @param defaultAllowedDelayMs Indicates the default delay allowed for the database synchronization, in milliseconds.
+     * @throws Throws this exception if any of the following errors occurs:{@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#setSyncParam
+     */
     setSyncParam(defaultAllowedDelayMs: number): Promise<void>;
 
     /**
@@ -1693,6 +1919,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.SingleKVStore#getSecurityLevel
      */
     getSecurityLevel(callback: AsyncCallback<SecurityLevel>): void;
+
+    /**
+     * Get the security level of the database.
+     *
+     * @returns SecurityLevel {@code SecurityLevel} the security level of the database.
+     * @throws Throws this exception if any of the following errors occurs:{@code SERVER_UNAVAILABLE},
+     * {@code IPC_ERROR}, and {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.SingleKVStore#getSecurityLevel
+     */
     getSecurityLevel(): Promise<SecurityLevel>;
   }
 
@@ -1724,6 +1962,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#get
      */
     get(deviceId: string, key: string, callback: AsyncCallback<boolean | string | number | Uint8Array>): void;
+
+    /**
+     * Obtains the {@code String} value matching a specified device ID and key.
+     *
+     * @param deviceId Indicates the device to be queried.
+     * @param key Indicates the key of the value to be queried.
+     * @returns Returns the value matching the given criteria.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}, and {@code KEY_NOT_FOUND}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#get
+     */
     get(deviceId: string, key: string): Promise<boolean | string | number | Uint8Array>;
 
     /**
@@ -1740,6 +1992,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
      */
     getEntries(deviceId: string, keyPrefix: string, callback: AsyncCallback<Entry[]>): void;
+
+    /**
+     * Obtains all key-value pairs matching a specified device ID and key prefix.
+     *
+     * @param deviceId Identifies the device whose data is to be queried.
+     * @param keyPrefix Indicates the key prefix to match.
+     * @returns Returns the list of all key-value pairs meeting the given criteria.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
+     */
     getEntries(deviceId: string, keyPrefix: string): Promise<Entry[]>;
 
     /**
@@ -1755,6 +2021,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
      */
     getEntries(query: Query, callback: AsyncCallback<Entry[]>): void;
+
+    /**
+     * Obtains the list of key-value pairs matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the list of key-value pairs matching the specified {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
+     */
     getEntries(query: Query): Promise<Entry[]>;
 
     /**
@@ -1769,6 +2048,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
      */
     getEntries(deviceId: string, query: Query, callback: AsyncCallback<Entry[]>): void;
+
+    /**
+     * Obtains the list of key-value pairs matching a specified device ID and {@code Query} object.
+     *
+     * @param deviceId Indicates the ID of the device to which the key-value pairs belong.
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the list of key-value pairs matching the specified {@code Query} object.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getEntries
+     */
     getEntries(deviceId: string, query: Query): Promise<Entry[]>;
 
     /**
@@ -1790,6 +2081,25 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
      */
     getResultSet(deviceId: string, keyPrefix: string, callback: AsyncCallback<KvStoreResultSet>): void;
+
+    /**
+     * Obtains the {@code KvStoreResultSet} object matching the specified device ID and key prefix.
+     *
+     * <p>The {@code KvStoreResultSet} object can be used to query all key-value pairs that meet the search criteria. Each {@code KvStore}
+     * instance can have a maximum of four {@code KvStoreResultSet} objects at the same time. If you have created four objects,
+     * calling this method will return a failure. Therefore, you are advised to call the closeResultSet method to close unnecessary
+     * {@code KvStoreResultSet} objects in a timely manner.
+     *
+     * @param deviceId Identifies the device whose data is to be queried.
+     * @param keyPrefix Indicates the key prefix to match.
+     * @returns Returns the {@code KvStoreResultSet} objects.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
+     */
     getResultSet(deviceId: string, keyPrefix: string): Promise<KvStoreResultSet>;
 
     /**
@@ -1805,6 +2115,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
      */
     getResultSet(query: Query, callback: AsyncCallback<KvStoreResultSet>): void;
+
+    /**
+     * Obtains the {@code KvStoreResultSet} object matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the {@code KvStoreResultSet} object matching the specified {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
+     */
     getResultSet(query: Query): Promise<KvStoreResultSet>;
 
     /**
@@ -1819,6 +2142,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
      */
     getResultSet(deviceId: string, query: Query, callback: AsyncCallback<KvStoreResultSet>): void;
+
+    /**
+     * Obtains the {@code KvStoreResultSet} object matching a specified device ID and {@code Query} object.
+     *
+     * @param deviceId Indicates the ID of the device to which the {@code KvStoreResultSet} object belongs.
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the {@code KvStoreResultSet} object matching the specified {@code Query} object.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSet
+     */
     getResultSet(deviceId: string, query: Query): Promise<KvStoreResultSet>;
 
     /**
@@ -1833,6 +2168,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#closeResultSet
      */
     closeResultSet(resultSet: KvStoreResultSet, callback: AsyncCallback<void>): void;
+
+    /**
+     * Closes a {@code KvStoreResultSet} object returned by getResultSet.
+     *
+     * @param resultSet Indicates the {@code KvStoreResultSet} object to close.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#closeResultSet
+     */
     closeResultSet(resultSet: KvStoreResultSet): Promise<void>;
 
     /**
@@ -1848,6 +2195,19 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSize
      */
     getResultSize(query: Query, callback: AsyncCallback<number>): void;
+
+    /**
+     * Obtains the number of results matching the specified {@code Query} object.
+     *
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the number of results matching the specified {@code Query} object.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSize
+     */
     getResultSize(query: Query): Promise<number>;
 
     /**
@@ -1862,6 +2222,18 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSize
      */
     getResultSize(deviceId: string, query: Query, callback: AsyncCallback<number>): void;
+
+    /**
+     * Obtains the number of results matching a specified device ID and {@code Query} object.
+     *
+     * @param deviceId Indicates the ID of the device to which the results belong.
+     * @param query Indicates the {@code Query} object.
+     * @returns Returns the number of results matching the specified {@code Query} object.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#getResultSize
+     */
     getResultSize(deviceId: string, query: Query): Promise<number>;
 
     /**
@@ -1878,6 +2250,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.DeviceKVStore#removeDeviceData
      */
     removeDeviceData(deviceId: string, callback: AsyncCallback<void>): void;
+
+    /**
+     * Removes data of a specified device from the current database. This method is used to remove only the data
+     * synchronized from remote devices. This operation does not synchronize data to other databases or affect
+     * subsequent data synchronization.
+     *
+     * @param deviceId Identifies the device whose data is to be removed. The value cannot be the current device ID.
+     * @throws Throws this exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.DeviceKVStore#removeDeviceData
+     */
     removeDeviceData(deviceId: string): Promise<void>;
 
     /**
@@ -1972,6 +2358,22 @@ declare namespace distributedData {
    * @useinstead ohos.data.distributedKVStore#createKVManager
    */
   function createKVManager(config: KVManagerConfig, callback: AsyncCallback<KVManager>): void;
+
+  /**
+   * Creates a {@link KVManager} instance based on the configuration information.
+   *
+   * <p>You must pass {@link KVManagerConfig} to provide configuration information
+   * for creating the {@link KVManager} instance.
+   *
+   * @param config Indicates the {@link KVStore} configuration information,
+   * including the user information and package name.
+   * @returns Returns the {@code KVManager} instance.
+   * @throws Throws exception if input is invalid.
+   * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+   * @since 7
+   * @deprecated since 9
+   * @useinstead ohos.data.distributedKVStore#createKVManager
+   */
   function createKVManager(config: KVManagerConfig): Promise<KVManager>;
 
   /**
@@ -1999,6 +2401,21 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.KVManager#getKVStore
      */
     getKVStore<T extends KVStore>(storeId: string, options: Options): Promise<T>;
+
+    /**
+     * Creates and obtains a {@code KVStore} database by specifying {@code Options} and {@code storeId}.
+     *
+     * @param options Indicates the options used for creating and obtaining the {@code KVStore} database,
+     * including {@code isCreateIfMissing}, {@code isEncrypt}, and {@code KVStoreType}.
+     * @param storeId Identifies the {@code KVStore} database.
+     * The value of this parameter must be unique for the same application,
+     * and different applications can share the same value.
+     * @returns Returns a {@code KVStore}, or {@code SingleKVStore}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 7
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.KVManager#getKVStore
+     */
     getKVStore<T extends KVStore>(storeId: string, options: Options, callback: AsyncCallback<T>): void;
 
     /**
@@ -2023,6 +2440,28 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.KVManager#closeKVStore
      */
     closeKVStore(appId: string, storeId: string, kvStore: KVStore, callback: AsyncCallback<void>): void;
+
+    /**
+     * Closes the {@code KvStore} database.
+     *
+     * <p>Warning: This method is not thread-safe. If you call this method to stop a KvStore database that is running, your
+     * thread may crash.
+     *
+     * <p>The {@code KvStore} database to close must be an object created by using the {@code getKvStore} method. Before using this
+     * method, release the resources created for the database, for example, {@code KvStoreResultSet} for {@code SingleKvStore},
+     * otherwise closing the database will fail. If you are attempting to close a database that is already closed, an error
+     * will be returned.
+     *
+     * @param kvStore Indicates the {@code KvStore} database to close.
+     * @throws Throws this exception if any of the following errors
+     * occurs:{@code INVALID_ARGUMENT}, {@code SERVER_UNAVAILABLE},
+     * {@code STORE_NOT_OPEN}, {@code STORE_NOT_FOUND}, {@code DB_ERROR},
+     * {@code PERMISSION_DENIED}, and {@code IPC_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.KVManager#closeKVStore
+     */
     closeKVStore(appId: string, storeId: string, kvStore: KVStore): Promise<void>;
 
     /**
@@ -2044,6 +2483,25 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.KVManager#deleteKVStore
      */
     deleteKVStore(appId: string, storeId: string, callback: AsyncCallback<void>): void;
+
+    /**
+     * Deletes the {@code KvStore} database identified by storeId.
+     *
+     * <p>Before using this method, close all {@code KvStore} instances in use that are identified by the same storeId.
+     *
+     * <p>You can use this method to delete a {@code KvStore} database not in use. After the database is deleted, all its data will be
+     * lost.
+     *
+     * @param storeId Identifies the {@code KvStore} database to delete.
+     * @throws Throws this exception if any of the following errors
+     * occurs: {@code INVALID_ARGUMENT},
+     * {@code SERVER_UNAVAILABLE}, {@code STORE_NOT_FOUND},
+     * {@code DB_ERROR}, {@code PERMISSION_DENIED}, and {@code IPC_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.KVManager#deleteKVStore
+     */
     deleteKVStore(appId: string, storeId: string): Promise<void>;
 
     /**
@@ -2060,6 +2518,20 @@ declare namespace distributedData {
      * @useinstead ohos.data.distributedKVStore.KVManager#getAllKVStoreId
      */
     getAllKVStoreId(appId: string, callback: AsyncCallback<string[]>): void;
+
+    /**
+     * Obtains the storeId of all {@code KvStore} databases that are created by using the {@code getKvStore} method and not deleted by
+     * calling the {@code deleteKvStore} method.
+     *
+     * @returns Returns the storeId of all created {@code KvStore} databases.
+     * @throws Throws this exception if any of the following errors
+     * occurs: {@code SERVER_UNAVAILABLE}, {@code DB_ERROR},
+     * {@code PERMISSION_DENIED}, and {@code IPC_ERROR}.
+     * @syscap SystemCapability.DistributedDataManager.KVStore.Core
+     * @since 8
+     * @deprecated since 9
+     * @useinstead ohos.data.distributedKVStore.KVManager#getAllKVStoreId
+     */
     getAllKVStoreId(appId: string): Promise<string[]>;
 
     /**
@@ -2088,4 +2560,10 @@ declare namespace distributedData {
   }
 }
 
+/**
+ * Providers interfaces to creat a {@link KVManager} instance.
+ * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
+ * @since 7
+ * @deprecated since 9
+ */
 export default distributedData;
\ No newline at end of file
diff --git a/interface_sdk/api/@ohos.data.distributedDataObject.d.ts b/interface_sdk/api/@ohos.data.distributedDataObject.d.ts
index 7e06e82b402bd45d62ef77b339baceaf0b2dd2e2..5960ab17e3c35255e01016e266397397ed322d08 100644
--- a/interface_sdk/api/@ohos.data.distributedDataObject.d.ts
+++ b/interface_sdk/api/@ohos.data.distributedDataObject.d.ts
@@ -131,6 +131,7 @@ declare namespace distributedDataObject {
     /**
      * sessionId of saved object
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
@@ -139,6 +140,7 @@ declare namespace distributedDataObject {
     /**
      * version of saved object, can compare with DistributedObject.__version
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
@@ -149,6 +151,7 @@ declare namespace distributedDataObject {
      * data is "local", means save in local device
      * otherwise, means the deviceId of others device
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
@@ -167,6 +170,7 @@ declare namespace distributedDataObject {
     /**
      * The sessionId of the changed object.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
@@ -291,6 +295,19 @@ declare namespace distributedDataObject {
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
+    /**
+     * Change object session.
+     *
+     * @permission ohos.permission.DISTRIBUTED_DATASYNC
+     * @param {string} sessionId - sessionId The sessionId to be joined, if empty, leave all session.
+     * @param {AsyncCallback<void>} callback - The callback of setSessionId.
+     * @throws {BusinessError} 201 - Permission verification failed.
+     * @throws {BusinessError} 401 - Parameter error. Possible causes: 1. Incorrect parameter types;
+     *     2. The sessionId allows only letters, digits, and underscores(_), and cannot exceed 128 in length.
+     * @throws {BusinessError} 15400001 - Create table failed.
+     * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
+     * @since 12
+     */
     setSessionId(sessionId: string, callback: AsyncCallback<void>): void;
 
     /**
@@ -318,6 +335,19 @@ declare namespace distributedDataObject {
      * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
      * @since 9
      */
+    /**
+     * Change object session.
+     *
+     * @permission ohos.permission.DISTRIBUTED_DATASYNC
+     * @param {string} sessionId - sessionId The sessionId to be joined, if empty, leave all session.
+     * @returns {Promise<void>} - The promise returned by the function.
+     * @throws {BusinessError} 201 - Permission verification failed.
+     * @throws {BusinessError} 401 - Parameter error. Possible causes: 1. Incorrect parameter types;
+     *     2. The sessionId allows only letters, digits, and underscores(_), and cannot exceed 128 in length.
+     * @throws {BusinessError} 15400001 - Create table failed.
+     * @syscap SystemCapability.DistributedDataManager.DataObject.DistributedObject
+     * @since 12
+     */
     setSessionId(sessionId?: string): Promise<void>;
 
     /**
diff --git a/interface_sdk/api/@ohos.data.distributedKVStore.d.ts b/interface_sdk/api/@ohos.data.distributedKVStore.d.ts
index 1918c77d90ff2a9c622f11e3c59a86d705350e72..62b913416bb88a9fa89e4bbc09dbe7ecb4897550 100644
--- a/interface_sdk/api/@ohos.data.distributedKVStore.d.ts
+++ b/interface_sdk/api/@ohos.data.distributedKVStore.d.ts
@@ -43,6 +43,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the bundleName
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -58,6 +59,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the ability or hap context
      *
+     * @type { BaseContext }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * if swap the area, you should close all the KV store and use the new BaseContext to create the KVManager
      * @since 10
@@ -76,6 +78,7 @@ declare namespace distributedKVStore {
     /**
      * Max key length is 1024.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -84,6 +87,7 @@ declare namespace distributedKVStore {
     /**
      * Max value length is 4194303.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -92,6 +96,7 @@ declare namespace distributedKVStore {
     /**
      * Max device coordinate key length is 896.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -100,6 +105,7 @@ declare namespace distributedKVStore {
     /**
      * Max store id length is 128.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -108,6 +114,7 @@ declare namespace distributedKVStore {
     /**
      * Max query length is 512000.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -116,6 +123,7 @@ declare namespace distributedKVStore {
     /**
      * Max batch operation size is 128.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -191,6 +199,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the value type
      *
+     * @type { ValueType }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      * @see ValueType
@@ -200,6 +209,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the value
      *
+     * @type { Uint8Array | string | number | boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -217,6 +227,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the key
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -225,6 +236,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the value
      *
+     * @type { Value }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -245,6 +257,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates data insertion records.
      *
+     * @type { Entry[] }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -253,6 +266,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates data update records.
      *
+     * @type { Entry[] }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -261,6 +275,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates data deletion records.
      *
+     * @type { Entry[] }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -269,6 +284,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the device id which brings the data change.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -422,6 +438,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates whether to create a database when the database file does not exist
      *
+     * @type { ?boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -430,6 +447,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates whether database files to be encrypted
      *
+     * @type { ?boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -438,6 +456,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates whether to back up database files
      *
+     * @type { ?boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -447,6 +466,7 @@ declare namespace distributedKVStore {
      * Indicates whether database files are automatically synchronized
      *
      * @permission ohos.permission.DISTRIBUTED_DATASYNC
+     * @type { ?boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -455,6 +475,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the database type
      *
+     * @type { ?KVStoreType }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -463,6 +484,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the database security level
      *
+     * @type { SecurityLevel }
      * @syscap SystemCapability.DistributedDataManager.KVStore.Core
      * @since 9
      */
@@ -471,6 +493,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the database schema
      *
+     * @type { ?Schema }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -496,6 +519,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the root json object.
      *
+     * @type { FieldNode }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -504,6 +528,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the string array of json.
      *
+     * @type { Array<string> }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -512,6 +537,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the mode of schema.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -520,6 +546,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the skip size of schema.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -555,7 +582,7 @@ declare namespace distributedKVStore {
      * @param { FieldNode } child - The field node to append.
      * @returns { boolean } Returns true if the child node is successfully added to this {@code FieldNode} and false otherwise.
      * @throws { BusinessError } 401 - Parameter error.Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -564,6 +591,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the default value of field node.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -572,6 +600,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the nullable of database field.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
@@ -580,6 +609,7 @@ declare namespace distributedKVStore {
     /**
      * Indicates the type of value.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.KVStore.DistributedKVStore
      * @since 9
      */
diff --git a/interface_sdk/api/@ohos.data.preferences.d.ts b/interface_sdk/api/@ohos.data.preferences.d.ts
index f45788e177666ca0e2be4d0b7e72b581b03c5daf..93426060de4f8890ba909ccc1533c252a56c0b3c 100644
--- a/interface_sdk/api/@ohos.data.preferences.d.ts
+++ b/interface_sdk/api/@ohos.data.preferences.d.ts
@@ -65,7 +65,7 @@ declare namespace preferences {
    */
   /**
    * Indicates possible value types
-   * 
+   *
    * @typedef {number | string | boolean | Array<number> | Array<string> | Array<boolean> | Uint8Array}
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @atomicservice
@@ -73,7 +73,7 @@ declare namespace preferences {
    */
   /**
    * Indicates possible value types
-   * 
+   *
    * @typedef {number | string | boolean | Array<number> | Array<string> | Array<boolean> | Uint8Array | object | bigint}
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @atomicservice
@@ -108,7 +108,6 @@ declare namespace preferences {
   /**
    * Maximum length of a key.
    *
-   * @constant
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @crossplatform
    * @atomicservice
@@ -143,7 +142,6 @@ declare namespace preferences {
   /**
    * Maximum length of a value.
    *
-   * @constant
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @crossplatform
    * @atomicservice
@@ -179,6 +177,7 @@ declare namespace preferences {
     /**
      * The preferences file name.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @crossplatform
      * @atomicservice
@@ -196,6 +195,7 @@ declare namespace preferences {
     /**
      * Application Group Id.
      *
+     * @type { ?(string | null | undefined) }
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @StageModelOnly
      * @atomicservice
@@ -1670,7 +1670,7 @@ declare namespace preferences {
      * Asynchronously saves the {@link Preferences} object to the file.
      *
      * @param { AsyncCallback<void> } callback - Indicates the callback function.
-     * @throws { BusinessError } 401 - Parameter error. Mandatory parameters are left unspecified;
+     * @throws { BusinessError } 401 - Parameter error. Mandatory parameters are left unspecified.
      * @throws { BusinessError } 15500000 - Inner error.
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @crossplatform
@@ -1782,7 +1782,6 @@ declare namespace preferences {
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
      *                                                                   2. Incorrect parameter types;
      *                                                                   3. Parameter verification failed.
-     *      The callback must be function.
      * @throws { BusinessError } 15500000 - Inner error.
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @atomicservice
diff --git a/interface_sdk/api/@ohos.data.rdb.d.ts b/interface_sdk/api/@ohos.data.rdb.d.ts
index 47c024345f258e2a5ca9dc42eb10446b7723c1ea..653c33468c3f8d89dbf3176436775c33d85d4531 100644
--- a/interface_sdk/api/@ohos.data.rdb.d.ts
+++ b/interface_sdk/api/@ohos.data.rdb.d.ts
@@ -510,6 +510,14 @@ declare namespace rdb {
    * @useinstead ohos.data.relationalStore.StoreConfig
    */
   interface StoreConfig {
+    /**
+     * Manages relational database configurations.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 7
+     * @deprecated since 9
+     * @useinstead ohos.data.relationalStore.StoreConfig
+     */
     name: string;
   }
 
@@ -937,7 +945,20 @@ declare namespace rdb {
     notIn(field: string, value: Array<ValueType>): RdbPredicates;
   }
 
+  /**
+   * Configure RdbPredicates to match the specified field whose data type is ValueType array and values
+   * are out of a given range.
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 7
+   * @deprecated since 9
+   */
   export type ResultSet = _ResultSet;
 }
 
+/**
+ * Provides methods for rdbStore create and delete.
+ * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+ * @since 7
+ * @deprecated since 9
+ */
 export default rdb;
diff --git a/interface_sdk/api/@ohos.data.relationalStore.d.ts b/interface_sdk/api/@ohos.data.relationalStore.d.ts
index 3c8f47e3168ab6d913446540ffc8cc738213f0d9..16e4ce632f3b0ee7235a9ca7fe64d7f376cb3e81 100644
--- a/interface_sdk/api/@ohos.data.relationalStore.d.ts
+++ b/interface_sdk/api/@ohos.data.relationalStore.d.ts
@@ -21,7 +21,7 @@
 import { AsyncCallback, Callback } from './@ohos.base';
 import Context from './application/BaseContext';
 import dataSharePredicates from './@ohos.data.dataSharePredicates';
-
+import sendableRelationalStore from './@ohos.data.sendableRelationalStore';
 /**
  * Provides methods for rdbStore create and delete.
  *
@@ -114,6 +114,7 @@ declare namespace relationalStore {
     /**
      * The name of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -123,6 +124,7 @@ declare namespace relationalStore {
     /**
      * The uri of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -132,6 +134,7 @@ declare namespace relationalStore {
     /**
      * The path of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -141,6 +144,7 @@ declare namespace relationalStore {
     /**
      * The create time of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -150,6 +154,7 @@ declare namespace relationalStore {
     /**
      * The modify time of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -159,6 +164,7 @@ declare namespace relationalStore {
     /**
      * The size of asset.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -168,6 +174,7 @@ declare namespace relationalStore {
     /**
      * The status of asset.
      *
+     * @type { ?AssetStatus }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -287,6 +294,7 @@ declare namespace relationalStore {
     /**
      * The database name.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -296,6 +304,7 @@ declare namespace relationalStore {
     /**
      * Specifies the security level of the database.
      *
+     * @type { SecurityLevel }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 9
@@ -305,6 +314,7 @@ declare namespace relationalStore {
     /**
      * Specifies whether the database is encrypted.
      *
+     * @type { ?boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 9
      */
@@ -313,6 +323,7 @@ declare namespace relationalStore {
     /**
      * The data group id of application.
      *
+     * @type { ?string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @StageModelOnly
      * @since 10
@@ -377,6 +388,53 @@ declare namespace relationalStore {
      * @since 12
      */
     isReadOnly?: boolean;
+
+    /**
+     * Indicates the names of the shared library containing fts etc.
+     *
+     * @type { ?Array<string> }
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    pluginLibs?: Array<string>;
+
+    /**
+     * Enumerates the high availability modes of the RDB store.
+     *
+     * @type { ?HAMode }
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    haMode?: HAMode;
+  }
+
+  /**
+   * Enumerates the high availability modes of the RDB store.
+   *
+   * @enum { number }
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @systemapi
+   * @since 12
+   */
+  enum HAMode {
+    /**
+     * SINGLE: Data is written to a single RDB store.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    SINGLE = 0,
+
+    /**
+     * MAIN_REPLICA: Data is written to the main and replica RDB stores.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    MAIN_REPLICA
   }
 
   /**
@@ -423,6 +481,7 @@ declare namespace relationalStore {
     /**
      * Describes the total number of data to sync.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -431,6 +490,7 @@ declare namespace relationalStore {
     /**
      * Describes the number of successfully synced data.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -439,6 +499,7 @@ declare namespace relationalStore {
     /**
      * Describes the number of data failed to sync.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -447,6 +508,7 @@ declare namespace relationalStore {
     /**
      * Describes the number of data remained to sync.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -464,6 +526,7 @@ declare namespace relationalStore {
     /**
      * Describes the {@code Statistic} details of the upload process.
      *
+     * @type { Statistic }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -472,6 +535,7 @@ declare namespace relationalStore {
     /**
      * Describes the {@code Statistic} details of the download process.
      *
+     * @type { Statistic }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -562,6 +626,7 @@ declare namespace relationalStore {
     /**
      * Describes the status of data sync progress.
      *
+     * @type { Progress }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -570,6 +635,7 @@ declare namespace relationalStore {
     /**
      * Describes the code of data sync progress.
      *
+     * @type { ProgressCode }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -747,7 +813,6 @@ declare namespace relationalStore {
   /**
    * Describes the subscription type.
    *
-   * @permission ohos.permission.DISTRIBUTED_DATASYNC
    * @enum { number }
    * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
    * @since 9
@@ -756,7 +821,6 @@ declare namespace relationalStore {
     /**
      * Subscription to remote data changes
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 9
      */
@@ -769,6 +833,12 @@ declare namespace relationalStore {
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
      */
+    /**
+     * Subscription to cloud data changes
+     *
+     * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
+     * @since 12
+     */
     SUBSCRIBE_TYPE_CLOUD,
 
     /**
@@ -778,6 +848,12 @@ declare namespace relationalStore {
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
      */
+    /**
+     * Subscription to cloud data changes details
+     *
+     * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
+     * @since 12
+     */
     SUBSCRIBE_TYPE_CLOUD_DETAILS,
 
     /**
@@ -804,6 +880,12 @@ declare namespace relationalStore {
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
+    /**
+     * Means the change type is data change.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
     DATA_CHANGE,
 
     /**
@@ -813,6 +895,12 @@ declare namespace relationalStore {
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
+    /**
+     * Means the change type is asset change.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
     ASSET_CHANGE
   }
 
@@ -827,6 +915,7 @@ declare namespace relationalStore {
     /**
      * Indicates the changed table
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -835,6 +924,7 @@ declare namespace relationalStore {
     /**
      * Indicates the changed type
      *
+     * @type { ChangeType }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -844,6 +934,7 @@ declare namespace relationalStore {
      * Indicates if there is a string primary key, the inserted will keep data's primary keys
      * otherwise it will keep the data's rowid.
      *
+     * @type { Array<string> | Array<number> }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -853,6 +944,7 @@ declare namespace relationalStore {
      * Indicates if there is a string primary key, the updated will keep data's primary keys
      * otherwise it will keep the data's rowid.
      *
+     * @type { Array<string> | Array<number> }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -862,6 +954,7 @@ declare namespace relationalStore {
      * Indicates if there is a string primary key, the deleted will keep data's primary keys
      * otherwise it will keep the data's rowid.
      *
+     * @type { Array<string> | Array<number> }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -871,7 +964,6 @@ declare namespace relationalStore {
   /**
    * Describes the distribution type of the tables.
    *
-   * @permission ohos.permission.DISTRIBUTED_DATASYNC
    * @enum { number }
    * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
    * @since 10
@@ -880,7 +972,6 @@ declare namespace relationalStore {
     /**
      * Indicates the table is distributed among the devices
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -893,6 +984,12 @@ declare namespace relationalStore {
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
      */
+    /**
+     * Indicates the table is distributed between the cloud and the devices.
+     *
+     * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
+     * @since 12
+     */
     DISTRIBUTED_CLOUD
   }
 
@@ -947,6 +1044,7 @@ declare namespace relationalStore {
     /**
      * Specifies whether the database auto sync.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 10
      */
@@ -1093,6 +1191,15 @@ declare namespace relationalStore {
      */
     DELETED_FLAG_FIELD = '#_deleted_flag',
 
+    /**
+     * Data status field.
+     * Indicates data status.
+     *
+     * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
+     * @since 12
+     */
+    DATA_STATUS_FIELD = '#_data_status',
+
     /**
      * Owner field.
      *
@@ -1969,6 +2076,7 @@ declare namespace relationalStore {
      * The column names are returned as a string array, in which the strings are in the same order
      * as the columns in the result set.
      *
+     * @type { Array<string> }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -1988,6 +2096,7 @@ declare namespace relationalStore {
      * The returned number is equal to the length of the string array returned by the
      * columnNames method.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2003,6 +2112,7 @@ declare namespace relationalStore {
     /**
      * Obtains the number of rows in the result set.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2020,6 +2130,7 @@ declare namespace relationalStore {
      * Obtains the current index of the result set.
      * The result set index starts from 0.
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2035,6 +2146,7 @@ declare namespace relationalStore {
     /**
      * Checks whether the cursor is positioned at the first row.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2050,6 +2162,7 @@ declare namespace relationalStore {
     /**
      * Checks whether the cursor is positioned at the last row.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2065,6 +2178,7 @@ declare namespace relationalStore {
     /**
      * Checks whether the cursor is positioned after the last row.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2080,6 +2194,7 @@ declare namespace relationalStore {
     /**
      * Checks whether the cursor is positioned before the first row.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2097,6 +2212,7 @@ declare namespace relationalStore {
      * Checks whether the current result set is closed.
      * If the result set is closed by calling the close method, true will be returned.
      *
+     * @type { boolean }
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @crossplatform
      * @since 10
@@ -2975,6 +3091,35 @@ declare namespace relationalStore {
      */
     getRow(): ValuesBucket;
 
+    /**
+     * Obtains the values of all columns in the specified row.
+     *
+     * @returns { sendableRelationalStore.ValuesBucket } Indicates the row of data
+     *   {@link sendableRelationalStore.ValuesBucket} to be inserted into the table.
+     * @throws { BusinessError } 14800000 - Inner error.
+     * @throws { BusinessError } 14800011 - Database corrupted.
+     * @throws { BusinessError } 14800012 - Row out of bounds.
+     * @throws { BusinessError } 14800013 - Column out of bounds.
+     * @throws { BusinessError } 14800014 - Already closed.
+     * @throws { BusinessError } 14800021 - SQLite: Generic error.
+     * @throws { BusinessError } 14800022 - SQLite: Callback routine requested an abort.
+     * @throws { BusinessError } 14800023 - SQLite: Access permission denied.
+     * @throws { BusinessError } 14800024 - SQLite: The database file is locked.
+     * @throws { BusinessError } 14800025 - SQLite: A table in the database is locked.
+     * @throws { BusinessError } 14800026 - SQLite: The database is out of memory.
+     * @throws { BusinessError } 14800027 - SQLite: Attempt to write a readonly database.
+     * @throws { BusinessError } 14800028 - SQLite: Some kind of disk I/O error occurred.
+     * @throws { BusinessError } 14800029 - SQLite: The database is full.
+     * @throws { BusinessError } 14800030 - SQLite: Unable to open the database file.
+     * @throws { BusinessError } 14800031 - SQLite: TEXT or BLOB exceeds size limit.
+     * @throws { BusinessError } 14800032 - SQLite: Abort due to constraint violation.
+     * @throws { BusinessError } 14800033 - SQLite: Data type mismatch.
+     * @throws { BusinessError } 14800034 - SQLite: Library used incorrectly.
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    getSendableRow(): sendableRelationalStore.ValuesBucket;
+
     /**
      * Checks whether the value of the specified column in the current row is null.
      *
@@ -3104,6 +3249,7 @@ declare namespace relationalStore {
      * Set RdbStore version. The version number must be an integer greater than 0.
      * Obtains the RdbStore version.
      *
+     * @type { number }
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
      * <br>2. Incorrect parameter types.
      * @throws { BusinessError } 801 - Capability not supported.
@@ -3129,7 +3275,6 @@ declare namespace relationalStore {
      * Set whether the database is rebuilt.
      *
      * @type {RebuildType}
-     * @readonly
      * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
      * @since 12
      */
@@ -3385,6 +3530,40 @@ declare namespace relationalStore {
      */
     insertSync(table: string, values: ValuesBucket, conflict?: ConflictResolution): number;
 
+    /**
+     * Inserts a row of data into the target table with sync interface.
+     *
+     * @param { string } table - Indicates the target table.
+     * @param { sendableRelationalStore.ValuesBucket } values - Indicates the row of data
+     *   {@link sendableRelationalStore.ValuesBucket} to be inserted into the table.
+     * @param { ConflictResolution } conflict - Indicates the {@link ConflictResolution} to insert data into the table.
+     * @returns { number } The row ID if the operation is successful. return -1 otherwise.
+     * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
+     * <br>2. Incorrect parameter types.
+     * @throws { BusinessError } 14800000 - Inner error.
+     * @throws { BusinessError } 14800011 - Database corrupted.
+     * @throws { BusinessError } 14800014 - Already closed.
+     * @throws { BusinessError } 14800015 - The database does not respond.
+     * @throws { BusinessError } 14800021 - SQLite: Generic error.
+     * @throws { BusinessError } 14800022 - SQLite: Callback routine requested an abort.
+     * @throws { BusinessError } 14800023 - SQLite: Access permission denied.
+     * @throws { BusinessError } 14800024 - SQLite: The database file is locked.
+     * @throws { BusinessError } 14800025 - SQLite: A table in the database is locked.
+     * @throws { BusinessError } 14800026 - SQLite: The database is out of memory.
+     * @throws { BusinessError } 14800027 - SQLite: Attempt to write a readonly database.
+     * @throws { BusinessError } 14800028 - SQLite: Some kind of disk I/O error occurred.
+     * @throws { BusinessError } 14800029 - SQLite: The database is full.
+     * @throws { BusinessError } 14800030 - SQLite: Unable to open the database file.
+     * @throws { BusinessError } 14800031 - SQLite: TEXT or BLOB exceeds size limit.
+     * @throws { BusinessError } 14800032 - SQLite: Abort due to constraint violation.
+     * @throws { BusinessError } 14800033 - SQLite: Data type mismatch.
+     * @throws { BusinessError } 14800034 - SQLite: Library used incorrectly.
+     * @throws { BusinessError } 14800047 - The WAL file size exceeds the default limit.
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    insertSync(table: string, values: sendableRelationalStore.ValuesBucket, conflict?: ConflictResolution): number;
+
     /**
      * Inserts a batch of data into the target table.
      *
@@ -4471,19 +4650,6 @@ declare namespace relationalStore {
       columns?: Array<string>
     ): Promise<ResultSet>;
 
-    /**
-     * Queries data in the database based on specified conditions with sync function.
-     *
-     * @param { RdbPredicates } predicates - The specified query condition by the instance object of {@link RdbPredicates}.
-     * @param { Array<string> } columns - The columns to query. If the value is empty array, the query applies to all columns.
-     * @returns { ResultSet } The {@link ResultSet} object if the operation is successful.
-     * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
-     * <br>2. Incorrect parameter types.
-     * @throws { BusinessError } 14800000 - Inner error.
-     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
-     * @crossplatform
-     * @since 12
-     */
     /**
      * Queries data in the database based on specified conditions with sync function.
      *
@@ -5725,6 +5891,36 @@ declare namespace relationalStore {
      */
     restore(srcName: string): Promise<void>;
 
+    /**
+     * Restores a database from a specified database file.
+     *
+     * @returns { Promise<void> } The promise returned by the function.
+     * @throws { BusinessError } 202 - Permission verification failed, application which is not a system application uses system API.
+     * @throws { BusinessError } 14800000 - Inner error.
+     * @throws { BusinessError } 14800010 - Invalid database path.
+     * @throws { BusinessError } 14800011 - Database corrupted.
+     * @throws { BusinessError } 14800014 - Already closed.
+     * @throws { BusinessError } 14800015 - The database does not respond.
+     * @throws { BusinessError } 14800021 - SQLite: Generic error.
+     * @throws { BusinessError } 14800022 - SQLite: Callback routine requested an abort.
+     * @throws { BusinessError } 14800023 - SQLite: Access permission denied.
+     * @throws { BusinessError } 14800024 - SQLite: The database file is locked.
+     * @throws { BusinessError } 14800025 - SQLite: A table in the database is locked.
+     * @throws { BusinessError } 14800026 - SQLite: The database is out of memory.
+     * @throws { BusinessError } 14800027 - SQLite: Attempt to write a readonly database.
+     * @throws { BusinessError } 14800028 - SQLite: Some kind of disk I/O error occurred.
+     * @throws { BusinessError } 14800029 - SQLite: The database is full.
+     * @throws { BusinessError } 14800030 - SQLite: Unable to open the database file.
+     * @throws { BusinessError } 14800031 - SQLite: TEXT or BLOB exceeds size limit.
+     * @throws { BusinessError } 14800032 - SQLite: Abort due to constraint violation.
+     * @throws { BusinessError } 14800033 - SQLite: Data type mismatch.
+     * @throws { BusinessError } 14800034 - SQLite: Library used incorrectly.
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    restore(): Promise<void>;
+
     /**
      * Set table to be distributed table.
      *
@@ -5805,7 +6001,7 @@ declare namespace relationalStore {
      * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { Array<string> } tables - Indicates the table names you want to set.
      * @param { DistributedType } type - Indicates the distributed type {@link DistributedType}.
-     * This method only works when type equals to DistributedType.DISTRIBUTED_CLOUD
+     * ohos.permission.DISTRIBUTED_DATASYNC is required only when type is DISTRIBUTED_DEVICE.
      * @param { AsyncCallback<void> } callback - The callback of setDistributedTables.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
      * <br>2. Incorrect parameter types.
@@ -5841,7 +6037,7 @@ declare namespace relationalStore {
      * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { Array<string> } tables - Indicates the table names you want to set.
      * @param { DistributedType } type - Indicates the distributed type {@link DistributedType}.
-     * This method only works when type equals to DistributedType.DISTRIBUTED_CLOUD
+     * ohos.permission.DISTRIBUTED_DATASYNC is required only when type is DISTRIBUTED_DEVICE.
      * @param { DistributedConfig } config - Indicates the distributed config of the tables. For details, see {@link DistributedConfig}.
      * @param { AsyncCallback<void> } callback - The callback of setDistributedTables.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
@@ -5883,7 +6079,7 @@ declare namespace relationalStore {
      * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { Array<string> } tables - Indicates the table names you want to set.
      * @param { DistributedType } type - Indicates the distributed type {@link DistributedType}.
-     * This method only works when type equals to DistributedType.DISTRIBUTED_CLOUD
+     * ohos.permission.DISTRIBUTED_DATASYNC is required only when type is DISTRIBUTED_DEVICE.
      * @param { DistributedConfig } config - Indicates the distributed config of the tables. For details, see {@link DistributedConfig}.
      * @returns { Promise<void> } The promise returned by the function.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
@@ -6032,13 +6228,11 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @param { AsyncCallback<void> } callback - {Array<[string, number]>}: devices sync status array, {string}: device id, {number}: device sync status.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The progress must be a callback type. 5. The callback must be a function.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 801 - Capability not supported.
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
@@ -6046,11 +6240,9 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @param { AsyncCallback<void> } callback - {Array<[string, number]>}: devices sync status array, {string}: device id, {number}: device sync status.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The progress must be a callback type. 5. The callback must be a function.
      * @throws { BusinessError } 801 - Capability not supported.
@@ -6063,13 +6255,11 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @returns { Promise<void> } : devices sync status array, {string}: device id, {number}: device sync status.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The progress must be a callback type.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 801 - Capability not supported.
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
@@ -6077,11 +6267,9 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @returns { Promise<void> } : devices sync status array, {string}: device id, {number}: device sync status.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The progress must be a callback type.
      * @throws { BusinessError } 801 - Capability not supported.
@@ -6094,7 +6282,6 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { string[] } tables - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
@@ -6102,7 +6289,6 @@ declare namespace relationalStore {
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The tablesNames must be not empty. 5. The progress must be a callback type.
      * 6. The callback must be a function.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 801 - Capability not supported.
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
@@ -6110,12 +6296,10 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { string[] } tables - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @param { AsyncCallback<void> } callback - {Array<[string, number]>}: devices sync status array, {string}: device id, {number}: device sync status.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The tablesNames must be not empty. 5. The progress must be a callback type.
      * 6. The callback must be a function.
@@ -6134,14 +6318,12 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { string[] } tables - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @returns { Promise<void> } : devices sync status array, {string}: device id, {number}: device sync status.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The tablesNames must be not empty. 5. The progress must be a callback type.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 801 - Capability not supported.
      * @syscap SystemCapability.DistributedDataManager.CloudSync.Client
      * @since 10
@@ -6149,12 +6331,10 @@ declare namespace relationalStore {
     /**
      * Sync data to cloud.
      *
-     * @permission ohos.permission.DISTRIBUTED_DATASYNC
      * @param { SyncMode } mode - indicates the database synchronization mode.
      * @param { string[] } tables - indicates the database synchronization mode.
      * @param { Callback<ProgressDetails> } progress - the specified sync condition by the instance object of {@link ProgressDetails}.
      * @returns { Promise<void> } : devices sync status array, {string}: device id, {number}: device sync status.
-     * @throws { BusinessError } 202 - if permission verification failed, application does not have permission ohos.permission.DISTRIBUTED_DATASYNC.
      * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Need 2 - 4  parameter(s). 2. The RdbStore must be not nullptr.
      * 3. The mode must be a SyncMode of cloud. 4. The tablesNames must be not empty. 5. The progress must be a callback type.
      * @throws { BusinessError } 801 - Capability not supported.
@@ -6821,6 +7001,28 @@ declare namespace relationalStore {
      * @since 12
      */
     queryLockedRow(predicates: RdbPredicates, columns?: Array<string>): Promise<ResultSet>;
+
+    /**
+     * Lock cloud container before non-auto cloud sync.
+     *
+     * @returns { Promise<number> } The expired time of the lock.
+     * @throws { BusinessError } 202 - Permission verification failed, application which is not a system application uses system API.
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    lockCloudContainer(): Promise<number>;
+
+    /**
+     * Unlock cloud container.
+     *
+     * @returns { Promise<void> } The promise returned by the function.
+     * @throws { BusinessError } 202 - Permission verification failed, application which is not a system application uses system API.
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @systemapi
+     * @since 12
+     */
+    unlockCloudContainer(): Promise<void>;
   }
 
   /**
diff --git a/interface_sdk/api/@ohos.data.sendablePreferences.d.ets b/interface_sdk/api/@ohos.data.sendablePreferences.d.ets
index b0fa633f6ee9f36c8c78d9a96d9a319b2925de95..626fbf4f811e5e671f0be2780d270427cabcde29 100644
--- a/interface_sdk/api/@ohos.data.sendablePreferences.d.ets
+++ b/interface_sdk/api/@ohos.data.sendablePreferences.d.ets
@@ -36,7 +36,6 @@ declare namespace sendablePreferences {
   /**
    * Maximum length of a key.
    *
-   * @constant
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @atomicservice
    * @since 12
@@ -46,7 +45,6 @@ declare namespace sendablePreferences {
   /**
    * Maximum length of a value.
    *
-   * @constant
    * @syscap SystemCapability.DistributedDataManager.Preferences.Core
    * @atomicservice
    * @since 12
@@ -65,6 +63,7 @@ declare namespace sendablePreferences {
     /**
      * Name of the preferences file.
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @atomicservice
      * @since 12
@@ -74,6 +73,7 @@ declare namespace sendablePreferences {
     /**
      * Application group ID.
      *
+     * @type { ?(string | null) }
      * @syscap SystemCapability.DistributedDataManager.Preferences.Core
      * @StageModelOnly
      * @atomicservice
diff --git a/interface_sdk/api/@ohos.data.sendableRelationalStore.d.ets b/interface_sdk/api/@ohos.data.sendableRelationalStore.d.ets
new file mode 100644
index 0000000000000000000000000000000000000000..b354d041916e0e02e138966c3d3f1b49e4708f17
--- /dev/null
+++ b/interface_sdk/api/@ohos.data.sendableRelationalStore.d.ets
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file
+ * @kit ArkData
+ */
+
+import collections from '../arkts/@arkts.collections';
+import lang from '../arkts/@arkts.lang';
+import relationalStore from './@ohos.data.relationalStore';
+
+/**
+ * Provides methods for creating and deleting an RDB store.
+ *
+ * @namespace sendableRelationalStore
+ * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+ * @since 12
+ */
+declare namespace sendableRelationalStore {
+  /**
+   * Defines information of an asset.
+   *
+   * @interface Asset
+   * @extends lang.ISendable
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  interface Asset extends lang.ISendable {
+    /**
+     * Name of the asset.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    name: string;
+
+    /**
+     * URI of the asset.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    uri: string;
+
+    /**
+     * Path of the asset.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    path: string;
+
+    /**
+     * Time when the asset was created.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    createTime: string;
+
+    /**
+     * Time when the asset was last modified.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    modifyTime: string;
+
+    /**
+     * Size of the asset.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    size: string;
+
+    /**
+     * Status of the asset.
+     *
+     * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+     * @since 12
+     */
+    status?: number;
+  }
+
+  /**
+   * Defines multiple assets in a column.
+   *
+   * @typedef { collections.Array<Asset> } Assets
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  type Assets = collections.Array<Asset>;
+
+  /**
+   * Defines the types of the value in a KV pair.
+   *
+   * @typedef { null | number | string | boolean | collections.Uint8Array | Asset | Assets |
+   * collections.Float32Array | bigint } ValueType
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  type ValueType = null | number | string | boolean | collections.Uint8Array | Asset | Assets |
+    collections.Float32Array | bigint;
+
+  /**
+   * Defines the data stored in KV pairs in a ValuesBucket object.
+   *
+   * @typedef { collections.Map<string, ValueType> } ValuesBucket
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  type ValuesBucket = collections.Map<string, ValueType>;
+
+  /**
+   * Defines NonSendableBucket for convenience.
+   *
+   * @typedef { relationalStore.ValuesBucket } NonSendableBucket
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  type NonSendableBucket = relationalStore.ValuesBucket;
+
+  /**
+   * Defines NonSendableAsset for convenience.
+   *
+   * @typedef { relationalStore.Asset } NonSendableAsset
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  type NonSendableAsset = relationalStore.Asset;
+
+  /**
+   * Converts a sendable <b>valuesBucket</b> object to a non-sendable <b>valuesBucket</b> object.
+   *
+   * @param { ValuesBucket } valuesBucket - Indicates the sendable <b>valuesBucket</b> object to convert.
+   * @returns { NonSendableBucket } a non-sendable <b>valuesBucket</b> object. For details,
+   *   see {@link NonSendableBucket}.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
+   * <br>2. Incorrect parameter types;3. Parameter verification failed.
+   * @throws { BusinessError } 14800000 - Inner error.
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  function fromSendableValuesBucket(valuesBucket: ValuesBucket): NonSendableBucket;
+
+  /**
+   * Converts a non-sendable <b>valuesBucket</b> object to a sendable <b>valuesBucket</b> object.
+   *
+   * @param { NonSendableBucket } valuesBucket - Indicates the non-sendable <b>valuesBucket</b> object to convert.
+   * @returns { ValuesBucket } a sendable <b>valuesBucket</b> object. For details, see {@link ValuesBucket}.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
+   * <br>2. Incorrect parameter types;3. Parameter verification failed.
+   * @throws { BusinessError } 14800000 - Inner error.
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  function toSendableValuesBucket(valuesBucket: NonSendableBucket): ValuesBucket;
+
+    /**
+   * Converts a sendable <b>asset</b> object to a non-sendable <b>asset</b> object.
+   *
+   * @param { Asset } asset - Indicates the sendable <b>asset</b> object to convert.
+   * @returns { NonSendableAsset } a non-sendable <b>asset</b> object. For details, see {@link NonSendableAsset}.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
+   * <br>2. Incorrect parameter types;3. Parameter verification failed.
+   * @throws { BusinessError } 14800000 - Inner error.
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  function fromSendableAsset(asset: Asset): NonSendableAsset;
+
+  /**
+   * Converts a non-sendable <b>asset</b> object to a sendable <b>asset</b> object.
+   *
+   * @param { NonSendableAsset } asset - Indicates the non-sendable <b>asset</b> object to convert.
+   * @returns { Asset } a sendable <b>asset</b> object. For details, see {@link Asset}.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
+   * <br>2. Incorrect parameter types;3. Parameter verification failed.
+   * @throws { BusinessError } 14800000 - Inner error.
+   * @syscap SystemCapability.DistributedDataManager.RelationalStore.Core
+   * @since 12
+   */
+  function toSendableAsset(asset: NonSendableAsset): Asset;
+}
+
+export default sendableRelationalStore;
\ No newline at end of file
diff --git a/interface_sdk/api/@ohos.data.storage.d.ts b/interface_sdk/api/@ohos.data.storage.d.ts
index f24cfb704830c08a56192c24cde5225f4c82603a..38ed538c9addd9f1424e0e75fcbe404cbcb9c079 100644
--- a/interface_sdk/api/@ohos.data.storage.d.ts
+++ b/interface_sdk/api/@ohos.data.storage.d.ts
@@ -23,6 +23,7 @@ import { AsyncCallback, Callback } from './@ohos.base';
 /**
  * Provides interfaces to obtain and modify storage data.
  *
+ * @namespace storage
  * @name storage
  * @since 6
  * @deprecated since 9
@@ -31,7 +32,6 @@ import { AsyncCallback, Callback } from './@ohos.base';
  *
  */
 
-
 declare namespace storage {
   /**
    * Obtains a {@link Storage} instance matching a specified storage file name.
@@ -46,9 +46,36 @@ declare namespace storage {
    * @deprecated since 9
    * @useinstead ohos.preferences.preferences.getPreferences
    */
-
   function getStorageSync(path: string): Storage;
+
+  /**
+   * Obtains a {@link Storage} instance matching a specified storage file name.
+   *
+   * <p>The {@link references} instance loads all data of the storage file and
+   * resides in the memory. You can use removeStorageFromCache to remove the instance from the memory.
+   *
+   * @param path Indicates the path of storage file stored.
+   * @returns Returns the {@link Storage} instance matching the specified storage file name.
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.getPreferences
+   */
   function getStorage(path: string, callback: AsyncCallback<Storage>): void;
+
+  /**
+   * Obtains a {@link Storage} instance matching a specified storage file name.
+   *
+   * <p>The {@link references} instance loads all data of the storage file and
+   * resides in the memory. You can use removeStorageFromCache to remove the instance from the memory.
+   *
+   * @param path Indicates the path of storage file stored.
+   * @returns Returns the {@link Storage} instance matching the specified storage file name.
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.getPreferences
+   */
   function getStorage(path: string): Promise<Storage>;
 
   /**
@@ -67,7 +94,39 @@ declare namespace storage {
    * @useinstead ohos.preferences.preferences.deletePreferences
    */
   function deleteStorageSync(path: string): void;
+
+  /**
+   * Deletes a {@link Storage} instance matching a specified storage file name
+   * from the cache which is performed by removeStorageFromCache and deletes the
+   * storage file.
+   *
+   * <p>When deleting the {@link Storage} instance, you must release all references
+   * of the instance. In addition, do not use the instance to perform data operations. Otherwise, inconsistent data
+   * will occur.
+   *
+   * @param path Indicates the path of storage file
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.deletePreferences
+   */
   function deleteStorage(path: string, callback: AsyncCallback<void>): void;
+
+  /**
+   * Deletes a {@link Storage} instance matching a specified storage file name
+   * from the cache which is performed by removeStorageFromCache and deletes the
+   * storage file.
+   *
+   * <p>When deleting the {@link Storage} instance, you must release all references
+   * of the instance. In addition, do not use the instance to perform data operations. Otherwise, inconsistent data
+   * will occur.
+   *
+   * @param path Indicates the path of storage file
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.deletePreferences
+   */
   function deleteStorage(path: string): Promise<void>;
 
   /**
@@ -85,7 +144,37 @@ declare namespace storage {
    * @useinstead ohos.preferences.preferences.removePreferencesFromCache
    */
   function removeStorageFromCacheSync(path: string): void;
+
+  /**
+   * Deletes a {@link Storage} instance matching a specified storage file name
+   * from the cache.
+   *
+   * <p>When deleting the {@link Storage} instance, you must release all references
+   * of the instance. In addition, do not use the instance to perform data operations. Otherwise, inconsistent data
+   * will occur.
+   *
+   * @param path Indicates the path of storage file.
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.removePreferencesFromCache
+   */
   function removeStorageFromCache(path: string, callback: AsyncCallback<void>): void;
+
+  /**
+   * Deletes a {@link Storage} instance matching a specified storage file name
+   * from the cache.
+   *
+   * <p>When deleting the {@link Storage} instance, you must release all references
+   * of the instance. In addition, do not use the instance to perform data operations. Otherwise, inconsistent data
+   * will occur.
+   *
+   * @param path Indicates the path of storage file.
+   * @throws BusinessError if invoked failed
+   * @since 6
+   * @deprecated since 9
+   * @useinstead ohos.preferences.preferences.removePreferencesFromCache
+   */
   function removeStorageFromCache(path: string): Promise<void>;
 
   /**
@@ -117,7 +206,35 @@ declare namespace storage {
     * @useinstead ohos.preferences.preferences.get
     */
     getSync(key: string, defValue: ValueType): ValueType;
+
+    /**
+    * Obtains the value of a storage in the int format.
+    *
+    * <p>If the value is {@code null} or not in the int format, the default value is returned.
+    *
+    * @param key Indicates the key of the storage. It cannot be {@code null} or empty.
+    * @param defValue Indicates the default value to return.
+    * @returns Returns the value matching the specified key if it is found; returns the default value otherwise.
+    * @throws BusinessError if invoked failed
+    * @since 6
+    * @deprecated since 9
+    * @useinstead ohos.preferences.preferences.get
+    */
     get(key: string, defValue: ValueType, callback: AsyncCallback<ValueType>): void;
+
+    /**
+    * Obtains the value of a storage in the int format.
+    *
+    * <p>If the value is {@code null} or not in the int format, the default value is returned.
+    *
+    * @param key Indicates the key of the storage. It cannot be {@code null} or empty.
+    * @param defValue Indicates the default value to return.
+    * @returns Returns the value matching the specified key if it is found; returns the default value otherwise.
+    * @throws BusinessError if invoked failed
+    * @since 6
+    * @deprecated since 9
+    * @useinstead ohos.preferences.preferences.get
+    */
     get(key: string, defValue: ValueType): Promise<ValueType>;
 
     /**
@@ -132,7 +249,31 @@ declare namespace storage {
      * @useinstead ohos.preferences.preferences.has
      */
     hasSync(key: string): boolean;
+
+    /**
+     * Checks whether the {@link Storage} object contains a storage matching a specified key.
+     *
+     * @param key Indicates the key of the storage to check for.
+     * @returns Returns {@code true} if the {@link Storage} object contains a storage with the specified key;
+     * returns {@code false} otherwise.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.has
+     */
     has(key: string, callback: AsyncCallback<boolean>): boolean;
+
+    /**
+     * Checks whether the {@link Storage} object contains a storage matching a specified key.
+     *
+     * @param key Indicates the key of the storage to check for.
+     * @returns Returns {@code true} if the {@link Storage} object contains a storage with the specified key;
+     * returns {@code false} otherwise.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.has
+     */
     has(key: string): Promise<boolean>;
 
     /**
@@ -150,7 +291,37 @@ declare namespace storage {
      * @useinstead ohos.preferences.preferences.put
      */
     putSync(key: string, value: ValueType): void;
+
+    /**
+     * Sets an int value for the key in the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} or {@link #flushSync} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @param key Indicates the key of the storage to modify. It cannot be {@code null} or empty.
+     * @param value Indicates the value of the storage.
+     * <tt>MAX_KEY_LENGTH</tt>.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.put
+     */
     put(key: string, value: ValueType, callback: AsyncCallback<void>): void;
+
+    /**
+     * Sets an int value for the key in the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} or {@link #flushSync} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @param key Indicates the key of the storage to modify. It cannot be {@code null} or empty.
+     * @param value Indicates the value of the storage.
+     * <tt>MAX_KEY_LENGTH</tt>.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.put
+     */
     put(key: string, value: ValueType): Promise<void>;
 
     /**
@@ -167,7 +338,35 @@ declare namespace storage {
      * @useinstead ohos.preferences.preferences.delete
      */
     deleteSync(key: string): void;
+
+    /**
+     * Deletes the storage with a specified key from the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @param key Indicates the key of the storage to delete. It cannot be {@code null} or empty.
+     * <tt>MAX_KEY_LENGTH</tt>.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.delete
+     */
     delete(key: string, callback: AsyncCallback<void>): void;
+
+    /**
+     * Deletes the storage with a specified key from the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @param key Indicates the key of the storage to delete. It cannot be {@code null} or empty.
+     * <tt>MAX_KEY_LENGTH</tt>.
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.delete
+     */
     delete(key: string): Promise<void>;
 
     /**
@@ -182,7 +381,31 @@ declare namespace storage {
      * @useinstead ohos.preferences.preferences.clear
      */
     clearSync(): void;
+
+    /**
+     * Clears all storage from the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.clear
+     */
     clear(callback: AsyncCallback<void>): void;
+
+    /**
+     * Clears all storage from the {@link Storage} object.
+     *
+     * <p>You can call the {@link #flush} method to save the {@link Storage} object to the
+     * file.
+     *
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.clear
+     */
     clear(): Promise<void>;
 
     /**
@@ -194,7 +417,25 @@ declare namespace storage {
      * @useinstead ohos.preferences.preferences.flush
      */
     flushSync(): void;
+
+    /**
+     * Asynchronously saves the {@link Storage} object to the file.
+     *
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.flush
+     */
     flush(callback: AsyncCallback<void>): void;
+
+    /**
+     * Asynchronously saves the {@link Storage} object to the file.
+     *
+     * @throws BusinessError if invoked failed
+     * @since 6
+     * @deprecated since 9
+     * @useinstead ohos.preferences.preferences.flush
+     */
     flush(): Promise<void>;
 
     /**
@@ -222,6 +463,9 @@ declare namespace storage {
 
   /**
    * Indicates possible value types
+   * 
+   * @since 6
+   * @deprecated since 9
    */
   type ValueType = number | string | boolean;
 
@@ -236,19 +480,34 @@ declare namespace storage {
   interface StorageObserver {
     /**
      * Indicates which key changes
+     * 
+     * @since 6
+     * @deprecated since 9
      */
     key: string;
   }
 
   /**
    * Indicates the maximum length of a key (80 characters).
+   * 
+   * @since 6
+   * @deprecated since 9
    */
   const MAX_KEY_LENGTH: 80;
 
   /**
    * Indicates the maximum length of a string (8192 characters).
+   * 
+   * @since 6
+   * @deprecated since 9
    */
   const MAX_VALUE_LENGTH: 8192;
 }
 
+/**
+ * Provides interfaces to obtain and modify storage data.
+ * @since 6
+ * @deprecated since 9
+ * @syscap SystemCapability.DistributedDataManager.Preferences.Core
+ */
 export default storage;
diff --git a/interface_sdk/api/@ohos.data.unifiedDataChannel.d.ts b/interface_sdk/api/@ohos.data.unifiedDataChannel.d.ts
index 4f5f87e09b504093f0c61ff6459fd5f9bae9d854..d9383673b60f036bd51ca44b8189554516d732a6 100644
--- a/interface_sdk/api/@ohos.data.unifiedDataChannel.d.ts
+++ b/interface_sdk/api/@ohos.data.unifiedDataChannel.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -37,6 +37,15 @@ import Want from "./@ohos.app.ability.Want";
  * @atomicservice
  * @since 11
  */
+/**
+ * Provide methods for sharing data between different applications across unified data channels.
+ *
+ * @namespace unifiedDataChannel
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ * @crossplatform
+ * @atomicservice
+ * @since 13
+ */
 declare namespace unifiedDataChannel {
   /**
    * Types of scope that UnifiedData can be used.
@@ -76,12 +85,20 @@ declare namespace unifiedDataChannel {
 
   /**
    * Indicates type of value.
-   * @typedef {number | string | image.PixelMap | Want | ArrayBuffer}
+   * @typedef {number | string | boolean | image.PixelMap | Want | ArrayBuffer | object | null | undefined}
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 12
    */
-  type ValueType = number | string | image.PixelMap | Want | ArrayBuffer;
+  /**
+   * Indicates type of value.
+   * @typedef {number | string | boolean | image.PixelMap | Want | ArrayBuffer | object | null | undefined}
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
+  type ValueType = number | string | boolean | image.PixelMap | Want | ArrayBuffer | object | null | undefined;
 
   /**
    * Describe the unified data properties.
@@ -150,13 +167,21 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified data.
+   *
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class UnifiedData {
     /**
      * Create unified data with a record
      *
      * @param { UnifiedRecord } record - Record will add into unified data.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 10
      */
@@ -165,11 +190,22 @@ declare namespace unifiedDataChannel {
      *
      * @param { UnifiedRecord } record - Record will add into unified data.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+     /**
+     * Create unified data with a record
+     *
+     * @param { UnifiedRecord } record - Record will add into unified data.
+     * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+     * <br>2.Incorrect Parameters types.
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     constructor(record: UnifiedRecord);
     /**
      * Create a empty unified data.
@@ -178,13 +214,21 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 12
      */
+    /**
+     * Create a empty unified data.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     constructor();
     /**
      * Add a record into unified data
      *
      * @param { UnifiedRecord } record - Record will add into unified data.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 10
      */
@@ -193,11 +237,22 @@ declare namespace unifiedDataChannel {
      *
      * @param { UnifiedRecord } record - Record will add into unified data.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Add a record into unified data
+     *
+     * @param { UnifiedRecord } record - Record will add into unified data.
+     * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+     * <br>2.Incorrect Parameters types.
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     addRecord(record: UnifiedRecord): void;
     /**
      * Get all records of unified data
@@ -214,6 +269,15 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 11
      */
+     /**
+     * Get all records of unified data
+     *
+     * @returns { Array<UnifiedRecord> } Return the records of unified data
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     getRecords(): Array<UnifiedRecord>;
 
     /**
@@ -221,11 +285,22 @@ declare namespace unifiedDataChannel {
      * @param { string } type - indicates to query data type.
      * @returns { boolean } if having mimeType in UnifiedData returns true, else returns false.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 12
      */
+    /**
+     * Checks whether there is a specified type of data in DataProperties.
+     * @param { string } type - indicates to query data type.
+     * @returns { boolean } if having mimeType in UnifiedData returns true, else returns false.
+     * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+     * <br>2.Incorrect Parameters types.
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     hasType(type: string): boolean;
 
     /**
@@ -235,6 +310,14 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 12
      */
+    /**
+     * UTD types of all content in the UnifiedData.
+     * @returns { Array<string> } type of array
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     getTypes(): Array<string>;
 
     /**
@@ -270,6 +353,7 @@ declare namespace unifiedDataChannel {
     /**
      * A map for each type and data size, key is data type, value is the corresponding data size
      *
+     * @type { Record<string, number> }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -284,6 +368,7 @@ declare namespace unifiedDataChannel {
     /**
      * Total data size of data in Bytes
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -304,6 +389,14 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified record
+   *
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class UnifiedRecord {
     /**
      * Get type of unified record
@@ -320,6 +413,15 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Get type of unified record
+     *
+     * @returns { string } Return the type of unified data
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     getType(): string;
 
     /**
@@ -329,6 +431,14 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 12
      */
+    /**
+     * Create unified record.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     constructor();
 
     /**
@@ -337,12 +447,25 @@ declare namespace unifiedDataChannel {
      * @param { string } type - indicates to data type of unified record. It can not be empty. When type of value is object, parameter type must be pixel-map or want UTD type.
      * @param { ValueType } value - indicates to value of unified record.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types;
+     * <br>2.Incorrect parameters types;
      * <br>3.Parameter verification failed.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 12
      */
+    /**
+     * Create unified record by type and value.
+     *
+     * @param { string } type - indicates to data type of unified record. It can not be empty. When type of value is object, parameter type must be pixel-map or want UTD type.
+     * @param { ValueType } value - indicates to value of unified record.
+     * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+     * <br>2.Incorrect Parameters types;
+     * <br>3.Parameter verification failed.
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     constructor(type: string, value: ValueType);
 
     /**
@@ -353,6 +476,15 @@ declare namespace unifiedDataChannel {
      * @atomicservice
      * @since 12
      */
+    /**
+     * Get the value of unified record.
+     *
+     * @returns { ValueType } Return the value of unified record.
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     getValue(): ValueType;
   }
 
@@ -371,6 +503,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified text data
+   *
+   * @extends UnifiedRecord
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Text extends UnifiedRecord {
     /**
      * Indicates the details of unified text
@@ -381,10 +522,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the details of unified text
      *
+     * @type { ?Record<string, string> }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the details of unified text
+     *
+     * @type { ?Record<string, string> }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     details?: Record<string, string>;
   }
 
@@ -403,6 +554,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified plain text data
+   *
+   * @extends Text
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class PlainText extends Text {
     /**
      * Indicates the content of text
@@ -413,10 +573,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the content of text
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the content of text
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     textContent: string;
     /**
      * Indicates the abstract of text
@@ -427,10 +597,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the abstract of text
      *
+     * @type { ?string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the abstract of text
+     *
+     * @type { ?string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     abstract?: string;
   }
 
@@ -449,6 +629,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified link data
+   *
+   * @extends Text
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Hyperlink extends Text {
     /**
      * Indicates the url of a link
@@ -459,10 +648,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the url of a link
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the url of a link
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     url: string;
     /**
      * Indicates the description of a link
@@ -473,10 +672,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the description of a link
      *
+     * @type { ?string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the description of a link
+     *
+     * @type { ?string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     description?: string;
   }
 
@@ -495,6 +704,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified html data
+   *
+   * @extends Text
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class HTML extends Text {
     /**
      * Indicates the content of html, with html tags
@@ -505,10 +723,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the content of html, with html tags
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the content of html, with html tags
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     htmlContent: string;
     /**
      * Indicates the plain content of html
@@ -519,10 +747,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the plain content of html
      *
+     * @type { ?string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the plain content of html
+     *
+     * @type { ?string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     plainContent?: string;
   }
 
@@ -541,6 +779,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified file data
+   *
+   * @extends UnifiedRecord
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class File extends UnifiedRecord {
     /**
      * Indicates the details of unified File
@@ -551,10 +798,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the details of unified File
      *
+     * @type { ?Record<string, string> }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the details of unified File
+     *
+     * @type { ?Record<string, string> }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     details?: Record<string, string>;
     /**
      * Indicates the uri of file
@@ -565,10 +822,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the uri of file
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the uri of file
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     uri: string;
   }
 
@@ -587,6 +854,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified image data
+   *
+   * @extends File
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Image extends File {
     /**
      * Indicates the uri of image
@@ -597,10 +873,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the uri of image
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the uri of image
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     imageUri: string;
   }
 
@@ -619,6 +905,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified video data
+   *
+   * @extends File
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Video extends File {
     /**
      * Indicates the uri of video
@@ -629,10 +924,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the uri of video
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the uri of video
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     videoUri: string;
   }
 
@@ -651,6 +956,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified audio data
+   *
+   * @extends File
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Audio extends File {
     /**
      * Indicates the uri of audio
@@ -661,10 +975,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the uri of audio
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the uri of audio
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     audioUri: string;
   }
 
@@ -683,6 +1007,15 @@ declare namespace unifiedDataChannel {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Describe the unified folder data
+   *
+   * @extends File
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   class Folder extends File {
     /**
      * Indicates the uri of folder
@@ -693,10 +1026,20 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the uri of folder
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
      */
+    /**
+     * Indicates the uri of folder
+     *
+     * @type { string }
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     folderUri: string;
   }
 
@@ -727,6 +1070,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the details of system defined data
      *
+     * @type { ?Record<string, number | string | Uint8Array> }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -761,6 +1105,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the id of form
      *
+     * @type { number }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -775,6 +1120,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the name of form
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -789,6 +1135,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the bundle name of form
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -803,6 +1150,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the ability name of form
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -817,6 +1165,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the module of form
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -851,6 +1200,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the app id
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -865,6 +1215,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the app name
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -879,6 +1230,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the id of app icon
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -893,6 +1245,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the id of app label
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -907,6 +1260,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the bundle name of app
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -921,6 +1275,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the ability name of app
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -955,6 +1310,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the raw data of pixel map
      *
+     * @type { Uint8Array }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -991,6 +1347,7 @@ declare namespace unifiedDataChannel {
      * Indicates the type of data, should always be started with 'ApplicationDefined.', will
      * return error otherwise
      *
+     * @type { string }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -1005,6 +1362,7 @@ declare namespace unifiedDataChannel {
     /**
      * Indicates the raw data of application defined data
      *
+     * @type { Uint8Array }
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
@@ -1063,6 +1421,7 @@ declare namespace unifiedDataChannel {
   /**
    * Describe the optional arguments of data operation
    *
+   * @typedef { object }
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1105,9 +1464,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the intention field to indicate the target {@link Intention}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to insert into target intention.
    * @param { AsyncCallback<string> } callback - {string}: the unique identifier.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1117,9 +1475,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the intention field to indicate the target {@link Intention}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to insert into target intention.
    * @param { AsyncCallback<string> } callback - {string}: the unique identifier.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1132,9 +1489,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the intention field to indicate the target {@link Intention}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to insert into target intention.
    * @returns { Promise<string> } {string}: the unique identifier.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1144,9 +1500,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the intention field to indicate the target {@link Intention}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to insert into target intention.
    * @returns { Promise<string> } {string}: the unique identifier.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1159,9 +1514,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the unique identifier field to indicate the target {@link UnifiedData}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to update the target data.
    * @param { AsyncCallback<void> } callback - the callback of updateData.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1171,9 +1525,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the unique identifier field to indicate the target {@link UnifiedData}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to update the target data.
    * @param { AsyncCallback<void> } callback - the callback of updateData.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1186,9 +1539,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the unique identifier field to indicate the target {@link UnifiedData}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to update the target data.
    * @returns { Promise<void> } the promise returned by the function.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1198,9 +1550,8 @@ declare namespace unifiedDataChannel {
    * @param { Options } options - fill the unique identifier field to indicate the target {@link UnifiedData}.
    * @param { UnifiedData } data - {@link UnifiedData} data object to update the target data.
    * @returns { Promise<void> } the promise returned by the function.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1212,9 +1563,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @param { AsyncCallback<Array<UnifiedData>> } callback - {Array<UnifiedData>}: the target {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1223,9 +1573,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @param { AsyncCallback<Array<UnifiedData>> } callback - {Array<UnifiedData>}: the target {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1237,9 +1586,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @returns { Promise<Array<UnifiedData>> } {Array<UnifiedData>}: the target {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1248,9 +1596,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @returns { Promise<Array<UnifiedData>> } {Array<UnifiedData>}: the target {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1262,9 +1609,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @param { AsyncCallback<Array<UnifiedData>> } callback - {Array<UnifiedData>}: the deleted {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1273,9 +1619,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @param { AsyncCallback<Array<UnifiedData>> } callback - {Array<UnifiedData>}: the deleted {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1287,9 +1632,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @returns { Promise<Array<UnifiedData>> } {Array<UnifiedData>}: the deleted {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 10
    */
@@ -1298,9 +1642,8 @@ declare namespace unifiedDataChannel {
    *
    * @param { Options } options - fill the intention or unique identifier field to indicate the target {@link Intention} or {@link UnifiedData}.
    * @returns { Promise<Array<UnifiedData>> } {Array<UnifiedData>}: the deleted {@link UnifiedData} object array.
-   * @throws { BusinessError } 201 - Permission denied.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @atomicservice
    * @since 11
@@ -1310,8 +1653,8 @@ declare namespace unifiedDataChannel {
   /**
    * Set app sharing options.
    *
-   * @param { intention } Describe the sharing channel that UDMF support.
-   * @param { shareOptions } Types of scope that UnifiedData can be used.
+   * @param { Intention } intention - Describe the sharing channel that UDMF support.
+   * @param { ShareOptions } shareOptions - Types of scope that UnifiedData can be used.
    * @throws { BusinessError } 202 - Permission verification failed, application which is not a system application uses system API.
    * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
    *                                                                   2. Incorrect parameter types.
@@ -1326,7 +1669,7 @@ declare namespace unifiedDataChannel {
    /**
     * Remove app sharing options.
     *
-    * @param { intention } Describe the sharing channel that UDMF support.
+    * @param { Intention } intention - Describe the sharing channel that UDMF support.
     * @throws { BusinessError } 202 - Permission verification failed, application which is not a system application uses system API.
     * @throws { BusinessError } 401 - Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;
     *                                                                   2. Incorrect parameter types.
diff --git a/interface_sdk/api/@ohos.data.uniformDataStruct.d.ts b/interface_sdk/api/@ohos.data.uniformDataStruct.d.ts
index 0209ccf0e7fb16eb7dd296f7b783cc2ac9a7c66b..adb83f2e52a220e949abfcceb43040e0e158d45b 100644
--- a/interface_sdk/api/@ohos.data.uniformDataStruct.d.ts
+++ b/interface_sdk/api/@ohos.data.uniformDataStruct.d.ts
@@ -38,10 +38,11 @@ declare namespace uniformDataStruct {
      * Indicates the uniform data type of this data struct.
      * 
      * @type { 'general.plain-text' }
+     * @readonly
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 12
      */
-    uniformDataType: 'general.plain-text';
+    readonly uniformDataType: 'general.plain-text';
     /**
      * Indicates the content of the PlainText.
      *
@@ -80,10 +81,11 @@ declare namespace uniformDataStruct {
      * Indicates the uniform data type of this data struct.
      * 
      * @type { 'general.hyperlink' }
+     * @readonly
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 12
      */
-    uniformDataType: 'general.hyperlink';
+    readonly uniformDataType: 'general.hyperlink';
     /**
      * Indicates the url of of the Hyperlink.
      *
@@ -121,10 +123,11 @@ declare namespace uniformDataStruct {
      * Indicates the uniform data type of this data struct.
      * 
      * @type { 'general.html' }
+     * @readonly
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 12
      */
-    uniformDataType: 'general.html';
+    readonly uniformDataType: 'general.html';
 
     /**
      * Indicates the content of html, with html tags.
@@ -164,10 +167,11 @@ declare namespace uniformDataStruct {
      * Indicates the uniform data type of this data struct.
      * 
      * @type { 'openharmony.app-item' }
+     * @readonly
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 12
      */
-    uniformDataType: 'openharmony.app-item';
+    readonly uniformDataType: 'openharmony.app-item';
     /**
      * Indicates the app id.
      *
@@ -223,7 +227,7 @@ declare namespace uniformDataStruct {
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 12
      */
-     details?: Record<string, number | string | Uint8Array>;
+    details?: Record<string, number | string | Uint8Array>;
   }
 }
 
diff --git a/interface_sdk/api/@ohos.data.uniformTypeDescriptor.d.ts b/interface_sdk/api/@ohos.data.uniformTypeDescriptor.d.ts
index 64e93dac06a3f6f5361e1560785f98064079ab19..b38c554ec81cd9e6d98f7a84e29fab670a7816de 100644
--- a/interface_sdk/api/@ohos.data.uniformTypeDescriptor.d.ts
+++ b/interface_sdk/api/@ohos.data.uniformTypeDescriptor.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -33,6 +33,15 @@
  * @atomicservice
  * @since 11
  */
+/**
+ * Provides methods for uniform data type definition and query.
+ *
+ * @namespace uniformTypeDescriptor
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ * @crossplatform
+ * @atomicservice
+ * @since 13
+ */
 declare namespace uniformTypeDescriptor {
   /**
    * Uniform data type IDs.
@@ -49,6 +58,15 @@ declare namespace uniformTypeDescriptor {
    * @atomicservice
    * @since 11
    */
+  /**
+   * Uniform data type IDs.
+   *
+   * @enum { string }
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @crossplatform
+   * @atomicservice
+   * @since 13
+   */
   enum UniformDataType {
     /**
      * Base data type for physical hierarchy, which identifies the physical representation of the data type.
@@ -87,6 +105,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Text data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     TEXT = 'general.text',
 
     /**
@@ -102,6 +128,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Plain text data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     PLAIN_TEXT = 'general.plain-text',
 
     /**
@@ -117,6 +151,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * HTML data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     HTML = 'general.html',
 
     /**
@@ -132,6 +174,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Hyperlink data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     HYPERLINK = 'general.hyperlink',
 
     /**
@@ -418,7 +468,15 @@ declare namespace uniformTypeDescriptor {
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @atomicservice
      * @since 11
-     */    
+     */
+    /**
+     * Image data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     IMAGE = 'general.image',
 
     /**
@@ -658,6 +716,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Video data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     VIDEO = 'general.video',
 
     /**
@@ -793,6 +859,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Audio data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     AUDIO = 'general.audio',
 
     /**
@@ -968,6 +1042,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * File data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     FILE = 'general.file',
 
     /**
@@ -991,6 +1073,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * Folder data type.
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     FOLDER = 'general.folder',
 
     /**
@@ -1452,6 +1542,14 @@ declare namespace uniformTypeDescriptor {
      * @atomicservice
      * @since 11
      */
+    /**
+     * OpenHarmony system defined pixel map data type(the data is provided and bound to OpenHarmony system).
+     *
+     * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+     * @crossplatform
+     * @atomicservice
+     * @since 13
+     */
     OPENHARMONY_PIXEL_MAP = 'openharmony.pixel-map',
 
     /**
@@ -1620,7 +1718,7 @@ declare namespace uniformTypeDescriptor {
      * @param { string } type - A uniform data type to be compared.
      * @returns { boolean } Returns true if the data type belongs to the given data type, else false.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 11
      */
@@ -1632,7 +1730,7 @@ declare namespace uniformTypeDescriptor {
      * @param { string } type - A uniform data type to be compared.
      * @returns { boolean } Returns true if the data type is the lower level type of the given data type, else false.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 11
      */
@@ -1644,7 +1742,7 @@ declare namespace uniformTypeDescriptor {
      * @param { string } type - A uniform data type to be compared.
      * @returns { boolean } Returns true if the data type is the higher level type of the given data type, else false.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 11
      */
@@ -1656,7 +1754,7 @@ declare namespace uniformTypeDescriptor {
      * @param { TypeDescriptor } typeDescriptor - A uniform type descriptor to be compared.
      * @returns { boolean } Returns true if the type descriptor is equal to the given type descriptor, else false.
      * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-     * <br>2.Incorrect Parameters types.
+     * <br>2.Incorrect parameters types.
      * @syscap SystemCapability.DistributedDataManager.UDMF.Core
      * @since 11
      */
@@ -1670,7 +1768,7 @@ declare namespace uniformTypeDescriptor {
    * @returns { TypeDescriptor } Returns the uniform type descriptor corresponding to the uniform data type ID or null
    * <br>if the uniform data type does not exist.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 11
    */
@@ -1684,7 +1782,7 @@ declare namespace uniformTypeDescriptor {
    * @returns { string } Returns the uniform data type ID corresponding to the given filename extension and the
    * <br>uniform data type it belongs to(If the 'belongsTo' parameter is set) or flexible type if the uniform data type does not exist.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 11
    */
@@ -1698,11 +1796,39 @@ declare namespace uniformTypeDescriptor {
    * @returns { string } Returns the uniform data type ID corresponding to the given MIME type and the uniform data type
    * <br>it belongs to(If the 'belongsTo' parameter is set) or flexible type if the uniform data type does not exist.
    * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
-   * <br>2.Incorrect Parameters types.
+   * <br>2.Incorrect parameters types.
    * @syscap SystemCapability.DistributedDataManager.UDMF.Core
    * @since 11
    */
   function getUniformDataTypeByMIMEType(mimeType: string, belongsTo?: string): string;
+
+  /**
+   * Queries and returns the uniform type descriptor list by the given filename extension and the uniform data type it belongs to.
+   *
+   * @param { string } filenameExtension - Filename extension.
+   * @param { string } [belongsTo] - A uniform data type ID it belongs to.
+   * @returns { Array<string> } Returns the uniform data type ID list corresponding to the given filename extension and the
+   * <br>uniform data type it belongs to(If the 'belongsTo' parameter is set) or flexible type if the uniform data type does not exist.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+   * <br>2.Incorrect Parameters types.
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @since 13
+   */
+  function getUniformDataTypesByFilenameExtension(filenameExtension: string, belongsTo?: string): Array<string>;
+
+  /**
+   * Queries and returns the uniform type descriptor list by the given MIME type and the uniform data type it belongs to.
+   *
+   * @param { string } mimeType - MIME type.
+   * @param { string } [belongsTo] - A uniform data type ID it belongs to.
+   * @returns { Array<string> } Returns the uniform data type ID list corresponding to the given MIME type and the uniform data type
+   * <br>it belongs to(If the 'belongsTo' parameter is set) or flexible type if the uniform data type does not exist.
+   * @throws { BusinessError } 401 - Parameter error. Possible causes:1.Mandatory parameters are left unspecified;
+   * <br>2.Incorrect Parameters types.
+   * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+   * @since 13
+   */
+  function getUniformDataTypesByMIMEType(mimeType: string, belongsTo?: string): Array<string>;
 }
 
 export default uniformTypeDescriptor;
diff --git a/kv_store/bundle.json b/kv_store/bundle.json
index 81de03108d609870356b09dff10c42480cd57ce3..b938a590d50878dccd6ea0e3fcd37df3ab0bd9b8 100644
--- a/kv_store/bundle.json
+++ b/kv_store/bundle.json
@@ -63,9 +63,11 @@
         "ability_base",
         "ability_runtime",
         "bundle_framework",
+        "access_token",
         "common_event_service",
         "c_utils",
         "device_manager",
+        "dmsfwk",
         "ffrt",
         "hilog",
         "hisysevent",
diff --git a/kv_store/frameworks/CMakeLists.txt b/kv_store/frameworks/CMakeLists.txt
index 33ed5518a761b4bfcc8c24c5c7fff7beac4c6433..1b32866aa40e9c782ef52e2278463c1c220af1a2 100644
--- a/kv_store/frameworks/CMakeLists.txt
+++ b/kv_store/frameworks/CMakeLists.txt
@@ -15,6 +15,8 @@ aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/innerkitsimpl/distributeddatasv
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/innerkitsimpl/kvdb/src kvdbSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/jskitsimpl/distributedkvstore/src jsKVSrc)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/jskitsimpl/distributeddata/src jsDataSrc)
+list(REMOVE_ITEM kvdbSrc "${CMAKE_CURRENT_SOURCE_DIR}/innerkitsimpl/kvdb/src/auto_sync_timer_mock.cpp")
+list(REMOVE_ITEM kvdbSrc "${CMAKE_CURRENT_SOURCE_DIR}/innerkitsimpl/kvdb/src/kv_hiview_reporter_mock.cpp")
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../utils_native/base/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../utils_native/safwk/native/include)
diff --git a/kv_store/frameworks/cj/include/distributed_kv_store_ffi.h b/kv_store/frameworks/cj/include/distributed_kv_store_ffi.h
index 69168862ce09258bbc31bd97e98a391c9712172c..25a1a2527202389cf94a530c4ba3031d8f2784d9 100644
--- a/kv_store/frameworks/cj/include/distributed_kv_store_ffi.h
+++ b/kv_store/frameworks/cj/include/distributed_kv_store_ffi.h
@@ -41,6 +41,12 @@ extern "C" {
 
     FFI_EXPORT CArrStr FfiOHOSDistributedKVStoreGetAllKVStoreId(int64_t id, const char* appId, int32_t* errCode);
 
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreOnDistributedDataServiceDie(int64_t id, void (*callbackId)());
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreOffDistributedDataServiceDie(int64_t id, void (*callbackId)());
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreOffAllDistributedDataServiceDie(int64_t id);
+
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStorePut(int64_t id, const char* key, ValueType value);
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStorePutBatch(int64_t id, const CArrEntry cArrEntry);
@@ -49,12 +55,34 @@ extern "C" {
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreDeleteBatch(int64_t id, const CArrStr cArrStr);
 
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreRemoveDeviceData(int64_t id, const char* deviceId);
+
     FFI_EXPORT ValueType FfiOHOSDistributedKVStoreSingleKVStoreGet(int64_t id, const char* key, int32_t* errCode);
 
+    FFI_EXPORT CArrEntry FfiOHOSDistributedKVStoreSingleKVStoreGetEntriesByQuery(int64_t id,
+        int64_t queryId, int32_t* errCode);
+
+    FFI_EXPORT CArrEntry FfiOHOSDistributedKVStoreSingleKVStoreGetEntriesByString(int64_t id,
+        const char* prefix, int32_t* errCode);
+
+    FFI_EXPORT int64_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSetByString(int64_t id,
+        const char* keyPrefix, int32_t* errCode);
+
+    FFI_EXPORT int64_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSetByQuery(int64_t id,
+        int64_t queryId, int32_t* errCode);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreCloseResultSet(int64_t id, int64_t resultSetId);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSize(int64_t id,
+        int64_t queryId, int32_t* errCode);
+
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreBackup(int64_t id, const char* file);
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreRestore(int64_t id, const char* file);
 
+    FFI_EXPORT CStringNum FfiOHOSDistributedKVStoreSingleKVStoreDeleteBackup(int64_t id,
+        const CArrStr cArrStr, int32_t* errCode);
+
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreStartTransaction(int64_t id);
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreCommit(int64_t id);
@@ -63,14 +91,87 @@ extern "C" {
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreEnableSync(int64_t id, bool enabled);
 
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreSetSyncRange(int64_t id, const CArrStr localLabels,
+        const CArrStr remoteSupportLabels);
+
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreSetSyncParam(int64_t id, uint32_t defaultAllowedDelayMs);
 
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreSync(int64_t id, const CArrStr deviceIds, uint8_t mode,
+        uint32_t delayMs);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreSyncByQuery(int64_t id, const CArrStr deviceIds,
+        int64_t queryId, uint8_t mode, uint32_t delayMs);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreOnDataChange(int64_t id, uint8_t type,
+        void (*callbackId)(const CChangeNotification valueRef));
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffDataChange(int64_t id,
+        void (*callbackId)(const CChangeNotification valueRef));
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffAllDataChange(int64_t id);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreOnSyncComplete(int64_t id,
+        void (*callbackId)(const CStringNum valueRef));
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffAllSyncComplete(int64_t id);
+
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreSingleKVStoreGetSecurityLevel(int64_t id, int32_t* errCode);
+
     FFI_EXPORT int64_t FfiOHOSDistributedKVStoreQueryConstructor();
 
     FFI_EXPORT void FfiOHOSDistributedKVStoreQueryReset(int64_t id);
 
     FFI_EXPORT void FfiOHOSDistributedKVStoreQueryEqualTo(int64_t id, const char* field, ValueType value);
 
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryNotEqualTo(int64_t id, const char* field, ValueType value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryGreaterThan(int64_t id, const char* field, ValueType value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryLessThan(int64_t id, const char* field, ValueType value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryGreaterThanOrEqualTo(int64_t id, const char* field, ValueType value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryLessThanOrEqualTo(int64_t id, const char* field, ValueType value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryIsNull(int64_t id, const char* field);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryInNumber(int64_t id, const char* field, const CArrNumber valueList);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryInString(int64_t id, const char* field, const CArrStr valueList);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryNotInNumber(int64_t id, const char* field,
+        const CArrNumber valueList);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryNotInString(int64_t id, const char* field, const CArrStr valueList);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryLike(int64_t id, const char* field, const char* value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryUnlike(int64_t id, const char* field, const char* value);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryAnd(int64_t id);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryOr(int64_t id);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryOrderByAsc(int64_t id, const char* field);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryOrderByDesc(int64_t id, const char* field);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryLimit(int64_t id, int32_t total, int32_t offset);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryIsNotNull(int64_t id, const char* field);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryBeginGroup(int64_t id);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryEndGroup(int64_t id);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryPrefixKey(int64_t id, const char* prefix);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQuerySetSuggestIndex(int64_t id, const char* index);
+
+    FFI_EXPORT void FfiOHOSDistributedKVStoreQueryDeviceId(int64_t id, const char* deviceId);
+
+    FFI_EXPORT const char* FfiOHOSDistributedKVStoreQueryGetSqlLike(int64_t id);
+
     FFI_EXPORT ValueType FfiOHOSDistributedKVStoreDeviceKVStoreGet(int64_t id, const char* deviceId, const char* key,
         int32_t* errCode);
 
@@ -90,8 +191,31 @@ extern "C" {
         int64_t queryId, int32_t* errCode);
 
     FFI_EXPORT int32_t FfiOHOSDistributedKVStoreKVStoreResultSetGetCount(int64_t id);
-}
 
+    FFI_EXPORT int32_t FfiOHOSDistributedKVStoreKVStoreResultSetGetPosition(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToFirst(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToLast(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToNext(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToPrevious(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMove(int64_t id, int32_t offset);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToPosition(int64_t id, int32_t position);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetIsFirst(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetIsLast(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetIsBeforeFirst(int64_t id);
+
+    FFI_EXPORT bool FfiOHOSDistributedKVStoreKVStoreResultSetIsAfterLast(int64_t id);
+
+    FFI_EXPORT CEntry FfiOHOSDistributedKVStoreKVStoreResultSetGetEntry(int64_t id);
+}
 }
 }
 
diff --git a/kv_store/frameworks/cj/include/distributed_kv_store_impl.h b/kv_store/frameworks/cj/include/distributed_kv_store_impl.h
index a09ba1e925d0f04f9949f9c5970351411692bf86..f9f0fb186dc454382594d600ea975e9b7b791605 100644
--- a/kv_store/frameworks/cj/include/distributed_kv_store_impl.h
+++ b/kv_store/frameworks/cj/include/distributed_kv_store_impl.h
@@ -27,6 +27,13 @@
 namespace OHOS {
 namespace DistributedKVStore {
 using namespace OHOS::DistributedKv;
+enum {
+    /* exported cj SubscribeType  is (DistributedKv::SubscribeType-1) */
+    SUBSCRIBE_LOCAL = 0,        /* i.e. SubscribeType::SUBSCRIBE_TYPE_LOCAL-1  */
+    SUBSCRIBE_REMOTE = 1,       /* i.e. SubscribeType::SUBSCRIBE_TYPE_REMOTE-1 */
+    SUBSCRIBE_LOCAL_REMOTE = 2, /* i.e. SubscribeType::SUBSCRIBE_TYPE_ALL-1   */
+    SUBSCRIBE_COUNT = 3
+};
 
 struct ContextParam {
     std::string baseDir = "";
@@ -68,6 +75,14 @@ struct CArrStr {
     int64_t size;
 };
 
+struct CArrNumber {
+    int32_t* intList;
+    float* floatList;
+    double* doubleList;
+    int64_t size;
+    uint8_t tag;
+};
+
 struct ValueType {
     char* string;
     int32_t integer;
@@ -78,6 +93,12 @@ struct ValueType {
     uint8_t tag;
 };
 
+struct CStringNum {
+    char** headChar;
+    int32_t* headNum;
+    int64_t size;
+};
+
 struct CEntry {
     char *key;
     ValueType value;
@@ -88,6 +109,62 @@ struct CArrEntry {
     int64_t size;
 };
 
+struct CChangeNotification {
+    CArrEntry insertEntries;
+    CArrEntry updateEntries;
+    CArrEntry deleteEntries;
+    char* deviceId;
+};
+
+class CKvStoreResultSet : public OHOS::FFI::FFIData {
+public:
+    OHOS::FFI::RuntimeType* GetRuntimeType() override
+    {
+        return GetClassType();
+    }
+
+    explicit CKvStoreResultSet(std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet);
+
+    std::shared_ptr<DistributedKv::KvStoreResultSet> GetKvStoreResultSet();
+
+    int32_t GetCount();
+
+    int32_t GetPosition();
+
+    bool MoveToFirst();
+
+    bool MoveToLast();
+
+    bool MoveToNext();
+
+    bool MoveToPrevious();
+
+    bool Move(int32_t offset);
+
+    bool MoveToPosition(int32_t position);
+
+    bool IsFirst();
+
+    bool IsLast();
+
+    bool IsBeforeFirst();
+
+    bool IsAfterLast();
+
+    CEntry GetEntry();
+
+private:
+    std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
+    friend class OHOS::FFI::RuntimeType;
+    friend class OHOS::FFI::TypeBase;
+    static OHOS::FFI::RuntimeType* GetClassType()
+    {
+        static OHOS::FFI::RuntimeType runtimeType =
+            OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("CKvStoreResultSet");
+        return &runtimeType;
+    }
+};
+
 class CJKVManager : public OHOS::FFI::FFIData {
 public:
     OHOS::FFI::RuntimeType* GetRuntimeType() override
@@ -102,8 +179,22 @@ public:
     int32_t CloseKVStore(const char* appId, const char* storeId);
     int32_t DeleteKVStore(const char* appId, const char* storeId);
     CArrStr GetAllKVStoreId(const char* appId, int32_t& errCode);
+    int32_t OnDistributedDataServiceDie(void (*callbackId)());
+    int32_t OffDistributedDataServiceDie(void (*callbackId)());
+    int32_t OffAllDistributedDataServiceDie();
+
 private:
+    class DeathRecipient : public DistributedKv::KvStoreDeathRecipient {
+    public:
+        DeathRecipient(void (*callbackId)(), const std::function<void()>& callbackRef);
+        virtual ~DeathRecipient() = default;
+        void OnRemoteDied() override;
+        void (*m_callbackId)();
+        std::function<void()> m_callbackRef;
+    };
     DistributedKv::DistributedKvDataManager kvDataManager_ {};
+    std::mutex deathMutex_ {};
+    std::list<std::shared_ptr<DeathRecipient>> deathRecipient_;
     std::string bundleName_ {};
     std::shared_ptr<ContextParam> param_;
     friend class OHOS::FFI::RuntimeType;
@@ -114,6 +205,79 @@ private:
         return &runtimeType;
     }
 };
+class CQuery : public OHOS::FFI::FFIData {
+public:
+    OHOS::FFI::RuntimeType* GetRuntimeType() override
+    {
+        return GetClassType();
+    }
+
+    CQuery() {};
+
+    const DistributedKv::DataQuery& GetDataQuery() const;
+
+    void Reset();
+
+    void EqualTo(const std::string &field, ValueType &value);
+
+    void NotEqualTo(const std::string &field, ValueType &value);
+
+    void GreaterThan(const std::string &field, ValueType &value);
+
+    void LessThan(const std::string &field, ValueType &value);
+
+    void GreaterThanOrEqualTo(const std::string &field, ValueType &value);
+
+    void LessThanOrEqualTo(const std::string &field, ValueType &value);
+
+    void IsNull(const std::string &field);
+
+    void InNumber(const std::string &field, const CArrNumber &valueList);
+
+    void InString(const std::string &field, const CArrStr &valueList);
+
+    void NotInNumber(const std::string &field, const CArrNumber &valueList);
+
+    void NotInString(const std::string &field, const CArrStr &valueList);
+
+    void Like(const std::string &field, const std::string &value);
+
+    void Unlike(const std::string &field, const std::string &value);
+
+    void And();
+
+    void Or();
+
+    void OrderByAsc(const std::string &field);
+
+    void OrderByDesc(const std::string &field);
+
+    void Limit(int32_t total, int32_t offset);
+
+    void IsNotNull(const std::string &field);
+
+    void BeginGroup();
+
+    void EndGroup();
+
+    void PrefixKey(const std::string &prefix);
+
+    void SetSuggestIndex(const std::string &index);
+
+    void DeviceId(const std::string &deviceId);
+
+    const std::string GetSqlLike();
+
+private:
+    DistributedKv::DataQuery query_;
+    friend class OHOS::FFI::RuntimeType;
+    friend class OHOS::FFI::TypeBase;
+    static OHOS::FFI::RuntimeType* GetClassType()
+    {
+        static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("CQuery");
+        return &runtimeType;
+    }
+};
 
 class CJSingleKVStore : public OHOS::FFI::FFIData {
 public:
@@ -131,17 +295,51 @@ public:
     int32_t PutBatch(const CArrEntry &cArrEntry);
     int32_t Delete(const std::string &key);
     int32_t DeleteBatch(const CArrStr &cArrStr);
+    int32_t RemoveDeviceData(const std::string &deviceId);
     ValueType Get(const std::string &key, int32_t& errCode);
+    CArrEntry GetEntries(OHOS::sptr<CQuery> query, int32_t& errCode);
+    CArrEntry GetEntries(const std::string &keyPrefix, int32_t& errCode);
+    int64_t GetResultSetByString(const std::string &keyPrefix, int32_t& errCode);
+    int64_t GetResultSetByQuery(OHOS::sptr<CQuery> query, int32_t& errCode);
+    int32_t CloseResultSet(OHOS::sptr<CKvStoreResultSet> resultSet);
+    int32_t GetResultSize(OHOS::sptr<CQuery> query, int32_t& errCode);
     int32_t Backup(const std::string &file);
     int32_t Restore(const std::string &file);
+    CStringNum DeleteBackup(const CArrStr &cArrStr, int32_t& errCode);
     int32_t StartTransaction();
     int32_t Commit();
     int32_t Rollback();
     int32_t EnableSync(bool enabled);
+    int32_t SetSyncRange(const CArrStr &localLabels, const CArrStr &remoteSupportLabels);
     int32_t SetSyncParam(uint32_t defaultAllowedDelayMs);
+    int32_t Sync(const CArrStr deviceIds, uint8_t mode, uint32_t delayMs);
+    int32_t SyncByQuery(const CArrStr deviceIds, OHOS::sptr<CQuery> query, uint8_t mode, uint32_t delayMs);
+    int32_t OnDataChange(uint8_t type, void (*callbackId)(const CChangeNotification valueRef));
+    int32_t OffDataChange(void (*callbackId)(const CChangeNotification valueRef));
+    int32_t OffAllDataChange();
+    int32_t OnSyncComplete(void (*callbackId)(const CStringNum valueRef));
+    int32_t OffAllSyncComplete();
+    int32_t GetSecurityLevel(int32_t& errCode);
 
 private:
-    /* private non-static members */
+    class DataObserver : public DistributedKv::KvStoreObserver {
+    public:
+        DataObserver(void (*callbackId)(const CChangeNotification),
+            const std::function<void(DistributedKv::ChangeNotification)>& callbackRef);
+        virtual ~DataObserver() = default;
+        void OnChange(const DistributedKv::ChangeNotification& notification) override;
+        void (*m_callbackId)(const CChangeNotification);
+        std::function<void(DistributedKv::ChangeNotification)> m_callbackRef;
+    };
+    class SyncObserver : public DistributedKv::KvStoreSyncCallback {
+    public:
+        SyncObserver(void (*callbackId)(const CStringNum),
+            const std::function<void(std::map<std::string, DistributedKv::Status>)>& callbackRef);
+        virtual ~SyncObserver() = default;
+        void SyncCompleted(const std::map<std::string, DistributedKv::Status>& results) override;
+        void (*m_callbackId)(const CStringNum);
+        std::function<void(std::map<std::string, DistributedKv::Status>)> m_callbackRef;
+    };
     std::shared_ptr<DistributedKv::SingleKvStore> kvStore_ = nullptr;
     std::string storeId_;
     std::shared_ptr<ContextParam> param_ = nullptr;
@@ -153,34 +351,10 @@ private:
             OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("CJSingleKVStore");
         return &runtimeType;
     }
+    std::mutex listMutex_ {};
+    std::list<std::shared_ptr<DataObserver>> dataObserver_[SUBSCRIBE_COUNT];
+    std::list<std::shared_ptr<SyncObserver>> syncObservers_;
 };
-
-class CQuery : public OHOS::FFI::FFIData {
-public:
-    OHOS::FFI::RuntimeType* GetRuntimeType() override
-    {
-        return GetClassType();
-    }
-
-    CQuery() {};
-
-    const DistributedKv::DataQuery& GetDataQuery() const;
-
-    void Reset();
-
-    void EqualTo(const std::string &field, ValueType &value);
-
-private:
-    DistributedKv::DataQuery query_;
-    friend class OHOS::FFI::RuntimeType;
-    friend class OHOS::FFI::TypeBase;
-    static OHOS::FFI::RuntimeType* GetClassType()
-    {
-        static OHOS::FFI::RuntimeType runtimeType = OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("CQuery");
-        return &runtimeType;
-    }
-};
-
 class CJDeviceKVStore : public CJSingleKVStore {
 public:
     OHOS::FFI::RuntimeType* GetRuntimeType() override
@@ -214,31 +388,6 @@ private:
         return &runtimeType;
     }
 };
-
-class CKvStoreResultSet : public OHOS::FFI::FFIData {
-public:
-    OHOS::FFI::RuntimeType* GetRuntimeType() override
-    {
-        return GetClassType();
-    }
-
-    explicit CKvStoreResultSet(std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet);
-
-    std::shared_ptr<DistributedKv::KvStoreResultSet> GetKvStoreResultSet();
-
-    int32_t GetCount();
-
-private:
-    std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
-    friend class OHOS::FFI::RuntimeType;
-    friend class OHOS::FFI::TypeBase;
-    static OHOS::FFI::RuntimeType* GetClassType()
-    {
-        static OHOS::FFI::RuntimeType runtimeType =
-            OHOS::FFI::RuntimeType::Create<OHOS::FFI::FFIData>("CKvStoreResultSet");
-        return &runtimeType;
-    }
-};
 }
 } // namespace OHOS::DistributedKVStore
 
diff --git a/kv_store/frameworks/cj/src/distributed_kv_store_ffi.cpp b/kv_store/frameworks/cj/src/distributed_kv_store_ffi.cpp
index d7b69c83b1edb3efee355bb343b385a125ea3258..02bf44bd0598dc5c1ca4028bcd0d0a9be7de5b40 100644
--- a/kv_store/frameworks/cj/src/distributed_kv_store_ffi.cpp
+++ b/kv_store/frameworks/cj/src/distributed_kv_store_ffi.cpp
@@ -73,6 +73,33 @@ CArrStr FfiOHOSDistributedKVStoreGetAllKVStoreId(int64_t id, const char* appId,
     return instance->GetAllKVStoreId(appId, *errCode);
 }
 
+int32_t FfiOHOSDistributedKVStoreOnDistributedDataServiceDie(int64_t id, void (*callbackId)())
+{
+    auto instance = FFIData::GetData<CJKVManager>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OnDistributedDataServiceDie(callbackId);
+}
+
+int32_t FfiOHOSDistributedKVStoreOffDistributedDataServiceDie(int64_t id, void (*callbackId)())
+{
+    auto instance = FFIData::GetData<CJKVManager>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OffDistributedDataServiceDie(callbackId);
+}
+
+int32_t FfiOHOSDistributedKVStoreOffAllDistributedDataServiceDie(int64_t id)
+{
+    auto instance = FFIData::GetData<CJKVManager>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OffAllDistributedDataServiceDie();
+}
+
 int32_t FfiOHOSDistributedKVStoreSingleKVStorePut(int64_t id, const char* key, ValueType value)
 {
     auto instance = FFIData::GetData<CJSingleKVStore>(id);
@@ -109,6 +136,15 @@ int32_t FfiOHOSDistributedKVStoreSingleKVStoreDeleteBatch(int64_t id, const CArr
     return instance->DeleteBatch(cArrStr);
 }
 
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreRemoveDeviceData(int64_t id, const char* deviceId)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->RemoveDeviceData(deviceId);
+}
+
 ValueType FfiOHOSDistributedKVStoreSingleKVStoreGet(int64_t id, const char* key, int32_t* errCode)
 {
     auto instance = FFIData::GetData<CJSingleKVStore>(id);
@@ -119,6 +155,69 @@ ValueType FfiOHOSDistributedKVStoreSingleKVStoreGet(int64_t id, const char* key,
     return instance->Get(key, *errCode);
 }
 
+CArrEntry FfiOHOSDistributedKVStoreSingleKVStoreGetEntriesByQuery(int64_t id, int64_t queryId, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    auto query = FFIData::GetData<CQuery>(queryId);
+    if (instance == nullptr || query == nullptr) {
+        *errCode = -1;
+        return CArrEntry{};
+    }
+    return instance->GetEntries(query, *errCode);
+}
+
+CArrEntry FfiOHOSDistributedKVStoreSingleKVStoreGetEntriesByString(int64_t id, const char* prefix, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        *errCode = -1;
+        return CArrEntry{};
+    }
+    return instance->GetEntries(prefix, *errCode);
+}
+
+int64_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSetByString(int64_t id, const char* keyPrefix, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        *errCode = -1;
+        return 0;
+    }
+    return instance->GetResultSetByString(keyPrefix, *errCode);
+}
+
+int64_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSetByQuery(int64_t id, int64_t queryId, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    auto query = FFIData::GetData<CQuery>(queryId);
+    if (instance == nullptr || query == nullptr) {
+        *errCode = -1;
+        return 0;
+    }
+    return instance->GetResultSetByQuery(query, *errCode);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreCloseResultSet(int64_t id, int64_t resultSetId)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    auto resultSet = FFIData::GetData<CKvStoreResultSet>(resultSetId);
+    if (instance == nullptr || resultSet == nullptr) {
+        return -1;
+    }
+    return instance->CloseResultSet(resultSet);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreGetResultSize(int64_t id, int64_t queryId, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    auto query = FFIData::GetData<CQuery>(queryId);
+    if (instance == nullptr || query == nullptr) {
+        *errCode = -1;
+        return 0;
+    }
+    return instance->GetResultSize(query, *errCode);
+}
+
 int32_t FfiOHOSDistributedKVStoreSingleKVStoreBackup(int64_t id, const char* file)
 {
     auto instance = FFIData::GetData<CJSingleKVStore>(id);
@@ -137,6 +236,17 @@ int32_t FfiOHOSDistributedKVStoreSingleKVStoreRestore(int64_t id, const char* fi
     return instance->Restore(file);
 }
 
+CStringNum FfiOHOSDistributedKVStoreSingleKVStoreDeleteBackup(int64_t id,
+    const CArrStr cArrStr, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        *errCode = -1;
+        return CStringNum{};
+    }
+    return instance->DeleteBackup(cArrStr, *errCode);
+}
+
 int32_t FfiOHOSDistributedKVStoreSingleKVStoreStartTransaction(int64_t id)
 {
     auto instance = FFIData::GetData<CJSingleKVStore>(id);
@@ -173,6 +283,16 @@ int32_t FfiOHOSDistributedKVStoreSingleKVStoreEnableSync(int64_t id, bool enable
     return instance->EnableSync(enabled);
 }
 
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreSetSyncRange(int64_t id, const CArrStr localLabels,
+    const CArrStr remoteSupportLabels)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->SetSyncRange(localLabels, remoteSupportLabels);
+}
+
 int32_t FfiOHOSDistributedKVStoreSingleKVStoreSetSyncParam(int64_t id, uint32_t defaultAllowedDelayMs)
 {
     auto instance = FFIData::GetData<CJSingleKVStore>(id);
@@ -182,6 +302,82 @@ int32_t FfiOHOSDistributedKVStoreSingleKVStoreSetSyncParam(int64_t id, uint32_t
     return instance->SetSyncParam(defaultAllowedDelayMs);
 }
 
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreSync(int64_t id, const CArrStr deviceIds, uint8_t mode, uint32_t delayMs)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->Sync(deviceIds, mode, delayMs);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreSyncByQuery(int64_t id, const CArrStr deviceIds, int64_t queryId,
+    uint8_t mode, uint32_t delayMs)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    auto query = FFIData::GetData<CQuery>(queryId);
+    if (instance == nullptr || query == nullptr) {
+        return -1;
+    }
+    return instance->SyncByQuery(deviceIds, query, mode, delayMs);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreOnDataChange(int64_t id, uint8_t type,
+    void (*callbackId)(const CChangeNotification valueRef))
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OnDataChange(type, callbackId);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffDataChange(int64_t id,
+    void (*callbackId)(const CChangeNotification valueRef))
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OffDataChange(callbackId);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffAllDataChange(int64_t id)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OffAllDataChange();
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreOnSyncComplete(int64_t id, void (*callbackId)(const CStringNum valueRef))
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OnSyncComplete(callbackId);
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreOffAllSyncComplete(int64_t id)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->OffAllSyncComplete();
+}
+
+int32_t FfiOHOSDistributedKVStoreSingleKVStoreGetSecurityLevel(int64_t id, int32_t* errCode)
+{
+    auto instance = FFIData::GetData<CJSingleKVStore>(id);
+    if (instance == nullptr) {
+        *errCode = -1;
+        return 0;
+    }
+    return instance->GetSecurityLevel(*errCode);
+}
 
 int64_t FfiOHOSDistributedKVStoreQueryConstructor()
 {
@@ -210,7 +406,224 @@ void FfiOHOSDistributedKVStoreQueryEqualTo(int64_t id, const char* field, ValueT
     return instance->EqualTo(field, value);
 }
 
-ValueType FfiOHOSDistributedKVStoreDeviceKVStoreGet(int64_t id, const char* deviceId, const char* key, int32_t* errCode)
+void FfiOHOSDistributedKVStoreQueryNotEqualTo(int64_t id, const char* field, ValueType value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->NotEqualTo(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryGreaterThan(int64_t id, const char* field, ValueType value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->GreaterThan(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryLessThan(int64_t id, const char* field, ValueType value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->LessThan(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryGreaterThanOrEqualTo(int64_t id, const char* field, ValueType value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->GreaterThanOrEqualTo(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryLessThanOrEqualTo(int64_t id, const char* field, ValueType value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->LessThanOrEqualTo(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryIsNull(int64_t id, const char* field)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->IsNull(field);
+}
+
+void FfiOHOSDistributedKVStoreQueryInNumber(int64_t id, const char* field, const CArrNumber valueList)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->InNumber(field, valueList);
+}
+
+void FfiOHOSDistributedKVStoreQueryInString(int64_t id, const char* field, const CArrStr valueList)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->InString(field, valueList);
+}
+
+void FfiOHOSDistributedKVStoreQueryNotInNumber(int64_t id, const char* field, const CArrNumber valueList)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->NotInNumber(field, valueList);
+}
+
+void FfiOHOSDistributedKVStoreQueryNotInString(int64_t id, const char* field, const CArrStr valueList)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->NotInString(field, valueList);
+}
+
+void FfiOHOSDistributedKVStoreQueryLike(int64_t id, const char* field, const char* value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->Like(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryUnlike(int64_t id, const char* field, const char* value)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->Unlike(field, value);
+}
+
+void FfiOHOSDistributedKVStoreQueryAnd(int64_t id)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->And();
+}
+
+void FfiOHOSDistributedKVStoreQueryOr(int64_t id)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->Or();
+}
+
+void FfiOHOSDistributedKVStoreQueryOrderByAsc(int64_t id, const char* field)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->OrderByAsc(field);
+}
+
+void FfiOHOSDistributedKVStoreQueryOrderByDesc(int64_t id, const char* field)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->OrderByDesc(field);
+}
+
+void FfiOHOSDistributedKVStoreQueryLimit(int64_t id, int32_t total, int32_t offset)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->Limit(total, offset);
+}
+
+void FfiOHOSDistributedKVStoreQueryIsNotNull(int64_t id, const char* field)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->IsNotNull(field);
+}
+
+void FfiOHOSDistributedKVStoreQueryBeginGroup(int64_t id)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->BeginGroup();
+}
+
+void FfiOHOSDistributedKVStoreQueryEndGroup(int64_t id)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->EndGroup();
+}
+
+void FfiOHOSDistributedKVStoreQueryPrefixKey(int64_t id, const char* prefix)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->PrefixKey(prefix);
+}
+
+void FfiOHOSDistributedKVStoreQuerySetSuggestIndex(int64_t id, const char* index)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->SetSuggestIndex(index);
+}
+
+void FfiOHOSDistributedKVStoreQueryDeviceId(int64_t id, const char* deviceId)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return;
+    }
+    return instance->DeviceId(deviceId);
+}
+
+const char* FfiOHOSDistributedKVStoreQueryGetSqlLike(int64_t id)
+{
+    auto instance = FFIData::GetData<CQuery>(id);
+    if (instance == nullptr) {
+        return nullptr;
+    }
+    return MallocCString(instance->GetSqlLike());
+}
+
+ValueType FfiOHOSDistributedKVStoreDeviceKVStoreGet(int64_t id, const char* deviceId,
+    const char* key, int32_t* errCode)
 {
     auto instance = FFIData::GetData<CJDeviceKVStore>(id);
     if (instance == nullptr) {
@@ -286,6 +699,114 @@ int32_t FfiOHOSDistributedKVStoreKVStoreResultSetGetCount(int64_t id)
     }
     return instance->GetCount();
 }
+
+int32_t FfiOHOSDistributedKVStoreKVStoreResultSetGetPosition(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return -1;
+    }
+    return instance->GetPosition();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToFirst(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->MoveToFirst();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToLast(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->MoveToLast();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToNext(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->MoveToNext();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToPrevious(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->MoveToPrevious();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMove(int64_t id, int32_t offset)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->Move(offset);
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetMoveToPosition(int64_t id, int32_t position)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->MoveToPosition(position);
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetIsFirst(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->IsFirst();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetIsLast(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->IsLast();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetIsBeforeFirst(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->IsBeforeFirst();
+}
+
+bool FfiOHOSDistributedKVStoreKVStoreResultSetIsAfterLast(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return false;
+    }
+    return instance->IsAfterLast();
+}
+
+CEntry FfiOHOSDistributedKVStoreKVStoreResultSetGetEntry(int64_t id)
+{
+    auto instance = FFIData::GetData<OHOS::DistributedKVStore::CKvStoreResultSet>(id);
+    if (instance == nullptr) {
+        return CEntry{};
+    }
+    return instance->GetEntry();
+}
 }
 }
 }
diff --git a/kv_store/frameworks/cj/src/distributed_kv_store_impl.cpp b/kv_store/frameworks/cj/src/distributed_kv_store_impl.cpp
index 307a3b0fbfb9954a0e1b5a70bfa37562c1b21489..ba1b762523244fe7d651c5d6ad35500ddbb475c7 100644
--- a/kv_store/frameworks/cj/src/distributed_kv_store_impl.cpp
+++ b/kv_store/frameworks/cj/src/distributed_kv_store_impl.cpp
@@ -21,6 +21,7 @@
 #include <iomanip>
 #include "securec.h"
 #include "ffi_remote_data.h"
+#include "cj_lambda.h"
 
 #include "distributed_kv_store_impl.h"
 #include "distributed_kv_store_utils.h"
@@ -36,6 +37,7 @@ static int32_t ConvertCJErrCode(Status status)
             // 202
             return CJ_ERROR_PERMISSION_DENIED;
         case INVALID_ARGUMENT:
+        case NOT_SUPPORT:
             // 401
             return CJ_ERROR_INVALID_ARGUMENT;
         case OVER_MAX_LIMITS:
@@ -229,11 +231,19 @@ uint64_t CJKVManager::GetKVStore(const char* cStoreId, const CJOptions cjOptions
     }
     if (cjOptions.kvStoreType == 1) {
         auto nativeKVStore = FFIData::Create<CJSingleKVStore>(sStoreId);
+        if (nativeKVStore == nullptr) {
+            errCode = -1;
+            return -1;
+        }
         nativeKVStore->SetKvStorePtr(kvStore);
         nativeKVStore->SetContextParam(param_);
         return nativeKVStore->GetID();
     }
     auto nativeKVStore = FFIData::Create<CJDeviceKVStore>(sStoreId);
+    if (nativeKVStore == nullptr) {
+        errCode = -1;
+        return -1;
+    }
     nativeKVStore->SetKvStorePtr(kvStore);
     nativeKVStore->SetContextParam(param_);
     return nativeKVStore->GetID();
@@ -284,9 +294,47 @@ CArrStr CJKVManager::GetAllKVStoreId(const char* appId, int32_t& errCode)
     std::vector<StoreId> storeIdList;
     Status status = kvDataManager_.GetAllKvStoreId(appIdBox, storeIdList);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return CArrStr{0};
+    }
     return VectorAppIdToCArr(storeIdList);
 }
 
+int32_t CJKVManager::OnDistributedDataServiceDie(void (*callbackId)())
+{
+    std::lock_guard<std::mutex> lck(deathMutex_);
+    auto onChange = [lambda = CJLambda::Create(callbackId)]() -> void { lambda(); };
+    auto deathRecipient = std::make_shared<DeathRecipient>(callbackId, onChange);
+    kvDataManager_.RegisterKvStoreServiceDeathRecipient(deathRecipient);
+    deathRecipient_.push_back(deathRecipient);
+    return 0;
+}
+
+int32_t CJKVManager::OffDistributedDataServiceDie(void (*callbackId)())
+{
+    std::lock_guard<std::mutex> lck(deathMutex_);
+    auto it = deathRecipient_.begin();
+    while (it != deathRecipient_.end()) {
+        if ((*it)->m_callbackId == callbackId) {
+            kvDataManager_.UnRegisterKvStoreServiceDeathRecipient(*it);
+            it = deathRecipient_.erase(it);
+            break; // specified observer is current iterator
+        }
+        ++it;
+    }
+    return 0;
+}
+
+int32_t CJKVManager::OffAllDistributedDataServiceDie()
+{
+    std::lock_guard<std::mutex> lck(deathMutex_);
+    for (auto& observer : deathRecipient_) {
+        kvDataManager_.UnRegisterKvStoreServiceDeathRecipient(observer);
+    }
+    deathRecipient_.clear();
+    return 0;
+}
+
 CJSingleKVStore::CJSingleKVStore(const std::string& storeId)
 {
     storeId_ = storeId;
@@ -333,6 +381,31 @@ static std::vector<Entry> CArrayEntryToEntries(const CArrEntry &cArrEntry)
     return entrys;
 }
 
+static CArrEntry EntriesToCArrEntry(const std::vector<Entry> &entries)
+{
+    CEntry *cEntries = static_cast<CEntry*>(malloc(entries.size() * sizeof(CEntry)));
+    if (cEntries == nullptr) {
+        return CArrEntry{};
+    }
+    for (size_t i = 0; i < entries.size(); i++) {
+        cEntries[i].key = MallocCString(entries[i].key.ToString());
+        cEntries[i].value = KVValueToValueType(entries[i].value);
+    }
+    return CArrEntry{.head = cEntries, .size = int64_t(entries.size())};
+}
+
+static CChangeNotification ChangeNotificationToCChangeNotification(const ChangeNotification &c)
+{
+    std::vector<Entry> insertEntries = c.GetInsertEntries();
+    std::vector<Entry> updateEntries = c.GetUpdateEntries();
+    std::vector<Entry> deleteEntries = c.GetDeleteEntries();
+    std::string deviceId = c.GetDeviceId();
+    return CChangeNotification{.insertEntries = EntriesToCArrEntry(insertEntries),
+        .updateEntries = EntriesToCArrEntry(updateEntries),
+        .deleteEntries = EntriesToCArrEntry(deleteEntries),
+        .deviceId = MallocCString(deviceId)};
+}
+
 int32_t CJSingleKVStore::PutBatch(const CArrEntry &cArrEntry)
 {
     Status status = kvStore_->PutBatch(CArrayEntryToEntries(cArrEntry));
@@ -363,15 +436,86 @@ int32_t CJSingleKVStore::DeleteBatch(const CArrStr &cArrStr)
     return ConvertCJErrCode(status);
 }
 
+int32_t CJSingleKVStore::RemoveDeviceData(const std::string &deviceId)
+{
+    Status status = kvStore_->RemoveDeviceData(deviceId);
+    return ConvertCJErrCode(status);
+}
+
 ValueType CJSingleKVStore::Get(const std::string &key, int32_t& errCode)
 {
     auto s_key = DistributedKv::Key(key);
     OHOS::DistributedKv::Value value;
     Status status = kvStore_->Get(key, value);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return ValueType{0};
+    }
     return KVValueToValueType(value);
 }
 
+CArrEntry CJSingleKVStore::GetEntries(OHOS::sptr<CQuery> query, int32_t& errCode)
+{
+    std::vector<DistributedKVStore::Entry> entries;
+    DistributedKVStore::DataQuery dataQuery = query->GetDataQuery();
+    Status status = kvStore_->GetEntries(dataQuery, entries);
+    errCode = ConvertCJErrCode(status);
+    return EntriesToCArrEntry(entries);
+}
+
+CArrEntry CJSingleKVStore::GetEntries(const std::string &keyPrefix, int32_t& errCode)
+{
+    std::vector<DistributedKVStore::Entry> entries;
+    DistributedKVStore::DataQuery dataQuery;
+    dataQuery.KeyPrefix(keyPrefix);
+    Status status = kvStore_->GetEntries(dataQuery, entries);
+    errCode = ConvertCJErrCode(status);
+    return EntriesToCArrEntry(entries);
+}
+
+int64_t CJSingleKVStore::GetResultSetByString(const std::string &keyPrefix, int32_t& errCode)
+{
+    DistributedKVStore::DataQuery dataQuery;
+    dataQuery.KeyPrefix(keyPrefix);
+    std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
+    Status status = GetKvStorePtr()->GetResultSet(dataQuery, kvResultSet);
+    errCode = ConvertCJErrCode(status);
+    auto nativeCKVStoreResultSet = FFIData::Create<OHOS::DistributedKVStore::CKvStoreResultSet>(kvResultSet);
+    if (nativeCKVStoreResultSet == nullptr) {
+        return -1;
+    }
+    return nativeCKVStoreResultSet->GetID();
+}
+
+int64_t CJSingleKVStore::GetResultSetByQuery(OHOS::sptr<CQuery> query, int32_t& errCode)
+{
+    DistributedKVStore::DataQuery dataQuery = query->GetDataQuery();
+    std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
+    Status status = GetKvStorePtr()->GetResultSet(dataQuery, kvResultSet);
+    errCode = ConvertCJErrCode(status);
+    auto nativeCKVStoreResultSet = FFIData::Create<OHOS::DistributedKVStore::CKvStoreResultSet>(kvResultSet);
+    if (nativeCKVStoreResultSet == nullptr) {
+        return -1;
+    }
+    return nativeCKVStoreResultSet->GetID();
+}
+
+int32_t CJSingleKVStore::CloseResultSet(OHOS::sptr<CKvStoreResultSet> resultSet)
+{
+    std::shared_ptr<DistributedKv::KvStoreResultSet> ptrKvResultSet = resultSet->GetKvStoreResultSet();
+    Status status = kvStore_->CloseResultSet(ptrKvResultSet);
+    return ConvertCJErrCode(status);
+}
+
+int32_t CJSingleKVStore::GetResultSize(OHOS::sptr<CQuery> query, int32_t& errCode)
+{
+    DistributedKVStore::DataQuery dataQuery = query->GetDataQuery();
+    int resultSize = 0;
+    Status status = kvStore_->GetCount(dataQuery, resultSize);
+    errCode = ConvertCJErrCode(status);
+    return resultSize;
+}
+
 int32_t CJSingleKVStore::Backup(const std::string &file)
 {
     Status status = kvStore_->Backup(file, param_->baseDir);
@@ -384,6 +528,47 @@ int32_t CJSingleKVStore::Restore(const std::string &file)
     return ConvertCJErrCode(status);
 }
 
+static std::vector<std::string> CArrStrToVectorString(const CArrStr &cArrStr)
+{
+    std::vector<std::string> strings;
+    int64_t size = cArrStr.size;
+    for (int64_t i = 0; i < size; i++) {
+        std::string str = cArrStr.head[i];
+        strings.push_back(str);
+    }
+    return strings;
+}
+
+static CStringNum MapToCStringNum(const std::map<std::string, DistributedKv::Status>& results)
+{
+    CStringNum cStringNum;
+    cStringNum.headChar = (char**)malloc(sizeof(char*) * results.size());
+    if (cStringNum.headChar == nullptr) {
+        return CStringNum{0};
+    }
+    cStringNum.headNum = (int32_t*)malloc(sizeof(int32_t) * results.size());
+    if (cStringNum.headNum == nullptr) {
+        free(cStringNum.headChar);
+        return CStringNum{0};
+    }
+    cStringNum.size = results.size();
+    int64_t i = 0;
+    for (auto& it : results) {
+        cStringNum.headChar[i] = MallocCString(it.first);
+        cStringNum.headNum[i] = ConvertCJErrCode(it.second);
+        i++;
+    }
+    return cStringNum;
+}
+
+CStringNum CJSingleKVStore::DeleteBackup(const CArrStr &cArrStr, int32_t& errCode)
+{
+    std::map<std::string, DistributedKv::Status> results;
+    Status status = kvStore_->DeleteBackup(CArrStrToVectorString(cArrStr), param_->baseDir, results);
+    errCode = ConvertCJErrCode(status);
+    return MapToCStringNum(results);
+}
+
 int32_t CJSingleKVStore::StartTransaction()
 {
     Status status = kvStore_->StartTransaction();
@@ -408,6 +593,13 @@ int32_t CJSingleKVStore::EnableSync(bool enabled)
     return ConvertCJErrCode(status);
 }
 
+int32_t CJSingleKVStore::SetSyncRange(const CArrStr &localLabels, const CArrStr &remoteSupportLabels)
+{
+    Status status = kvStore_->SetCapabilityRange(CArrStrToVectorString(localLabels),
+        CArrStrToVectorString(remoteSupportLabels));
+    return ConvertCJErrCode(status);
+}
+
 int32_t CJSingleKVStore::SetSyncParam(uint32_t defaultAllowedDelayMs)
 {
     KvSyncParam syncParam { defaultAllowedDelayMs };
@@ -415,6 +607,124 @@ int32_t CJSingleKVStore::SetSyncParam(uint32_t defaultAllowedDelayMs)
     return ConvertCJErrCode(status);
 }
 
+int32_t CJSingleKVStore::Sync(const CArrStr deviceIds, uint8_t mode, uint32_t delayMs)
+{
+    Status status = kvStore_->Sync(CArrStrToVectorString(deviceIds), static_cast<SyncMode>(mode), delayMs);
+    return ConvertCJErrCode(status);
+}
+
+int32_t CJSingleKVStore::SyncByQuery(const CArrStr deviceIds, OHOS::sptr<CQuery> query, uint8_t mode, uint32_t delayMs)
+{
+    DistributedKVStore::DataQuery dataQuery = query->GetDataQuery();
+    Status status = kvStore_->Sync(CArrStrToVectorString(deviceIds),
+        static_cast<SyncMode>(mode), dataQuery, nullptr, delayMs);
+    return ConvertCJErrCode(status);
+}
+
+static SubscribeType ToSubscribeType(uint8_t type)
+{
+    switch (type) {
+        case 0:  // 0 means SUBSCRIBE_TYPE_LOCAL
+            return SubscribeType::SUBSCRIBE_TYPE_LOCAL;
+        case 1:  // 1 means SUBSCRIBE_TYPE_REMOTE
+            return SubscribeType::SUBSCRIBE_TYPE_REMOTE;
+        case 2:  // 2 means SUBSCRIBE_TYPE_ALL
+            return SubscribeType::SUBSCRIBE_TYPE_ALL;
+        default:
+            return SubscribeType::SUBSCRIBE_TYPE_LOCAL;
+    }
+}
+
+int32_t CJSingleKVStore::OnDataChange(uint8_t type, void (*callbackId)(const CChangeNotification valueRef))
+{
+    std::lock_guard<std::mutex> lck(listMutex_);
+    auto onChange = [lambda = CJLambda::Create(callbackId)](const ChangeNotification& valueRef) ->
+        void { lambda(ChangeNotificationToCChangeNotification(valueRef)); };
+    auto observer = std::make_shared<DataObserver>(callbackId, onChange);
+    auto subscribeType = ToSubscribeType(type);
+    Status status = kvStore_->SubscribeKvStore(subscribeType, observer);
+    int32_t errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return errCode;
+    }
+    dataObserver_[type].push_back(observer);
+    return errCode;
+}
+
+int32_t CJSingleKVStore::OffDataChange(void (*callbackId)(const CChangeNotification valueRef))
+{
+    std::lock_guard<std::mutex> lck(listMutex_);
+    for (uint8_t type = SUBSCRIBE_LOCAL; type < SUBSCRIBE_COUNT; type++) {
+        auto it = dataObserver_[type].begin();
+        while (it != dataObserver_[type].end()) {
+            int32_t errCode = 0;
+            if ((*it)->m_callbackId == callbackId) {
+                auto subscribeType = ToSubscribeType(type);
+                Status status = kvStore_->UnSubscribeKvStore(subscribeType, *it);
+                errCode = ConvertCJErrCode(status);
+                it = dataObserver_[type].erase(it);
+            }
+            if (errCode != 0) {
+                return errCode;
+            }
+            ++it;
+        }
+    }
+    return 0;
+}
+
+int32_t CJSingleKVStore::OffAllDataChange()
+{
+    std::lock_guard<std::mutex> lck(listMutex_);
+    for (uint8_t type = SUBSCRIBE_LOCAL; type < SUBSCRIBE_COUNT; type++) {
+        for (auto& observer : dataObserver_[type]) {
+            auto subscribeType = ToSubscribeType(type);
+            Status status = kvStore_->UnSubscribeKvStore(subscribeType, observer);
+            int32_t errCode = ConvertCJErrCode(status);
+            if (errCode != 0) {
+                return errCode;
+            }
+        }
+        dataObserver_[type].clear();
+    }
+    return 0;
+}
+
+int32_t CJSingleKVStore::OnSyncComplete(void (*callbackId)(const CStringNum valueRef))
+{
+    std::lock_guard<std::mutex> lck(listMutex_);
+    auto onChange = [lambda = CJLambda::Create(callbackId)]
+        (const std::map<std::string, DistributedKv::Status>& valueRef) ->
+        void { lambda(MapToCStringNum(valueRef)); };
+    auto observer = std::make_shared<SyncObserver>(callbackId, onChange);
+    Status status = kvStore_->RegisterSyncCallback(observer);
+    int32_t errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return errCode;
+    }
+    syncObservers_.push_back(observer);
+    return errCode;
+}
+
+int32_t CJSingleKVStore::OffAllSyncComplete()
+{
+    std::lock_guard<std::mutex> lck(listMutex_);
+    Status status = kvStore_->UnRegisterSyncCallback();
+    int32_t errCode = ConvertCJErrCode(status);
+    if (errCode == 0) {
+        syncObservers_.clear();
+    }
+    return errCode;
+}
+
+int32_t CJSingleKVStore::GetSecurityLevel(int32_t& errCode)
+{
+    SecurityLevel securityLevel;
+    Status status = kvStore_->GetSecurityLevel(securityLevel);
+    errCode = ConvertCJErrCode(status);
+    return static_cast<int32_t>(securityLevel);
+}
+
 constexpr int DEVICEID_WIDTH = 4;
 
 static std::string GetDeviceKey(const std::string& deviceId, const std::string& key)
@@ -439,6 +749,9 @@ ValueType CJDeviceKVStore::Get(const std::string &deviceId, const std::string &k
     OHOS::DistributedKv::Value value;
     Status status = GetKvStorePtr()->Get(key, value);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return ValueType{0};
+    }
     return KVValueToValueType(value);
 }
 
@@ -447,6 +760,9 @@ CArrEntry CJDeviceKVStore::GetEntriesByDataQuery(DistributedKVStore::DataQuery d
     std::vector<DistributedKVStore::Entry> entries;
     Status status = GetKvStorePtr()->GetEntries(dataQuery, entries);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return CArrEntry{};
+    }
     CEntry *cEntries = static_cast<CEntry*>(malloc(entries.size() * sizeof(CEntry)));
     if (cEntries == nullptr) {
         errCode = -1;
@@ -485,7 +801,14 @@ int64_t CJDeviceKVStore::GetResultSet(const std::string &deviceId, const std::st
     std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
     Status status = GetKvStorePtr()->GetResultSet(dataQuery, kvResultSet);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return -1;
+    }
     auto nativeCKvStoreResultSet = FFIData::Create<OHOS::DistributedKVStore::CKvStoreResultSet>(kvResultSet);
+    if (nativeCKvStoreResultSet == nullptr) {
+        errCode = -1;
+        return -1;
+    }
     return nativeCKvStoreResultSet->GetID();
 }
 
@@ -497,7 +820,14 @@ int64_t CJDeviceKVStore::GetResultSetQuery(const std::string &deviceId, OHOS::sp
     std::shared_ptr<DistributedKv::KvStoreResultSet> kvResultSet;
     Status status = GetKvStorePtr()->GetResultSet(dataQuery, kvResultSet);
     errCode = ConvertCJErrCode(status);
+    if (errCode != 0) {
+        return -1;
+    }
     auto nativeCKvStoreResultSet = FFIData::Create<OHOS::DistributedKVStore::CKvStoreResultSet>(kvResultSet);
+    if (nativeCKvStoreResultSet == nullptr) {
+        errCode = -1;
+        return -1;
+    }
     return nativeCKvStoreResultSet->GetID();
 }
 
@@ -527,6 +857,72 @@ int32_t CKvStoreResultSet::GetCount()
     return kvResultSet->GetCount();
 }
 
+int32_t CKvStoreResultSet::GetPosition()
+{
+    return kvResultSet->GetPosition();
+}
+
+bool CKvStoreResultSet::MoveToFirst()
+{
+    return kvResultSet->MoveToFirst();
+}
+
+bool CKvStoreResultSet::MoveToLast()
+{
+    return kvResultSet->MoveToLast();
+}
+
+bool CKvStoreResultSet::MoveToNext()
+{
+    return kvResultSet->MoveToNext();
+}
+
+bool CKvStoreResultSet::MoveToPrevious()
+{
+    return kvResultSet->MoveToPrevious();
+}
+
+bool CKvStoreResultSet::Move(int32_t offset)
+{
+    return kvResultSet->Move(offset);
+}
+
+bool CKvStoreResultSet::MoveToPosition(int32_t position)
+{
+    return kvResultSet->MoveToPosition(position);
+}
+
+bool CKvStoreResultSet::IsFirst()
+{
+    return kvResultSet->IsFirst();
+}
+
+bool CKvStoreResultSet::IsLast()
+{
+    return kvResultSet->IsLast();
+}
+
+bool CKvStoreResultSet::IsBeforeFirst()
+{
+    return kvResultSet->IsBeforeFirst();
+}
+
+bool CKvStoreResultSet::IsAfterLast()
+{
+    return kvResultSet->IsAfterLast();
+}
+
+CEntry CKvStoreResultSet::GetEntry()
+{
+    Entry entry;
+    auto status = kvResultSet->GetEntry(entry);
+    if (status != Status::SUCCESS)
+        return CEntry{};
+    auto& data = entry.key.Data();
+    return CEntry{.key = MallocCString(std::string(data.begin(), data.end())),
+        .value = KVValueToValueType(entry.value)};
+}
+
 const DistributedKv::DataQuery& CQuery::GetDataQuery() const
 {
     return query_;
@@ -541,7 +937,8 @@ void CQuery::EqualTo(const std::string &field, ValueType &value)
 {
     switch (value.tag) {
         case STRING: {
-            query_.EqualTo(field, value.string);
+            std::string str = value.string;
+            query_.EqualTo(field, str);
             break;
         }
         case INTEGER: {
@@ -565,4 +962,336 @@ void CQuery::EqualTo(const std::string &field, ValueType &value)
         }
     }
 }
+
+void CQuery::NotEqualTo(const std::string &field, ValueType &value)
+{
+    switch (value.tag) {
+        case STRING: {
+            std::string str = value.string;
+            query_.NotEqualTo(field, str);
+            break;
+        }
+        case INTEGER: {
+            query_.NotEqualTo(field, value.integer);
+            break;
+        }
+        case FLOAT: {
+            query_.NotEqualTo(field, value.flo);
+            break;
+        }
+        case BOOLEAN: {
+            query_.NotEqualTo(field, value.boolean);
+            break;
+        }
+        case DOUBLE: {
+            query_.NotEqualTo(field, value.dou);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::GreaterThan(const std::string &field, ValueType &value)
+{
+    switch (value.tag) {
+        case STRING: {
+            std::string str = value.string;
+            query_.GreaterThan(field, str);
+            break;
+        }
+        case INTEGER: {
+            query_.GreaterThan(field, value.integer);
+            break;
+        }
+        case FLOAT: {
+            query_.GreaterThan(field, value.flo);
+            break;
+        }
+        case BOOLEAN: {
+            query_.GreaterThan(field, value.boolean);
+            break;
+        }
+        case DOUBLE: {
+            query_.GreaterThan(field, value.dou);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::LessThan(const std::string &field, ValueType &value)
+{
+    switch (value.tag) {
+        case STRING: {
+            std::string str = value.string;
+            query_.LessThan(field, str);
+            break;
+        }
+        case INTEGER: {
+            query_.LessThan(field, value.integer);
+            break;
+        }
+        case FLOAT: {
+            query_.LessThan(field, value.flo);
+            break;
+        }
+        case BOOLEAN: {
+            query_.LessThan(field, value.boolean);
+            break;
+        }
+        case DOUBLE: {
+            query_.LessThan(field, value.dou);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::GreaterThanOrEqualTo(const std::string &field, ValueType &value)
+{
+    switch (value.tag) {
+        case STRING: {
+            std::string str = value.string;
+            query_.GreaterThanOrEqualTo(field, str);
+            break;
+        }
+        case INTEGER: {
+            query_.GreaterThanOrEqualTo(field, value.integer);
+            break;
+        }
+        case FLOAT: {
+            query_.GreaterThanOrEqualTo(field, value.flo);
+            break;
+        }
+        case BOOLEAN: {
+            query_.GreaterThanOrEqualTo(field, value.boolean);
+            break;
+        }
+        case DOUBLE: {
+            query_.GreaterThanOrEqualTo(field, value.dou);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::LessThanOrEqualTo(const std::string &field, ValueType &value)
+{
+    switch (value.tag) {
+        case STRING: {
+            std::string str = value.string;
+            query_.LessThanOrEqualTo(field, str);
+            break;
+        }
+        case INTEGER: {
+            query_.LessThanOrEqualTo(field, value.integer);
+            break;
+        }
+        case FLOAT: {
+            query_.LessThanOrEqualTo(field, value.flo);
+            break;
+        }
+        case BOOLEAN: {
+            query_.LessThanOrEqualTo(field, value.boolean);
+            break;
+        }
+        case DOUBLE: {
+            query_.LessThanOrEqualTo(field, value.dou);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::IsNull(const std::string &field)
+{
+    query_.IsNull(field);
+}
+
+void CQuery::InNumber(const std::string &field, const CArrNumber &valueList)
+{
+    switch (valueList.tag) {
+        case INTEGER: {
+            query_.In(field, std::vector<int32_t>(valueList.intList, valueList.intList + valueList.size));
+            break;
+        }
+        case FLOAT: {
+            query_.In(field, std::vector<double>(valueList.floatList, valueList.floatList + valueList.size));
+            break;
+        }
+        case DOUBLE: {
+            query_.In(field, std::vector<double>(valueList.doubleList, valueList.doubleList + valueList.size));
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+static std::vector<std::string> CArrayStrToVectorString(const CArrStr &cArrStr)
+{
+    std::vector<std::string> strs;
+    int64_t size = cArrStr.size;
+    for (int64_t i = 0; i < size; i++) {
+        std::string str = cArrStr.head[i];
+        strs.push_back(str);
+    }
+    return strs;
+}
+
+void CQuery::InString(const std::string &field, const CArrStr &valueList)
+{
+    query_.In(field, CArrayStrToVectorString(valueList));
+}
+
+void CQuery::NotInNumber(const std::string &field, const CArrNumber &valueList)
+{
+    switch (valueList.tag) {
+        case INTEGER: {
+            query_.NotIn(field, std::vector<int32_t>(valueList.intList, valueList.intList + valueList.size));
+            break;
+        }
+        case FLOAT: {
+            query_.NotIn(field, std::vector<double>(valueList.floatList, valueList.floatList + valueList.size));
+            break;
+        }
+        case DOUBLE: {
+            query_.NotIn(field, std::vector<double>(valueList.doubleList, valueList.doubleList + valueList.size));
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+}
+
+void CQuery::NotInString(const std::string &field, const CArrStr &valueList)
+{
+    query_.NotIn(field, CArrayStrToVectorString(valueList));
+}
+
+void CQuery::Like(const std::string &field, const std::string &value)
+{
+    query_.Like(field, value);
+}
+
+void CQuery::Unlike(const std::string &field, const std::string &value)
+{
+    query_.Unlike(field, value);
+}
+
+void CQuery::And()
+{
+    query_.And();
+}
+
+void CQuery::Or()
+{
+    query_.Or();
+}
+
+void CQuery::OrderByAsc(const std::string &field)
+{
+    query_.OrderByAsc(field);
+}
+
+void CQuery::OrderByDesc(const std::string &field)
+{
+    query_.OrderByDesc(field);
+}
+
+void CQuery::Limit(int32_t total, int32_t offset)
+{
+    query_.Limit(total, offset);
+}
+
+void CQuery::IsNotNull(const std::string &field)
+{
+    query_.IsNotNull(field);
+}
+
+void CQuery::BeginGroup()
+{
+    query_.BeginGroup();
+}
+
+void CQuery::EndGroup()
+{
+    query_.EndGroup();
+}
+
+void CQuery::PrefixKey(const std::string &prefix)
+{
+    query_.KeyPrefix(prefix);
+}
+
+void CQuery::SetSuggestIndex(const std::string &index)
+{
+    query_.SetSuggestIndex(index);
+}
+
+void CQuery::DeviceId(const std::string &deviceId)
+{
+    query_.DeviceId(deviceId);
+}
+
+const std::string CQuery::GetSqlLike()
+{
+    return query_.ToString();
+}
+
+CJKVManager::DeathRecipient::DeathRecipient(void (*callbackId)(), const std::function<void()>& callbackRef)
+{
+    if (callbackId == nullptr) {
+        LOGI("WARNING: nullptr");
+    }
+    m_callbackId = callbackId;
+    m_callbackRef = callbackRef;
+}
+
+void CJKVManager::DeathRecipient::OnRemoteDied()
+{
+    m_callbackRef();
+}
+
+CJSingleKVStore::DataObserver::DataObserver(void (*callbackId)(const CChangeNotification),
+    const std::function<void(DistributedKv::ChangeNotification)>& callbackRef)
+{
+    if (callbackId == nullptr) {
+        LOGI("WARNING: nullptr");
+    }
+    m_callbackId = callbackId;
+    m_callbackRef = callbackRef;
+}
+
+void CJSingleKVStore::DataObserver::OnChange(const DistributedKv::ChangeNotification& notification)
+{
+    m_callbackRef(notification);
+}
+
+CJSingleKVStore::SyncObserver::SyncObserver(void (*callbackId)(const CStringNum),
+    const std::function<void(std::map<std::string, DistributedKv::Status>)>& callbackRef)
+{
+    if (callbackId == nullptr) {
+        LOGI("WARNING: nullptr");
+    }
+    m_callbackId = callbackId;
+    m_callbackRef = callbackRef;
+}
+
+void CJSingleKVStore::SyncObserver::SyncCompleted(const std::map<std::string, DistributedKv::Status>& results)
+{
+    m_callbackRef(results);
 }
+}
\ No newline at end of file
diff --git a/kv_store/frameworks/common/concurrent_map.h b/kv_store/frameworks/common/concurrent_map.h
index 42cd1ca88bfa1240eb83e159bb05ab78d050b12f..747212eee05e1a2a5246166a094ec5ceeb3471f2 100644
--- a/kv_store/frameworks/common/concurrent_map.h
+++ b/kv_store/frameworks/common/concurrent_map.h
@@ -194,12 +194,6 @@ public:
         return count;
     }
 
-    mapped_type &operator[](const key_type &key) noexcept
-    {
-        std::lock_guard<decltype(mutex_)> lock(mutex_);
-        return entries_[key];
-    }
-
     void ForEach(const std::function<bool(const key_type &, mapped_type &)> &action)
     {
         if (action == nullptr) {
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/include/ikvstore_observer.h b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/include/ikvstore_observer.h
index 5d7d7fde318dc2882346f58d1289803fafe97ad6..ff50ce010ff7a8a4f3c31ea00462fea3076c0d00 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/include/ikvstore_observer.h
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/include/ikvstore_observer.h
@@ -38,7 +38,7 @@ public:
     virtual void OnChange(const ChangeNotification &changeNotification) = 0;
     virtual void OnChange(const DataOrigin &origin, Keys &&keys) = 0;
 protected:
-    static constexpr int64_t SWITCH_RAW_DATA_SIZE = 700 * 1024;
+    static constexpr int64_t SWITCH_RAW_DATA_SIZE = 200 * 1024;
     static constexpr size_t MAX_IPC_CAPACITY = 800 * 1024;
 };
 
@@ -60,4 +60,4 @@ private:
 }  // namespace DistributedKv
 }  // namespace OHOS
 
-#endif  // I_KVSTORE_OBSERVER_H
+#endif  // I_KVSTORE_OBSERVER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.cpp
index 8c70fc821d7cc6dcb0b051cdcd204d5469ca7fa9..9e4060512d45fa82c07f37aa3c03d7f35ceb78d1 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.cpp
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.cpp
@@ -30,53 +30,33 @@ namespace OHOS {
 namespace DistributedKv {
 
 std::mutex KvStoreServiceDeathNotifier::instanceMutex_;
-KvStoreServiceDeathNotifier* KvStoreServiceDeathNotifier::instance_ = nullptr;
-
-KvStoreServiceDeathNotifier* KvStoreServiceDeathNotifier::GetInstance()
+KvStoreServiceDeathNotifier& KvStoreServiceDeathNotifier::GetInstance()
 {
-    if (instance_ == nullptr) {
-        std::lock_guard<std::mutex> lock(instanceMutex_);
-        if (instance_ == nullptr) {
-            instance_ = new (std::nothrow) KvStoreServiceDeathNotifier();
-            if (instance_ == nullptr) {
-                ZLOGE("KvStoreServiceDeathNotifier nullptr");
-            }
-            return instance_;
-        }
-    }
-    return instance_;
+    static KvStoreServiceDeathNotifier instance;
+    return instance;
 }
 
 void KvStoreServiceDeathNotifier::SetAppId(const AppId &appId)
 {
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return;
-    }
-    std::lock_guard<decltype(mutex_)> lg(instance->mutex_);
-    instance->appId_ = appId;
+    auto &instance = GetInstance();
+    std::lock_guard<decltype(mutex_)> lg(instance.mutex_);
+    instance.appId_ = appId;
 }
 
 AppId KvStoreServiceDeathNotifier::GetAppId()
 {
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return {};
-    }
-    std::lock_guard<decltype(mutex_)> lg(instance->mutex_);
-    return instance->appId_;
+    auto &instance = GetInstance();
+    std::lock_guard<decltype(mutex_)> lg(instance.mutex_);
+    return instance.appId_;
 }
 
 sptr<IKvStoreDataService> KvStoreServiceDeathNotifier::GetDistributedKvDataService()
 {
     ZLOGD("begin.");
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return nullptr;
-    }
-    std::lock_guard<std::mutex> lg(instance->watchMutex_);
-    if (instance->kvDataServiceProxy_ != nullptr) {
-        return instance->kvDataServiceProxy_;
+    auto &instance = GetInstance();
+    std::lock_guard<std::mutex> lg(instance.watchMutex_);
+    if (instance.kvDataServiceProxy_ != nullptr) {
+        return instance.kvDataServiceProxy_;
     }
 
     ZLOGI("create remote proxy.");
@@ -87,26 +67,26 @@ sptr<IKvStoreDataService> KvStoreServiceDeathNotifier::GetDistributedKvDataServi
     }
 
     auto remote = samgr->CheckSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
-    instance->kvDataServiceProxy_ = iface_cast<DataMgrServiceProxy>(remote);
-    if (instance->kvDataServiceProxy_ == nullptr) {
+    instance.kvDataServiceProxy_ = iface_cast<DataMgrServiceProxy>(remote);
+    if (instance.kvDataServiceProxy_ == nullptr) {
         ZLOGE("initialize proxy failed.");
         return nullptr;
     }
 
-    if (instance->deathRecipientPtr_ == nullptr) {
-        instance->deathRecipientPtr_ = new (std::nothrow) ServiceDeathRecipient();
-        if (instance->deathRecipientPtr_ == nullptr) {
+    if (instance.deathRecipientPtr_ == nullptr) {
+        instance.deathRecipientPtr_ = new (std::nothrow) ServiceDeathRecipient();
+        if (instance.deathRecipientPtr_ == nullptr) {
             ZLOGW("new KvStoreDeathRecipient failed");
             return nullptr;
         }
     }
-    if ((remote->IsProxyObject()) && (!remote->AddDeathRecipient(instance->deathRecipientPtr_))) {
+    if ((remote->IsProxyObject()) && (!remote->AddDeathRecipient(instance.deathRecipientPtr_))) {
         ZLOGE("failed to add death recipient.");
     }
 
-    instance->RegisterClientDeathObserver();
+    instance.RegisterClientDeathObserver();
 
-    return instance->kvDataServiceProxy_;
+    return instance.kvDataServiceProxy_;
 }
 
 void KvStoreServiceDeathNotifier::RegisterClientDeathObserver()
@@ -126,47 +106,38 @@ void KvStoreServiceDeathNotifier::RegisterClientDeathObserver()
 
 void KvStoreServiceDeathNotifier::AddServiceDeathWatcher(std::shared_ptr<KvStoreDeathRecipient> watcher)
 {
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return;
-    }
-    std::lock_guard<std::mutex> lg(instance->watchMutex_);
-    auto ret = instance->serviceDeathWatchers_.insert(std::move(watcher));
+    auto &instance = GetInstance();
+    std::lock_guard<std::mutex> lg(instance.watchMutex_);
+    auto ret = instance.serviceDeathWatchers_.insert(std::move(watcher));
     if (ret.second) {
-        ZLOGI("success set size: %zu", instance->serviceDeathWatchers_.size());
+        ZLOGI("success set size: %zu", instance.serviceDeathWatchers_.size());
     } else {
-        ZLOGE("failed set size: %zu", instance->serviceDeathWatchers_.size());
+        ZLOGE("failed set size: %zu", instance.serviceDeathWatchers_.size());
     }
 }
 
 void KvStoreServiceDeathNotifier::RemoveServiceDeathWatcher(std::shared_ptr<KvStoreDeathRecipient> watcher)
 {
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return;
-    }
-    std::lock_guard<std::mutex> lg(instance->watchMutex_);
-    auto it = instance->serviceDeathWatchers_.find(std::move(watcher));
-    if (it != instance->serviceDeathWatchers_.end()) {
-        instance->serviceDeathWatchers_.erase(it);
-        ZLOGI("find & erase set size: %zu", instance->serviceDeathWatchers_.size());
+    auto &instance = GetInstance();
+    std::lock_guard<std::mutex> lg(instance.watchMutex_);
+    auto it = instance.serviceDeathWatchers_.find(std::move(watcher));
+    if (it != instance.serviceDeathWatchers_.end()) {
+        instance.serviceDeathWatchers_.erase(it);
+        ZLOGI("find & erase set size: %zu", instance.serviceDeathWatchers_.size());
     } else {
-        ZLOGE("no found set size: %zu", instance->serviceDeathWatchers_.size());
+        ZLOGE("no found set size: %zu", instance.serviceDeathWatchers_.size());
     }
 }
 
 void KvStoreServiceDeathNotifier::ServiceDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
     ZLOGW("DistributedDataMgrService died.");
-    auto *instance = GetInstance();
-    if (instance == nullptr) {
-        return;
-    }
+    auto &instance = GetInstance();
     // Need to do this with the lock held
-    std::lock_guard<std::mutex> lg(instance->watchMutex_);
-    instance->kvDataServiceProxy_ = nullptr;
-    ZLOGI("watcher set size: %zu", instance->serviceDeathWatchers_.size());
-    for (const auto &watcher : instance->serviceDeathWatchers_) {
+    std::lock_guard<std::mutex> lg(instance.watchMutex_);
+    instance.kvDataServiceProxy_ = nullptr;
+    ZLOGI("watcher set size: %zu", instance.serviceDeathWatchers_.size());
+    for (const auto &watcher : instance.serviceDeathWatchers_) {
         if (watcher == nullptr) {
             ZLOGI("watcher is nullptr");
             continue;
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.h b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.h
index 0090d7364f56f9e34687b3ee6bf9c4e4969a7992..16d5c64ae4bf3f30f60dc01c9a941f0cded18df2 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.h
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/src/kvstore_service_death_notifier.h
@@ -49,7 +49,7 @@ private:
 
         void OnRemoteDied(const wptr<IRemoteObject> &remote) override;
     };
-    static KvStoreServiceDeathNotifier* GetInstance();
+    static KvStoreServiceDeathNotifier& GetInstance();
 
     static std::mutex instanceMutex_;
     static KvStoreServiceDeathNotifier *instance_;
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn
index 40ec019b1e0dcf6b005e91f412f0a46792c37fe0..161cfebb2dbcb07e2624201bcadc891c3e01a00f 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/BUILD.gn
@@ -64,7 +64,6 @@ ohos_source_set("distributeddatafwk_src_file") {
   kvdb_sources = [
     "../../kvdb/src/backup_manager.cpp",
     "../../kvdb/src/convertor.cpp",
-    "../../kvdb/src/data_change_notifier.cpp",
     "../../kvdb/src/dev_manager.cpp",
     "../../kvdb/src/device_convertor.cpp",
     "../../kvdb/src/kv_types_util.cpp",
@@ -84,6 +83,11 @@ ohos_source_set("distributeddatafwk_src_file") {
   ]
 
   sources = old_sources + kvdb_sources
+  if (qemu_disable) {
+    sources += [ "../../kvdb/src/auto_sync_timer.cpp" ]
+  } else {
+    sources += [ "../../kvdb/src/auto_sync_timer_mock.cpp" ]
+  }
   configs = [ ":module_private_config" ]
 
   deps = [
@@ -93,6 +97,8 @@ ohos_source_set("distributeddatafwk_src_file") {
     "//foundation/distributedhardware/device_manager/interfaces/inner_kits/native_cpp:devicemanagersdk",
   ]
   external_deps = [
+    "access_token:libaccesstoken_sdk",
+    "access_token:libtokenid_sdk",
     "c_utils:utils",
     "file_api:securitylabel",
     "hilog:libhilog",
@@ -103,6 +109,9 @@ ohos_source_set("distributeddatafwk_src_file") {
     "ipc:ipc_single",
     "samgr:samgr_proxy",
   ]
+  if (dms_service_enable && qemu_disable) {
+    external_deps += [ "dmsfwk:distributed_sdk" ]
+  }
 
   public_external_deps = [
     "data_share:datashare_common",
@@ -115,7 +124,10 @@ ohos_source_set("distributeddatafwk_src_file") {
 ohos_unittest("DistributedKvDataManagerTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/distributed_kv_data_manager_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/distributed_kv_data_manager_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -135,7 +147,10 @@ ohos_unittest("DistributedKvDataManagerTest") {
 ohos_unittest("DistributedKvDataManagerEncryptTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/distributed_kv_data_manager_encrypt_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/distributed_kv_data_manager_encrypt_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -148,7 +163,6 @@ ohos_unittest("DistributedKvDataManagerEncryptTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -156,7 +170,10 @@ ohos_unittest("DistributedKvDataManagerEncryptTest") {
 ohos_unittest("LocalSubscribeStoreTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/local_subscribe_store_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/local_subscribe_store_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -169,7 +186,6 @@ ohos_unittest("LocalSubscribeStoreTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -177,7 +193,10 @@ ohos_unittest("LocalSubscribeStoreTest") {
 ohos_unittest("LocalSubscribeDeviceStoreTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/local_subscribe_device_store_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/local_subscribe_device_store_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -190,7 +209,6 @@ ohos_unittest("LocalSubscribeDeviceStoreTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -198,7 +216,10 @@ ohos_unittest("LocalSubscribeDeviceStoreTest") {
 ohos_unittest("SingleKvStoreClientQueryTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/single_kvstore_client_query_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/single_kvstore_client_query_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -211,7 +232,6 @@ ohos_unittest("SingleKvStoreClientQueryTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -219,7 +239,10 @@ ohos_unittest("SingleKvStoreClientQueryTest") {
 ohos_unittest("SingleKvStoreClientTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/single_kvstore_client_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/single_kvstore_client_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -232,7 +255,6 @@ ohos_unittest("SingleKvStoreClientTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -240,7 +262,10 @@ ohos_unittest("SingleKvStoreClientTest") {
 ohos_unittest("SingleKvStoreAsyncGetTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/single_kvstore_async_get_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/single_kvstore_async_get_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -260,7 +285,10 @@ ohos_unittest("SingleKvStoreAsyncGetTest") {
 ohos_unittest("DeviceKvStoreTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/device_kvstore_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/device_kvstore_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -273,7 +301,6 @@ ohos_unittest("DeviceKvStoreTest") {
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 }
@@ -281,13 +308,15 @@ ohos_unittest("DeviceKvStoreTest") {
 ohos_unittest("BlobTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/blob_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/blob_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 
@@ -301,13 +330,15 @@ ohos_unittest("BlobTest") {
 ohos_unittest("TypesUtilTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/types_util_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/types_util_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 
@@ -321,13 +352,15 @@ ohos_unittest("TypesUtilTest") {
 ohos_unittest("KvUtilTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/kv_utils_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/kv_utils_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 
@@ -341,13 +374,15 @@ ohos_unittest("KvUtilTest") {
 ohos_unittest("KvstoreDatashareBridgeTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/kvstore_datashare_bridge_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/kvstore_datashare_bridge_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
   deps = [
     ":distributeddatafwk_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//third_party/googletest:gtest_main",
   ]
 
@@ -361,7 +396,10 @@ ohos_unittest("KvstoreDatashareBridgeTest") {
 ohos_unittest("DistributedDataMgrTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/distributed_data_mgr_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/distributed_data_mgr_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -384,7 +422,10 @@ ohos_unittest("DistributedDataMgrTest") {
 ohos_unittest("EndPointTest") {
   module_out_path = module_output_path
 
-  sources = [ "unittest/end_point_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "unittest/end_point_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_data_mgr_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_data_mgr_test.cpp
index a90678861194d5f913d91830618902aea047834f..a3df1653ea65fad909d4e4cbbb41540dead78f2a 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_data_mgr_test.cpp
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_data_mgr_test.cpp
@@ -19,74 +19,26 @@
 #include "types.h"
 #include "accesstoken_kit.h"
 #include "nativetoken_kit.h"
+#include "ipc_skeleton.h"
 #include "token_setproc.h"
 
 using namespace testing::ext;
 using namespace OHOS::DistributedKv;
 using namespace OHOS::Security::AccessToken;
+std::string BUNDLE_NAME = "ohos.distributeddatamgrtest.demo";
 namespace OHOS::Test {
 class DistributedDataMgrTest : public testing::Test {
 public:
     static DistributedDataMgr manager;
-    static void SetUpTestCase(void) {};
-    static void TearDownTestCase(void) {};
-    void SetUp();
-    void TearDown();
+    static void SetUpTestCase(void){};
+    static void TearDownTestCase(void){};
+    void SetUp(){};
+    void TearDown(){};
     static constexpr int32_t TEST_USERID = 100;
     static constexpr int32_t APP_INDEX = 0;
-    NativeTokenInfoParams infoInstance {0};
 };
 DistributedDataMgr DistributedDataMgrTest::manager;
 
-void DistributedDataMgrTest::SetUp(void)
-{
-    infoInstance.dcapsNum = 0;
-    infoInstance.permsNum = 0;
-    infoInstance.aclsNum = 0;
-    infoInstance.dcaps = nullptr;
-    infoInstance.perms = nullptr;
-    infoInstance.acls = nullptr;
-    infoInstance.processName = "KvStoreDataServiceClearTest";
-    infoInstance.aplStr = "system_core";
-
-    HapInfoParams info = {
-        .userID = TEST_USERID,
-        .bundleName = "ohos.test.demo",
-        .instIndex = 0,
-        .appIDDesc = "ohos.test.demo"
-    };
-    PermissionDef infoManagerTestPermDef = {
-        .permissionName = "ohos.permission.test",
-        .bundleName = "ohos.test.demo",
-        .grantMode = 1,
-        .availableLevel = APL_NORMAL,
-        .label = "label",
-        .labelId = 1,
-        .description = "open the door",
-        .descriptionId = 1
-    };
-    PermissionStateFull infoManagerTestState = {
-        .permissionName = "ohos.permission.test",
-        .isGeneral = true,
-        .resDeviceID = {"local"},
-        .grantStatus = {PermissionState::PERMISSION_GRANTED},
-        .grantFlags = {1}
-    };
-    HapPolicyParams policy = {
-        .apl = APL_NORMAL,
-        .domain = "test.domain",
-        .permList = {infoManagerTestPermDef},
-        .permStateList = {infoManagerTestState}
-    };
-    AccessTokenKit::AllocHapToken(info, policy);
-}
-
-void DistributedDataMgrTest::TearDown(void)
-{
-    auto tokenId = AccessTokenKit::GetHapTokenID(TEST_USERID, "ohos.test.demo", 0);
-    AccessTokenKit::DeleteToken(tokenId);
-}
-
 /**
 * @tc.name: ClearAppStorage
 * @tc.desc:
@@ -96,22 +48,9 @@ void DistributedDataMgrTest::TearDown(void)
 */
 HWTEST_F(DistributedDataMgrTest, ClearAppStorage001, TestSize.Level1)
 {
-    auto tokenId = AccessTokenKit::GetHapTokenID(TEST_USERID, "ohos.test.demo", 0);
-    auto ret = manager.ClearAppStorage("ohos.test.demo", TEST_USERID, APP_INDEX, tokenId);
+    auto tokenId = AccessTokenKit::GetNativeTokenId("foundation");
+    SetSelfTokenID(tokenId);
+    auto ret = manager.ClearAppStorage(BUNDLE_NAME, TEST_USERID, APP_INDEX, tokenId);
     EXPECT_EQ(ret, Status::SUCCESS);
 }
-
-/**
-* @tc.name: ClearAppStorage
-* @tc.desc:
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: SQL
-*/
-HWTEST_F(DistributedDataMgrTest, ClearAppStorage002, TestSize.Level1)
-{
-    auto tokenId = AccessTokenKit::GetHapTokenID(TEST_USERID, "ohos.test.fail", 0);
-    auto ret = manager.ClearAppStorage("ohos.test.demo", TEST_USERID, APP_INDEX, tokenId);
-    EXPECT_EQ(ret, Status::ERROR);
-}
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_kv_data_manager_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_kv_data_manager_test.cpp
index 38b883e3784ccb689e76be03f0d98fb34a0e87e4..cefe082682930d81ecb163870f49ed279870605d 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_kv_data_manager_test.cpp
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/distributed_kv_data_manager_test.cpp
@@ -297,6 +297,34 @@ HWTEST_F(DistributedKvDataManagerTest, GetKvStore008, TestSize.Level1)
     EXPECT_NE(cloudKvStore, nullptr);
 }
 
+/**
+ * @tc.name: GetKvStore009
+ * @tc.desc: Get a SingleKvStore which security level upgrade.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: yanhui
+ */
+HWTEST_F(DistributedKvDataManagerTest, GetKvStore009, TestSize.Level1)
+{
+    ZLOGI("GetKvStore009 begin.");
+    std::shared_ptr<SingleKvStore> kvStore = nullptr;
+    Options options = create;
+    options.securityLevel = S1;
+    Status status = manager.GetSingleKvStore(options, appId, storeId64, kvStore);
+
+    manager.CloseKvStore(appId, storeId64);
+    options.securityLevel = S2;
+    status = manager.GetSingleKvStore(options, appId, storeId64, kvStore);
+    ASSERT_EQ(status, Status::SUCCESS);
+    EXPECT_NE(kvStore, nullptr);
+
+    manager.CloseKvStore(appId, storeId64);
+    options.securityLevel = S1;
+    status = manager.GetSingleKvStore(options, appId, storeId64, kvStore);
+    ASSERT_EQ(status, Status::STORE_META_CHANGED);
+    EXPECT_EQ(kvStore, nullptr);
+}
+
 /**
 * @tc.name: GetKvStoreInvalidSecurityLevel
 * @tc.desc: Get a SingleKvStore with a 64
diff --git a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_async_get_test.cpp b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_async_get_test.cpp
index 86cc749ea45e77e26cb9171d5e7fe9183d03412c..0ede44c23fc8c4e6d8e55f16052eb5f32e9d20f8 100644
--- a/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_async_get_test.cpp
+++ b/kv_store/frameworks/innerkitsimpl/distributeddatafwk/test/unittest/single_kvstore_async_get_test.cpp
@@ -213,7 +213,7 @@ HWTEST_F(SingleKvStoreAsyncGetTest, AsyncGetValueWithInvalidNetworkId, TestSize.
     EXPECT_EQ(value.ToString(), "test_value_0");
     auto blockData = std::make_shared<BlockData<bool>>(1, false);
     std::function<void(Status, Value&&)> call = [blockData](Status status, Value &&value) {
-        EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+        EXPECT_EQ(status, Status::SUCCESS);
         blockData->SetValue(true);
     };
     singleKvStore->Get({ "test_key_0" }, "", call);
@@ -247,7 +247,7 @@ HWTEST_F(SingleKvStoreAsyncGetTest, AsyncGetEntriesWithInvalidNetworkId, TestSiz
     EXPECT_EQ(results.size(), 10);
     auto blockData = std::make_shared<BlockData<bool>>(1, false);
     std::function<void(Status, std::vector<Entry>&&)> call = [blockData](Status status, std::vector<Entry> &&value) {
-        EXPECT_EQ(status, Status::INVALID_ARGUMENT);
+        EXPECT_EQ(status, Status::SUCCESS);
         blockData->SetValue(true);
     };
     singleKvStore->GetEntries({ "prefix_key_" }, "", call);
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/data_change_notifier.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h
similarity index 56%
rename from kv_store/frameworks/innerkitsimpl/kvdb/include/data_change_notifier.h
rename to kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h
index 5cc0225b12351cfc32f404afb5a66fa7f8c25658..860f65181c1ee6b69dcd85fc6abe8f706f902d0e 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/data_change_notifier.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/auto_sync_timer.h
@@ -21,24 +21,29 @@
 #include "kvdb_service.h"
 #include "task_executor.h"
 namespace OHOS::DistributedKv {
-class DataChangeNotifier {
+class AutoSyncTimer {
 public:
-    static DataChangeNotifier &GetInstance();
-    void DoNotifyChange(const std::string &appId, std::set<StoreId> storeIds, bool now = false);
+    static constexpr uint32_t FORCE_SYNC_INTERVAL = 200;
+    static constexpr uint32_t AUTO_SYNC_INTERVAL = 50;
+    static AutoSyncTimer &GetInstance();
+    void DoAutoSync(const std::string &appId, std::set<StoreId> storeIds);
 
 private:
-    static constexpr uint32_t NOTIFY_DELAY = 1; // s
-    DataChangeNotifier() = default;
-    ~DataChangeNotifier() = default;
+    static constexpr size_t TIME_TASK_NUM = 5;
+    static constexpr size_t SYNC_STORE_NUM = 10;
+    AutoSyncTimer() = default;
+    ~AutoSyncTimer() = default;
     std::map<std::string, std::vector<StoreId>> GetStoreIds();
-    std::function<void()> GenTask() __attribute__((no_sanitize("cfi")));
+    std::function<void()> ProcessTask() __attribute__((no_sanitize("cfi")));
     void StartTimer();
-    void AddStores(const std::string &appId, std::set<StoreId> storeIds);
-    void DoNotify(const std::string& appId, const std::vector<StoreId> &stores);
-    bool HasStores();
+    void StopTimer();
+    void AddSyncStores(const std::string &appId, std::set<StoreId> storeIds);
+    bool HasSyncStores();
+    std::pair<bool, std::string> HasCollaboration(const std::string &appId);
     ConcurrentMap<std::string, std::vector<StoreId>> stores_;
-    TaskExecutor::TaskId taskId_;
+    TaskExecutor::TaskId delaySyncTaskId_;
+    TaskExecutor::TaskId forceSyncTaskId_;
     std::mutex mutex_;
 };
 } // namespace OHOS::DistributedKv
-#endif // SDB_AUTO_SYNC_TIMER_H
+#endif // SDB_AUTO_SYNC_TIMER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/dev_manager.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/dev_manager.h
index c5862aab46f9a202448eb353538769c7a14c6664..e98401658bc5a9cd3398a72d1ed82bd3ed5a6f85 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/dev_manager.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/dev_manager.h
@@ -33,6 +33,7 @@ public:
     std::string ToNetworkId(const std::string &uuid);
     const DetailInfo &GetLocalDevice();
     std::vector<DetailInfo> GetRemoteDevices();
+    std::string GetUnEncryptedUuid();
 
 private:
     friend class DmDeathCallback;
@@ -47,6 +48,7 @@ private:
     const std::string PKG_NAME;
     const DetailInfo invalidDetail_ {};
     DetailInfo localInfo_ {};
+    DetailInfo UnEncryptedLocalInfo_ {};
     mutable std::mutex mutex_ {};
     mutable LRUBucket<std::string, DetailInfo> deviceInfos_ {64};
 };
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/distributeddata_kvdb_ipc_interface_code.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/distributeddata_kvdb_ipc_interface_code.h
index 6d53f4bd262062d4afc2b4391185a9d99addbb8a..0022d8b525a978198a63f3df1556850bb14e8d6c 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/distributeddata_kvdb_ipc_interface_code.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/distributeddata_kvdb_ipc_interface_code.h
@@ -39,7 +39,6 @@ enum class KVDBServiceInterfaceCode : uint32_t {
     TRANS_SUB,
     TRANS_UNSUB,
     TRANS_GET_PASSWORD,
-    TRANS_SYNC_EXT,
     TRANS_CLOUD_SYNC,
     TRANS_NOTIFY_DATA_CHANGE,
     TRANS_SET_CONFIG,
@@ -48,6 +47,7 @@ enum class KVDBServiceInterfaceCode : uint32_t {
     TRANS_SUBSCRIBE_SWITCH_DATA,
     TRANS_UNSUBSCRIBE_SWITCH_DATA,
     TRANS_CLOSE,
+    TRANS_REMOVE_DEVICE_DATA,
     TRANS_BUTT
 };
 
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_hiview_reporter.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_hiview_reporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd13958591e0308c9880ddeb2b913c445e11d8e3
--- /dev/null
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_hiview_reporter.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KV_HIVIEW_REPORTER_H
+#define KV_HIVIEW_REPORTER_H
+
+#include <string>
+#include "types.h"
+
+namespace OHOS::DistributedKv {
+constexpr const char* OPEN_STORE = "OPEN_STORE";
+constexpr const char* PUT = "PUT";
+constexpr const char* PUTBATCH = "PUTBATCH";
+constexpr const char* DEL = "DELETE";
+constexpr const char* DELETEBATCH = "DELETEBATCH";
+constexpr const char* STARTTRANSACTION = "STARTTRANSACTION";
+constexpr const char* COMMIT = "COMMIT";
+constexpr const char* ROLLBACK = "ROLLBACK";
+constexpr const char* GET = "GET";
+constexpr const char* GETDEVICEENTRIES = "GETDEVICEENTRIES";
+constexpr const char* GETCOUNT = "GETCOUNT";
+constexpr const char* GETSECURITYLEVEL = "GETSECURITYLEVEL";
+constexpr const char* REMOVEDEVICEDATA = "REMOVEDEVICEDATA";
+constexpr const char* GETENTRIES = "GETENTRIES";
+
+struct KVDBCorruptedEvent;
+class KVDBFaultHiViewReporter {
+public:
+    static void ReportKVDBCorruptedFault(
+        const Options &options, uint32_t errorCode, int32_t systemErrorNo,
+        const KvStoreTuple &storeTuple, const std::string &appendix);
+
+private:
+    static void ReportCommonFault(const KVDBCorruptedEvent &eventInfo);
+
+    static std::string GetCurrentMicrosecondTimeFormat();
+};
+} // namespace OHOS::DistributedKv
+#endif //KV_HIVIEW_REPORTER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_types_util.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_types_util.h
index 6c8988c77b06482ad156ba9017ea7c6135d42922..59d267161a7722372b05186f50a300e0837c9e92 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_types_util.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/kv_types_util.h
@@ -39,6 +39,7 @@ using Notification = OHOS::DistributedKv::SwitchNotification;
 using SwitchState = OHOS::DistributedKv::SwitchState;
 using CloudConfig = OHOS::DistributedKv::CloudConfig;
 using StoreConfig = OHOS::DistributedKv::StoreConfig;
+using AuthType = OHOS::DistributedKv::AuthType;
 template<>
 API_EXPORT bool Marshalling(const Blob &input, MessageParcel &data);
 template<>
@@ -119,6 +120,11 @@ API_EXPORT bool Marshalling(const StoreConfig &input, MessageParcel &data);
 template<>
 API_EXPORT bool Unmarshalling(StoreConfig &output, MessageParcel &data);
 
+template<>
+API_EXPORT bool Marshalling(const AuthType &input, MessageParcel &data);
+template<>
+API_EXPORT bool Unmarshalling(AuthType &output, MessageParcel &data);
+
 int64_t GetTotalSize(const std::vector<Entry> &entries);
 int64_t GetTotalSize(const std::vector<Key> &entries);
 } // namespace OHOS::ITypesUtil
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service.h
index bd003bad8a74112aca52ed669d4db91e9dfa94b3..6f18deeed1fa122820b97cead159b77c4884192a 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service.h
@@ -33,6 +33,7 @@ public:
         std::vector<std::string> devices;
         std::string query;
         uint64_t syncId = 0;
+        int32_t triggerMode = 0;
     };
     DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.DistributedKv.KVFeature");
 
@@ -47,7 +48,6 @@ public:
     virtual Status Delete(const AppId &appId, const StoreId &storeId) = 0;
     virtual Status Close(const AppId &appId, const StoreId &storeId) = 0;
     virtual Status Sync(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) = 0;
-    virtual Status SyncExt(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) = 0;
     virtual Status RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier) = 0;
     virtual Status UnregServiceNotifier(const AppId &appId) = 0;
     virtual Status SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam) = 0;
@@ -63,12 +63,13 @@ public:
     virtual Status GetBackupPassword(
         const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password) = 0;
     virtual Status CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo) = 0;
-    virtual Status NotifyDataChange(const AppId &appId, const StoreId &storeId) = 0;
+    virtual Status NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay) = 0;
     virtual Status PutSwitch(const AppId &appId, const SwitchData &data) = 0;
     virtual Status GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data) = 0;
     virtual Status SubscribeSwitchData(const AppId &appId) = 0;
     virtual Status UnsubscribeSwitchData(const AppId &appId) = 0;
     virtual Status SetConfig(const AppId &appId, const StoreId &storeId, const StoreConfig &storeConfig) = 0;
+    virtual Status RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device) = 0;
 };
 } // namespace OHOS::DistributedKv
 #endif // OHOS_DISTRIBUTED_DATA_FRAMEWORKS_KVDB_SERVICE_H
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service_client.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service_client.h
index efe99f20367251041b05f4d1a9e8aa096f530c91..2bbf5131a96f10bd7de56efea3038f16dc41b5c4 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service_client.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/kvdb_service_client.h
@@ -37,7 +37,6 @@ public:
     Status Delete(const AppId &appId, const StoreId &storeId) override;
     Status Close(const AppId &appId, const StoreId &storeId) override;
     Status Sync(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) override;
-    Status SyncExt(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo) override;
     Status RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier) override;
     Status UnregServiceNotifier(const AppId &appIdd) override;
     Status SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam) override;
@@ -52,12 +51,14 @@ public:
     Status Unsubscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer) override;
     Status GetBackupPassword(const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password) override;
     Status CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo) override;
-    Status NotifyDataChange(const AppId &appId, const StoreId &storeId) override;
+    Status NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay) override;
     Status PutSwitch(const AppId &appId, const SwitchData &data) override;
     Status GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data) override;
     Status SubscribeSwitchData(const AppId &appId) override;
     Status UnsubscribeSwitchData(const AppId &appId) override;
     Status SetConfig(const AppId &appId, const StoreId &storeId, const StoreConfig &storeConfig) override;
+    Status RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device) override;
+
     sptr<KVDBNotifierClient> GetServiceAgent(const AppId &appId);
 
 protected:
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h b/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h
index dbcf3c7f882d2b6cc588715abf317ba886f9e862..11c37a47766530312c281e466c57ee7ba03d5c66 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/include/single_store_impl.h
@@ -32,7 +32,6 @@
 namespace OHOS::DistributedKv {
 class SingleStoreImpl : public SingleKvStore,
                         public KvStoreDeathRecipient,
-                        public KvStoreSyncCallback,
                         public std::enable_shared_from_this<SingleStoreImpl> {
 public:
     using Observer = KvStoreObserver;
@@ -46,6 +45,7 @@ public:
     using SyncInfo = KVDBService::SyncInfo;
     using Convert = std::function<Key(const DBKey &key, std::string &deviceId)>;
     using TimePoint = std::chrono::steady_clock::time_point;
+    using DBStatus = DistributedDB::DBStatus;
     SingleStoreImpl(std::shared_ptr<DBStore> dbStore, const AppId &appId, const Options &options, const Convertor &cvt);
     ~SingleStoreImpl();
     StoreId GetStoreId() const override;
@@ -77,8 +77,6 @@ public:
     Status DeleteBackup(const std::vector<std::string> &files, const std::string &baseDir,
         std::map<std::string, DistributedKv::Status> &status) override;
     void OnRemoteDied() override;
-    void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override;
-    void SyncCompleted(const std::map<std::string, Status> &results) override;
 
     // normal function
     int32_t Close(bool isForce = false);
@@ -112,7 +110,13 @@ private:
         std::function<void(Status, Value &&)> toGet;
         std::function<void(Status, std::vector<Entry> &&)> toGetEntries;
     };
-
+    static inline uint64_t GetTimeStamp(uint32_t offset = 0)
+    {
+        return std::chrono::duration_cast<std::chrono::milliseconds>(
+            (std::chrono::steady_clock::now() + std::chrono::milliseconds(offset)).time_since_epoch())
+            .count();
+    }
+    static constexpr uint32_t NOTIFY_INTERVAL = 200; // ms
     static constexpr size_t MAX_VALUE_LENGTH = 4 * 1024 * 1024;
     static constexpr size_t MAX_OBSERVER_SIZE = 8;
     static constexpr Duration SYNC_DURATION = std::chrono::seconds(60);
@@ -123,13 +127,14 @@ private:
     Status RetryWithCheckPoint(std::function<DistributedDB::DBStatus()> lambda);
     std::function<void(ObserverBridge *)> BridgeReleaser();
     Status DoSync(SyncInfo &syncInfo, std::shared_ptr<SyncCallback> observer);
-    Status DoSyncExt(SyncInfo &syncInfo, std::shared_ptr<SyncCallback> observer);
     Status DoClientSync(SyncInfo &syncInfo, std::shared_ptr<SyncCallback> observer);
-    Status SyncExt(const std::string &networkId, uint64_t sequenceId);
+    void DoAutoSync();
     bool IsRemoteChanged(const std::string &deviceId);
     void DoNotifyChange();
     void Register();
+    void ReportDBCorruptedFault(Status status, const std::string &appendIX) const;
 
+    bool isApplication_ = false;
     bool autoSync_ = false;
     bool cloudAutoSync_ = false;
     bool isClientSync_ = false;
@@ -141,6 +146,14 @@ private:
     int32_t dataType_ = DataType::TYPE_DYNAMICAL;
     uint32_t roleType_ = 0;
     uint64_t taskId_ = 0;
+
+    bool encrypt_ = false;
+    int32_t securityLevel_ = -1;
+    int32_t area_ = 1;
+    std::string hapName_ = "";
+
+    std::mutex notifyMutex_;
+    uint64_t notifyExpiredTime_ = 0;
     std::shared_ptr<DBStore> dbStore_ = nullptr;
     std::shared_ptr<SyncObserver> syncObserver_ = nullptr;
     ConcurrentMap<uintptr_t, std::pair<uint32_t, std::shared_ptr<ObserverBridge>>> observers_;
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c5236b36276ae908eb844aad7b4844dfe960bb7
--- /dev/null
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "AutoSyncTimer"
+#include "auto_sync_timer.h"
+
+#include "dms_handler.h"
+#include "ipc_skeleton.h"
+#include "kvdb_service_client.h"
+#include "log_print.h"
+
+namespace OHOS::DistributedKv {
+AutoSyncTimer &AutoSyncTimer::GetInstance()
+{
+    static AutoSyncTimer instance;
+    return instance;
+}
+
+void AutoSyncTimer::StartTimer()
+{
+    std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
+    if (forceSyncTaskId_ == TaskExecutor::INVALID_TASK_ID) {
+        forceSyncTaskId_ =
+            TaskExecutor::GetInstance().Schedule(std::chrono::milliseconds(FORCE_SYNC_INTERVAL), ProcessTask());
+    }
+    if (delaySyncTaskId_ == TaskExecutor::INVALID_TASK_ID) {
+        delaySyncTaskId_ =
+            TaskExecutor::GetInstance().Schedule(std::chrono::milliseconds(AUTO_SYNC_INTERVAL), ProcessTask());
+    } else {
+        delaySyncTaskId_ =
+            TaskExecutor::GetInstance().Reset(delaySyncTaskId_, std::chrono::milliseconds(AUTO_SYNC_INTERVAL));
+    }
+}
+
+void AutoSyncTimer::DoAutoSync(const std::string &appId, std::set<StoreId> storeIds)
+{
+    AddSyncStores(appId, std::move(storeIds));
+    StartTimer();
+}
+
+void AutoSyncTimer::AddSyncStores(const std::string &appId, std::set<StoreId> storeIds)
+{
+    stores_.Compute(appId, [&storeIds](const auto &key, std::vector<StoreId> &value) {
+        std::set<StoreId> tempStores(value.begin(), value.end());
+        for (auto it = storeIds.begin(); it != storeIds.end(); it++) {
+            if (tempStores.count(*it) == 0) {
+                value.push_back(*it);
+            }
+        }
+        return !value.empty();
+    });
+}
+
+bool AutoSyncTimer::HasSyncStores()
+{
+    return !stores_.Empty();
+}
+
+std::map<std::string, std::vector<StoreId>> AutoSyncTimer::GetStoreIds()
+{
+    std::map<std::string, std::vector<StoreId>> stores;
+    int count = SYNC_STORE_NUM;
+    stores_.EraseIf([&stores, &count](const std::string &key, std::vector<StoreId> &value) {
+        int size = value.size();
+        if (size <= count) {
+            stores.insert({ key, std::move(value) });
+            count = count - size;
+            return true;
+        }
+        auto &innerStore = stores[key];
+        auto it = value.begin();
+        while (it != value.end() && count > 0) {
+            innerStore.push_back(*it);
+            it++;
+            count--;
+        }
+        value.erase(value.begin(), it);
+        return value.empty();
+    });
+    return stores;
+}
+
+std::function<void()> AutoSyncTimer::ProcessTask()
+{
+    return [this]() {
+        StopTimer();
+        auto service = KVDBServiceClient::GetInstance();
+        if (service == nullptr) {
+            StartTimer();
+            return;
+        }
+        auto storeIds = GetStoreIds();
+        for (const auto &id : storeIds) {
+            auto res = HasCollaboration(id.first);
+            if (!res.first) {
+                continue;
+            }
+            KVDBService::SyncInfo syncInfo;
+            syncInfo.devices.push_back(res.second);
+            ZLOGD("DoSync appId:%{public}s store size:%{public}zu", id.first.c_str(), id.second.size());
+            for (const auto &storeId : id.second) {
+                service->Sync({ id.first }, storeId, syncInfo);
+            }
+        }
+        if (HasSyncStores()) {
+            StartTimer();
+        }
+    };
+}
+
+std::pair<bool, std::string> AutoSyncTimer::HasCollaboration(const std::string &appId)
+{
+    std::vector<DistributedSchedule::EventNotify> events;
+    auto status = DistributedSchedule::DmsHandler::GetInstance().GetDSchedEventInfo(
+        DistributedSchedule::DMS_COLLABORATION, events);
+    if (status != SUCCESS) {
+        ZLOGE("Get collaboration events failed, status:%{public}d", status);
+        return { false, "" };
+    }
+    for (const auto &event : events) {
+        if (event.srcBundleName_ == appId || event.destBundleName_ == appId) {
+            ZLOGI("The application is collaboration, srcBundleName:%{public}s, destBundleName:%{public}s",
+                event.srcBundleName_.c_str(), event.destBundleName_.c_str());
+            return { true, std::move(event.dstNetworkId_) };
+        }
+    }
+    ZLOGD("The application is not collaboration, appId:%{public}s", appId.c_str());
+    return { false, "" };
+}
+
+void AutoSyncTimer::StopTimer()
+{
+    std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
+    TaskExecutor::GetInstance().Remove(forceSyncTaskId_);
+    TaskExecutor::GetInstance().Remove(delaySyncTaskId_);
+    forceSyncTaskId_ = TaskExecutor::INVALID_TASK_ID;
+    delaySyncTaskId_ = TaskExecutor::INVALID_TASK_ID;
+}
+} // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/data_change_notifier.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer_mock.cpp
similarity index 35%
rename from kv_store/frameworks/innerkitsimpl/kvdb/src/data_change_notifier.cpp
rename to kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer_mock.cpp
index cee7aeb6a07a9bcdbc7e4dca9b74254689a48e75..c6212b22ae7da30d54a2bc6090305ae8527935cc 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/data_change_notifier.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/auto_sync_timer_mock.cpp
@@ -12,40 +12,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#define LOG_TAG "DataChangeNotifier"
-#include "data_change_notifier.h"
+#define LOG_TAG "AutoSyncTimerMock"
+#include "auto_sync_timer.h"
 
 #include "kvdb_service_client.h"
 #include "log_print.h"
 
 namespace OHOS::DistributedKv {
-DataChangeNotifier &DataChangeNotifier::GetInstance()
+AutoSyncTimer &AutoSyncTimer::GetInstance()
 {
-    static DataChangeNotifier instance;
+    static AutoSyncTimer instance;
     return instance;
 }
 
-void DataChangeNotifier::StartTimer()
+void AutoSyncTimer::StartTimer()
 {
     std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
-    if (taskId_ == TaskExecutor::INVALID_TASK_ID) {
-        taskId_ = TaskExecutor::GetInstance().Schedule(std::chrono::seconds(NOTIFY_DELAY), GenTask());
-        return;
+    if (forceSyncTaskId_ == TaskExecutor::INVALID_TASK_ID) {
+        forceSyncTaskId_ =
+            TaskExecutor::GetInstance().Schedule(std::chrono::milliseconds(FORCE_SYNC_INTERVAL), ProcessTask());
+    }
+    if (delaySyncTaskId_ == TaskExecutor::INVALID_TASK_ID) {
+        delaySyncTaskId_ =
+            TaskExecutor::GetInstance().Schedule(std::chrono::milliseconds(AUTO_SYNC_INTERVAL), ProcessTask());
+    } else {
+        delaySyncTaskId_ =
+            TaskExecutor::GetInstance().Reset(delaySyncTaskId_, std::chrono::milliseconds(AUTO_SYNC_INTERVAL));
     }
-    taskId_ = TaskExecutor::GetInstance().Reset(taskId_, std::chrono::seconds(NOTIFY_DELAY));
 }
 
-void DataChangeNotifier::DoNotifyChange(const std::string &appId, std::set<StoreId> storeIds, bool now)
+void AutoSyncTimer::DoAutoSync(const std::string &appId, std::set<StoreId> storeIds)
 {
-    if (now) {
-        DoNotify(appId, { storeIds.begin(), storeIds.end() });
-        return;
-    }
-    AddStores(appId, std::move(storeIds));
+    AddSyncStores(appId, std::move(storeIds));
     StartTimer();
 }
 
-void DataChangeNotifier::AddStores(const std::string &appId, std::set<StoreId> storeIds)
+void AutoSyncTimer::AddSyncStores(const std::string &appId, std::set<StoreId> storeIds)
 {
     stores_.Compute(appId, [&storeIds](const auto &key, std::vector<StoreId> &value) {
         std::set<StoreId> tempStores(value.begin(), value.end());
@@ -58,47 +60,73 @@ void DataChangeNotifier::AddStores(const std::string &appId, std::set<StoreId> s
     });
 }
 
-bool DataChangeNotifier::HasStores()
+bool AutoSyncTimer::HasSyncStores()
 {
     return !stores_.Empty();
 }
 
-std::map<std::string, std::vector<StoreId>> DataChangeNotifier::GetStoreIds()
+std::map<std::string, std::vector<StoreId>> AutoSyncTimer::GetStoreIds()
 {
     std::map<std::string, std::vector<StoreId>> stores;
-    stores_.EraseIf([&stores](const std::string &key, std::vector<StoreId> &value) {
-        stores.insert({ key, std::move(value) });
-        return true;
+    int count = SYNC_STORE_NUM;
+    stores_.EraseIf([&stores, &count](const std::string &key, std::vector<StoreId> &value) {
+        int size = value.size();
+        if (size <= count) {
+            stores.insert({ key, std::move(value) });
+            count = count - size;
+            return true;
+        }
+        auto &innerStore = stores[key];
+        auto it = value.begin();
+        while (it != value.end() && count > 0) {
+            innerStore.push_back(*it);
+            it++;
+            count--;
+        }
+        value.erase(value.begin(), it);
+        return value.empty();
     });
     return stores;
 }
 
-std::function<void()> DataChangeNotifier::GenTask()
+std::function<void()> AutoSyncTimer::ProcessTask()
 {
     return [this]() {
-        {
-            std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
-            taskId_ = TaskExecutor::INVALID_TASK_ID;
+        StopTimer();
+        auto service = KVDBServiceClient::GetInstance();
+        if (service == nullptr) {
+            StartTimer();
+            return;
         }
         auto storeIds = GetStoreIds();
         for (const auto &id : storeIds) {
-            DoNotify({ id.first }, id.second);
+            auto res = HasCollaboration(id.first);
+            if (!res.first) {
+                continue;
+            }
+            ZLOGD("DoSync appId:%{public}s store size:%{public}zu", id.first.c_str(), id.second.size());
+            for (const auto &storeId : id.second) {
+                KVDBService::SyncInfo syncInfo;
+                service->Sync({ id.first }, storeId, syncInfo);
+            }
         }
-        if (HasStores()) {
+        if (HasSyncStores()) {
             StartTimer();
         }
     };
 }
 
-void DataChangeNotifier::DoNotify(const std::string& appId, const std::vector<StoreId> &stores)
+std::pair<bool, std::string> AutoSyncTimer::HasCollaboration(const std::string &appId)
 {
-    auto service = KVDBServiceClient::GetInstance();
-    if (service == nullptr) {
-        return;
-    }
-    for (const auto &store : stores) {
-        service->NotifyDataChange({ appId }, store);
-    }
-    ZLOGD("Notify change appId:%{public}s store size:%{public}zu", appId.c_str(), stores.size());
+    return { true, "" };
+}
+
+void AutoSyncTimer::StopTimer()
+{
+    std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
+    TaskExecutor::GetInstance().Remove(forceSyncTaskId_);
+    TaskExecutor::GetInstance().Remove(delaySyncTaskId_);
+    forceSyncTaskId_ = TaskExecutor::INVALID_TASK_ID;
+    delaySyncTaskId_ = TaskExecutor::INVALID_TASK_ID;
 }
-} // namespace OHOS::DistributedKv
+} // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/dev_manager.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/dev_manager.cpp
index 58620ed02b59561d9bee5d3575a2d959d0c28aea..8d0829d1016298ebff151f591a4e8ede7a3b61f5 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/dev_manager.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/dev_manager.cpp
@@ -120,6 +120,36 @@ void DevManager::UpdateBucket()
     }
 }
 
+std::string DevManager::GetUnEncryptedUuid()
+{
+    std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
+    if (!UnEncryptedLocalInfo_.uuid.empty()) {
+        return UnEncryptedLocalInfo_.uuid;
+    }
+    DevInfo info;
+    auto ret = DeviceManager::GetInstance().GetLocalDeviceInfo(PKG_NAME, info);
+    if (ret != DM_OK) {
+        ZLOGE("get local device info fail");
+        return "";
+    }
+    auto networkId = std::string(info.networkId);
+    if (networkId.empty()) {
+        ZLOGE("networkid empty");
+        return "";
+    }
+    std::string uuid;
+    DeviceManager::GetInstance().GetUuidByNetworkId(PKG_NAME, networkId, uuid);
+    if (uuid.empty()) {
+        ZLOGE("get uuid by networkid fail");
+        return "";
+    }
+    UnEncryptedLocalInfo_.uuid = std::move(uuid);
+    ZLOGI("[GetUnEncryptedUuid] uuid:%{public}s, networkId:%{public}s",
+        StoreUtil::Anonymous(UnEncryptedLocalInfo_.uuid).c_str(),
+        StoreUtil::Anonymous(networkId).c_str());
+    return UnEncryptedLocalInfo_.uuid;
+}
+
 const DevManager::DetailInfo &DevManager::GetLocalDevice()
 {
     std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c86da91dacaa3a0a4ee69dd244199b1833d249a
--- /dev/null
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter.cpp
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "KVDBFaultHiViewReporter"
+
+#include "kv_hiview_reporter.h"
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+#include "hisysevent_c.h"
+#include "log_print.h"
+#include "types.h"
+
+namespace OHOS::DistributedKv {
+
+static constexpr const char *EVENT_NAME = "DATABASE_CORRUPTED";
+static constexpr const char *DISTRIBUTED_DATAMGR = "DISTDATAMGR";
+struct KVDBCorruptedEvent {
+    std::string bundleName;
+    std::string moduleName;
+    std::string storeType;
+    std::string storeName;
+    uint32_t securityLevel;
+    uint32_t pathArea;
+    uint32_t encryptStatus;
+    uint32_t integrityCheck = 0;
+    uint32_t errorCode = 0;
+    int32_t systemErrorNo = 0;
+    std::string appendix;
+    std::string errorOccurTime;
+
+    explicit KVDBCorruptedEvent(const Options &options) : storeType("KVDB")
+    {
+        moduleName = options.hapName;
+        securityLevel = static_cast<uint32_t>(options.securityLevel);
+        pathArea = static_cast<uint32_t>(options.area);
+        encryptStatus = static_cast<uint32_t>(options.encrypt);
+    }
+};
+
+void KVDBFaultHiViewReporter::ReportKVDBCorruptedFault(
+    const Options &options, uint32_t errorCode, int32_t systemErrorNo,
+    const KvStoreTuple &storeTuple, const std::string &appendix)
+{
+    KVDBCorruptedEvent eventInfo(options);
+    eventInfo.errorCode = errorCode;
+    eventInfo.systemErrorNo = systemErrorNo;
+    eventInfo.appendix = appendix;
+    eventInfo.storeName = storeTuple.storeId;
+    eventInfo.bundleName = storeTuple.appId;
+    eventInfo.errorOccurTime = GetCurrentMicrosecondTimeFormat();
+    ReportCommonFault(eventInfo);
+}
+
+std::string KVDBFaultHiViewReporter::GetCurrentMicrosecondTimeFormat()
+{
+    auto now = std::chrono::system_clock::now();
+    auto now_ms = std::chrono::time_point_cast<std::chrono::microseconds>(now);
+    auto epoch = now_ms.time_since_epoch();
+    auto value = std::chrono::duration_cast<std::chrono::microseconds>(epoch);
+    auto timestamp = value.count();
+
+    std::time_t tt = std::chrono::system_clock::to_time_t(now);
+    std::tm *tm = std::localtime(&tt);
+    if (tm == nullptr) {
+        ZLOGE("Failed localtime is nullptr");
+        return "";
+    }
+
+    const int offset = 1000;
+    const int width = 3;
+    std::stringstream oss;
+    oss << std::put_time(tm, "%Y-%m-%d %H:%M:%S.") << std::setfill('0') << std::setw(width)
+        << ((timestamp / offset) % offset) << "." << std::setfill('0') << std::setw(width) << (timestamp % offset);
+    return oss.str();
+}
+
+void KVDBFaultHiViewReporter::ReportCommonFault(const KVDBCorruptedEvent &eventInfo)
+{
+    char *bundleName = const_cast<char *>(eventInfo.bundleName.c_str());
+    char *moduleName = const_cast<char *>(eventInfo.moduleName.c_str());
+    char *storeType = const_cast<char *>(eventInfo.storeType.c_str());
+    char *storeName = const_cast<char *>(eventInfo.storeName.c_str());
+    uint32_t checkType = eventInfo.integrityCheck;
+    char *appendix = const_cast<char *>(eventInfo.appendix.c_str());
+    char *errorOccurTime = const_cast<char *>(eventInfo.errorOccurTime.c_str());
+    HiSysEventParam params[] = {
+        { .name = "BUNDLE_NAME", .t = HISYSEVENT_STRING, .v = { .s = bundleName }, .arraySize = 0 },
+        { .name = "MODULE_NAME", .t = HISYSEVENT_STRING, .v = { .s = moduleName }, .arraySize = 0 },
+        { .name = "STORE_TYPE", .t = HISYSEVENT_STRING, .v = { .s = storeType }, .arraySize = 0 },
+        { .name = "STORE_NAME", .t = HISYSEVENT_STRING, .v = { .s = storeName }, .arraySize = 0 },
+        { .name = "SECURITY_LEVEL", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.securityLevel }, .arraySize = 0 },
+        { .name = "PATH_AREA", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.pathArea }, .arraySize = 0 },
+        { .name = "ENCRYPT_STATUS", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.encryptStatus }, .arraySize = 0 },
+        { .name = "INTEGRITY_CHECK", .t = HISYSEVENT_UINT32, .v = { .ui32 = checkType }, .arraySize = 0 },
+        { .name = "ERROR_CODE", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.errorCode }, .arraySize = 0 },
+        { .name = "ERRNO", .t = HISYSEVENT_INT32, .v = { .i32 = eventInfo.systemErrorNo }, .arraySize = 0 },
+        { .name = "APPENDIX", .t = HISYSEVENT_STRING, .v = { .s = appendix }, .arraySize = 0 },
+        { .name = "ERROR_TIME", .t = HISYSEVENT_STRING, .v = { .s = errorOccurTime }, .arraySize = 0 },
+    };
+
+    OH_HiSysEvent_Write(DISTRIBUTED_DATAMGR, EVENT_NAME, HISYSEVENT_FAULT, params, sizeof(params) / sizeof(params[0]));
+}
+} // namespace OHOS::NativeRdb
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter_mock.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d5d2a70b507d2be80b3f4df62ad934d86a831aaa
--- /dev/null
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter_mock.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "KVDBFaultHiViewReporterMock"
+
+#include "kv_hiview_reporter.h"
+
+namespace OHOS::DistributedKv {
+struct KVDBCorruptedEvent {
+    std::string bundleName;
+    std::string moduleName;
+    std::string storeType;
+    std::string storeName;
+    uint32_t securityLevel;
+    uint32_t pathArea;
+    uint32_t encryptStatus;
+    uint32_t integrityCheck = 0;
+    uint32_t errorCode = 0;
+    int32_t systemErrorNo = 0;
+    std::string appendix;
+    std::string errorOccurTime;
+
+    explicit KVDBCorruptedEvent(const Options &options) : storeType("KVDB")
+    {
+        moduleName = options.hapName;
+        securityLevel = static_cast<uint32_t>(options.securityLevel);
+        pathArea = static_cast<uint32_t>(options.area);
+        encryptStatus = static_cast<uint32_t>(options.encrypt);
+    }
+};
+
+void KVDBFaultHiViewReporter::ReportKVDBCorruptedFault(
+    const Options &options, uint32_t errorCode, int32_t systemErrorNo,
+    const KvStoreTuple &storeTuple, const std::string &appendix)
+{
+    KVDBCorruptedEvent eventInfo(options);
+    eventInfo.errorCode = errorCode;
+    eventInfo.systemErrorNo = systemErrorNo;
+    eventInfo.appendix = appendix;
+    eventInfo.storeName = storeTuple.storeId;
+    eventInfo.bundleName = storeTuple.appId;
+    eventInfo.errorOccurTime = GetCurrentMicrosecondTimeFormat();
+    ReportCommonFault(eventInfo);
+}
+
+std::string KVDBFaultHiViewReporter::GetCurrentMicrosecondTimeFormat()
+{
+    return "";
+}
+
+void KVDBFaultHiViewReporter::ReportCommonFault(__attribute__((unused))
+    const KVDBCorruptedEvent &eventInfo)
+{
+    return;
+}
+} // namespace OHOS::NativeRdb
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_types_util.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_types_util.cpp
index 1f59bc3fe1ae7e6d2d35ed84f3c332707512c8cf..b0ebcadbe59103c02e8134edc59fa9e774cf5849 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_types_util.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/kv_types_util.cpp
@@ -106,7 +106,7 @@ template<>
 bool Marshalling(const Options &input, MessageParcel &data)
 {
     if (!ITypesUtil::Marshal(data, input.schema, input.hapName, input.policies, input.cloudConfig.enableCloud,
-                             input.cloudConfig.autoSync)) {
+                             input.cloudConfig.autoSync, input.authType)) {
         ZLOGE("write policies failed");
         return false;
     }
@@ -132,7 +132,7 @@ template<>
 bool Unmarshalling(Options &output, MessageParcel &data)
 {
     if (!ITypesUtil::Unmarshal(data, output.schema, output.hapName, output.policies, output.cloudConfig.enableCloud,
-                               output.cloudConfig.autoSync)) {
+                               output.cloudConfig.autoSync, output.authType)) {
         ZLOGE("read policies failed");
         return false;
     }
@@ -156,6 +156,23 @@ bool Unmarshalling(Options &output, MessageParcel &data)
     return true;
 }
 
+template<>
+bool Marshalling(const AuthType &input, MessageParcel &data)
+{
+    return ITypesUtil::Marshal(data, static_cast<int32_t>(input));
+}
+
+template<>
+bool Unmarshalling(AuthType &output, MessageParcel &data)
+{
+    int32_t authType;
+    if (!ITypesUtil::Unmarshal(data, authType)) {
+        return false;
+    }
+    output = static_cast<AuthType>(authType);
+    return true;
+}
+
 template<>
 bool Marshalling(const SyncPolicy &input, MessageParcel &data)
 {
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/kvdb_service_client.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/kvdb_service_client.cpp
index 11a039a0e78da154e1141b19cab3c61deeb35c96..2360c771239768c0c006684d22d999b32ad6d1a2 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/kvdb_service_client.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/kvdb_service_client.cpp
@@ -188,23 +188,11 @@ Status KVDBServiceClient::CloudSync(const AppId &appId, const StoreId &storeId,
     return static_cast<Status>(status);
 }
 
-Status KVDBServiceClient::SyncExt(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo)
-{
-    MessageParcel reply;
-    int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SYNC_EXT), reply, appId,
-        storeId, syncInfo.seqId, syncInfo.mode, syncInfo.devices, syncInfo.delay, syncInfo.query);
-    if (status != SUCCESS) {
-        ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, sequenceId:%{public}" PRIu64,
-            status, appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), syncInfo.seqId);
-    }
-    return static_cast<Status>(status);
-}
-
-Status KVDBServiceClient::NotifyDataChange(const AppId &appId, const StoreId &storeId)
+Status KVDBServiceClient::NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay)
 {
     MessageParcel reply;
     int32_t status = IPC_SEND(
-        static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_NOTIFY_DATA_CHANGE), reply, appId, storeId);
+        static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_NOTIFY_DATA_CHANGE), reply, appId, storeId, delay);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s",
             status, appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
@@ -436,4 +424,16 @@ Status KVDBServiceClient::SetConfig(const AppId &appId, const StoreId &storeId,
     }
     return static_cast<Status>(status);
 }
+
+Status KVDBServiceClient::RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device)
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(
+        static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REMOVE_DEVICE_DATA), reply, appId, storeId, device);
+    if (status != SUCCESS) {
+        ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
+            appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
+    }
+    return static_cast<Status>(status);
+}
 } // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/observer_bridge.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/observer_bridge.cpp
index a557d1ec46ad0da0976f3d179b61469e2e30cd16..e5015d0c56f6b025e6cd58e11cd17fa7a60da981 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/observer_bridge.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/observer_bridge.cpp
@@ -16,6 +16,7 @@
 #include "kvdb_service_client.h"
 #include "kvstore_observer_client.h"
 namespace OHOS::DistributedKv {
+constexpr uint32_t INVALID_SUBSCRIBE_TYPE = 0;
 ObserverBridge::ObserverBridge(AppId appId, StoreId store, std::shared_ptr<Observer> observer, const Convertor &cvt)
     : appId_(std::move(appId)), storeId_(std::move(store)), observer_(std::move(observer)), convert_(cvt)
 {
@@ -87,7 +88,7 @@ void ObserverBridge::OnChange(const DBChangedData &data)
 }
 
 ObserverBridge::ObserverClient::ObserverClient(std::shared_ptr<Observer> observer, const Convertor &cvt)
-    : KvStoreObserverClient(observer), convert_(cvt)
+    : KvStoreObserverClient(observer), convert_(cvt), realType_(INVALID_SUBSCRIBE_TYPE)
 {
 }
 
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/process_system_api_adapter_impl.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/process_system_api_adapter_impl.cpp
index 982d5beb95255053cf0d2500de331ffacfde21bf..aa05ea0c85dbe4e13e5f94541f07b244b6996bb5 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/process_system_api_adapter_impl.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/process_system_api_adapter_impl.cpp
@@ -23,7 +23,7 @@
 namespace OHOS::DistributedKv {
 using Label = DistributedDB::SecurityLabel;
 using Flag = DistributedDB::SecurityFlag;
-using SecurityLabel = FileManagement::ModuleSecurityLabel::SecurityLabel;
+using SecurityLabel = OHOS::FileManagement::ModuleSecurityLabel::SecurityLabel;
 constexpr int32_t HEAD_SIZE = 3;
 constexpr int32_t END_SIZE = 3;
 constexpr const char *REPLACE_CHAIN = "***";
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp
index 7f53f00b485acc07948852098b8a4bb7d6a0d836..eb8a6323d29e4393df8196ea9aae5c6bec76ddfd 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/single_store_impl.cpp
@@ -15,18 +15,24 @@
 #define LOG_TAG "SingleStoreImpl"
 #include "single_store_impl.h"
 
+#include <cerrno>
+#include "accesstoken_kit.h"
+#include "auto_sync_timer.h"
 #include "backup_manager.h"
-#include "data_change_notifier.h"
 #include "dds_trace.h"
 #include "dev_manager.h"
+#include "ipc_skeleton.h"
 #include "kvdb_service_client.h"
 #include "log_print.h"
 #include "store_result_set.h"
 #include "store_util.h"
 #include "task_executor.h"
+#include "kv_hiview_reporter.h"
+
 namespace OHOS::DistributedKv {
 using namespace OHOS::DistributedDataDfx;
 using namespace std::chrono;
+using namespace Security::AccessToken;
 SingleStoreImpl::SingleStoreImpl(
     std::shared_ptr<DBStore> dbStore, const AppId &appId, const Options &options, const Convertor &cvt)
     : convertor_(cvt), dbStore_(std::move(dbStore))
@@ -40,9 +46,17 @@ SingleStoreImpl::SingleStoreImpl(
     syncObserver_ = std::make_shared<SyncObserver>();
     roleType_ = options.role;
     dataType_ = options.dataType;
+    encrypt_ = options.encrypt;
+    securityLevel_ = options.securityLevel;
+    area_ = options.area;
+    hapName_ = options.hapName;
     if (options.backup) {
         BackupManager::GetInstance().Prepare(path, storeId_);
     }
+    uint32_t tokenId = IPCSkeleton::GetSelfTokenID();
+    if (AccessTokenKit::GetTokenTypeFlag(tokenId) == TOKEN_HAP) {
+        isApplication_ = true;
+    }
 }
 
 SingleStoreImpl::~SingleStoreImpl()
@@ -86,10 +100,12 @@ Status SingleStoreImpl::Put(const Key &key, const Value &value)
     }
 
     auto status = RetryWithCheckPoint([this, &dbKey, &value]() { return dbStore_->Put(dbKey, value); });
+    ReportDBCorruptedFault(status, PUT);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x key:%{public}s, value size:%{public}zu", status,
             StoreUtil::Anonymous(key.ToString()).c_str(), value.Size());
     }
+    DoAutoSync();
     DoNotifyChange();
     return status;
 }
@@ -117,9 +133,11 @@ Status SingleStoreImpl::PutBatch(const std::vector<Entry> &entries)
     }
 
     auto status = RetryWithCheckPoint([this, &dbEntries]() { return dbStore_->PutBatch(dbEntries); });
+    ReportDBCorruptedFault(status, PUTBATCH);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x entries size:%{public}zu", status, entries.size());
     }
+    DoAutoSync();
     DoNotifyChange();
     return status;
 }
@@ -140,9 +158,11 @@ Status SingleStoreImpl::Delete(const Key &key)
     }
 
     auto status = RetryWithCheckPoint([this, &dbKey]() { return dbStore_->Delete(dbKey); });
+    ReportDBCorruptedFault(status, DEL);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x key:%{public}s", status, StoreUtil::Anonymous(key.ToString()).c_str());
     }
+    DoAutoSync();
     DoNotifyChange();
     return status;
 }
@@ -167,9 +187,11 @@ Status SingleStoreImpl::DeleteBatch(const std::vector<Key> &keys)
     }
 
     auto status = RetryWithCheckPoint([this, &dbKeys]() { return dbStore_->DeleteBatch(dbKeys); });
+    ReportDBCorruptedFault(status, DELETEBATCH);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x keys size:%{public}zu", status, keys.size());
     }
+    DoAutoSync();
     DoNotifyChange();
     return status;
 }
@@ -184,6 +206,7 @@ Status SingleStoreImpl::StartTransaction()
     }
 
     auto status = RetryWithCheckPoint([this]() { return dbStore_->StartTransaction(); });
+    ReportDBCorruptedFault(status, STARTTRANSACTION);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x storeId:%{public}s", status, StoreUtil::Anonymous(storeId_).c_str());
     }
@@ -201,6 +224,7 @@ Status SingleStoreImpl::Commit()
 
     auto dbStatus = dbStore_->Commit();
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, COMMIT);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x storeId:%{public}s", status, StoreUtil::Anonymous(storeId_).c_str());
     }
@@ -218,6 +242,7 @@ Status SingleStoreImpl::Rollback()
 
     auto dbStatus = dbStore_->Rollback();
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, ROLLBACK);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x storeId:%{public}s", status, StoreUtil::Anonymous(storeId_).c_str());
     }
@@ -330,6 +355,7 @@ Status SingleStoreImpl::Get(const Key &key, Value &value)
     auto dbStatus = dbStore_->Get(dbKey, dbValue);
     value = std::move(dbValue);
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, GET);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x key:%{public}s", status, StoreUtil::Anonymous(key.ToString()).c_str());
     }
@@ -354,53 +380,6 @@ void SingleStoreImpl::GetEntries(const Key &prefix, const std::string &networkId
     onResult(status, std::move(entries));
 }
 
-Status SingleStoreImpl::SyncExt(const std::string &networkId, uint64_t sequenceId)
-{
-    auto clientUuid = DevManager::GetInstance().ToUUID(networkId);
-    if (clientUuid.empty()) {
-        ZLOGE("clientUuid is empty");
-        return INVALID_ARGUMENT;
-    }
-    KVDBService::SyncInfo syncInfo;
-    syncInfo.mode = SyncMode::PULL;
-    syncInfo.seqId = sequenceId;
-    syncInfo.devices = { networkId };
-    auto status = DoSyncExt(syncInfo, shared_from_this());
-    if (status != SUCCESS) {
-        ZLOGE("sync ext failed, status:%{public}d networkId:%{public}s app:%{public}s store:%{public}s", status,
-            StoreUtil::Anonymous(networkId).c_str(), appId_.c_str(), StoreUtil::Anonymous(storeId_).c_str());
-        return status;
-    }
-    return SUCCESS;
-}
-
-void SingleStoreImpl::SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId)
-{
-    AsyncFunc asyncFunc;
-    auto exist = asyncFuncs_.ComputeIfPresent(sequenceId, [&asyncFunc](const auto &key, const auto &value) -> bool {
-        asyncFunc = value;
-        return false;
-    });
-    if (!exist) {
-        ZLOGD("not exist, sequenceId:%{public}" PRIu64, sequenceId);
-        return ;
-    }
-    if (asyncFunc.toGet) {
-        Value value;
-        auto status = Get(asyncFunc.key, value);
-        asyncFunc.toGet(status, std::move(value));
-        return;
-    }
-    if (asyncFunc.toGetEntries) {
-        std::vector<Entry> entries;
-        auto status = GetEntries(asyncFunc.key, entries);
-        asyncFunc.toGetEntries(status, std::move(entries));
-        return;
-    }
-    ZLOGW("sync ext completed, but do nothing, key:%{public}s, sequenceId:%{public}" PRIu64,
-        StoreUtil::Anonymous(asyncFunc.key.ToString()).c_str(), sequenceId);
-}
-
 bool SingleStoreImpl::IsRemoteChanged(const std::string &deviceId)
 {
     auto clientUuid = DevManager::GetInstance().ToUUID(deviceId);
@@ -418,9 +397,6 @@ bool SingleStoreImpl::IsRemoteChanged(const std::string &deviceId)
     return serviceAgent->IsChanged(clientUuid, static_cast<DataType>(dataType_));
 }
 
-void SingleStoreImpl::SyncCompleted(const std::map<std::string, Status> &results)
-{}
-
 Status SingleStoreImpl::GetEntries(const Key &prefix, std::vector<Entry> &entries) const
 {
     DdsTrace trace(std::string(LOG_TAG "::") + std::string(__FUNCTION__));
@@ -483,7 +459,16 @@ Status SingleStoreImpl::GetDeviceEntries(const std::string &device, std::vector<
     }
     std::vector<DBEntry> dbEntries;
     std::string devId;
-    auto dbStatus = dbStore_->GetDeviceEntries(device, dbEntries);
+
+    DBStatus dbStatus = DBStatus::DB_ERROR;
+    auto uuid = DevManager::GetInstance().GetUnEncryptedUuid();
+    if (device == uuid) {
+        dbStatus = dbStore_->GetDeviceEntries("", dbEntries);
+        ZLOGI("device equal loacluuid:%{public}s", StoreUtil::Anonymous(uuid).c_str());
+    } else {
+        dbStatus = dbStore_->GetDeviceEntries(device, dbEntries);
+    }
+
     entries.resize(dbEntries.size());
     auto it = entries.begin();
     for (auto &dbEntry : dbEntries) {
@@ -494,6 +479,7 @@ Status SingleStoreImpl::GetDeviceEntries(const std::string &device, std::vector<
     }
 
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, GETDEVICEENTRIES);
     if (status == NOT_FOUND) {
         status = SUCCESS;
     }
@@ -539,6 +525,7 @@ Status SingleStoreImpl::GetCount(const DataQuery &query, int &result) const
     DBQuery dbQuery = convertor_.GetDBQuery(query);
     auto dbStatus = dbStore_->GetCount(dbQuery, result);
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, GETCOUNT);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x query:%{public}s", status, StoreUtil::Anonymous(query.ToString()).c_str());
     }
@@ -558,6 +545,7 @@ Status SingleStoreImpl::GetSecurityLevel(SecurityLevel &secLevel) const
     auto dbStatus = dbStore_->GetSecurityOption(option);
     secLevel = static_cast<SecurityLevel>(StoreUtil::GetSecLevel(option));
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, GETSECURITYLEVEL);
     if (status != SUCCESS) {
         ZLOGE("status:0x%{public}x security:[%{public}d]", status, option.securityLabel);
     }
@@ -572,20 +560,15 @@ Status SingleStoreImpl::RemoveDeviceData(const std::string &device)
         ZLOGE("db:%{public}s already closed!", StoreUtil::Anonymous(storeId_).c_str());
         return ALREADY_CLOSED;
     }
-
-    if (device.empty()) {
-        auto dbStatus = dbStore_->RemoveDeviceData();
-        auto status = StoreUtil::ConvertStatus(dbStatus);
-        if (status != SUCCESS) {
-            ZLOGE("status:0x%{public}x device:all others", status);
-        }
-        return status;
+    auto service = KVDBServiceClient::GetInstance();
+    if (service == nullptr) {
+        return SERVER_UNAVAILABLE;
     }
 
-    auto dbStatus = dbStore_->RemoveDeviceData(DevManager::GetInstance().ToUUID(device));
-    auto status = StoreUtil::ConvertStatus(dbStatus);
+    Status status = service->RemoveDeviceData({ appId_ }, { storeId_ }, device);
+    ReportDBCorruptedFault(status, REMOVEDEVICEDATA);
     if (status != SUCCESS) {
-        ZLOGE("status:0x%{public}x device:%{public}s", status, StoreUtil::Anonymous(device).c_str());
+        ZLOGE("status:%{public}d device:%{public}s", status, StoreUtil::Anonymous(device).c_str());
     }
     return status;
 }
@@ -915,6 +898,7 @@ Status SingleStoreImpl::GetEntries(const DBQuery &query, std::vector<Entry> &ent
     }
 
     auto status = StoreUtil::ConvertStatus(dbStatus);
+    ReportDBCorruptedFault(status, GETENTRIES);
     if (status == NOT_FOUND) {
         status = SUCCESS;
     }
@@ -978,26 +962,6 @@ Status SingleStoreImpl::DoSync(SyncInfo &syncInfo, std::shared_ptr<SyncCallback>
     }
 }
 
-Status SingleStoreImpl::DoSyncExt(SyncInfo &syncInfo, std::shared_ptr<SyncCallback> observer)
-{
-    auto service = KVDBServiceClient::GetInstance();
-    if (service == nullptr) {
-        return SERVER_UNAVAILABLE;
-    }
-    auto serviceAgent = service->GetServiceAgent({ appId_ });
-    if (serviceAgent == nullptr) {
-        ZLOGE("failed! invalid agent app:%{public}s store:%{public}s!",
-            appId_.c_str(), StoreUtil::Anonymous(storeId_).c_str());
-        return ILLEGAL_STATE;
-    }
-    serviceAgent->AddSyncCallback(observer, syncInfo.seqId);
-    auto status = service->SyncExt({ appId_ }, { storeId_ }, syncInfo);
-    if (status != Status::SUCCESS) {
-        serviceAgent->DeleteSyncCallback(syncInfo.seqId);
-    }
-    return status;
-}
-
 Status SingleStoreImpl::SetConfig(const StoreConfig &storeConfig)
 {
     auto service = KVDBServiceClient::GetInstance();
@@ -1009,16 +973,35 @@ Status SingleStoreImpl::SetConfig(const StoreConfig &storeConfig)
 
 void SingleStoreImpl::DoNotifyChange()
 {
-    if (!autoSync_ && !cloudAutoSync_ && dataType_ == DataType::TYPE_DYNAMICAL) {
+    if (!cloudAutoSync_) {
+        return;
+    }
+    auto now = GetTimeStamp();
+    if (now < notifyExpiredTime_) {
         return;
     }
-    ZLOGD("app:%{public}s store:%{public}s dataType:%{public}d!",
-        appId_.c_str(), StoreUtil::Anonymous(storeId_).c_str(), dataType_);
-    if (dataType_ == DataType::TYPE_STATICS) {
-        DataChangeNotifier::GetInstance().DoNotifyChange(appId_, { { storeId_ } }, true);
+    std::lock_guard<decltype(notifyMutex_)> lock(notifyMutex_);
+    if (now < notifyExpiredTime_) {
+        return;
+    }
+    notifyExpiredTime_ = GetTimeStamp(NOTIFY_INTERVAL);
+    TaskExecutor::GetInstance().Execute([app = this->appId_, store = this->storeId_]() {
+        auto service = KVDBServiceClient::GetInstance();
+        if (service == nullptr) {
+            ZLOGD("app:%{public}s store:%{public}s!", app.c_str(), StoreUtil::Anonymous(store).c_str());
+            return;
+        }
+        service->NotifyDataChange({ app }, { store }, NOTIFY_INTERVAL);
+    });
+}
+
+void SingleStoreImpl::DoAutoSync()
+{
+    if (!autoSync_ || !isApplication_) {
         return;
     }
-    DataChangeNotifier::GetInstance().DoNotifyChange(appId_, { { storeId_ } });
+    ZLOGD("app:%{public}s store:%{public}s!", appId_.c_str(), StoreUtil::Anonymous(storeId_).c_str());
+    AutoSyncTimer::GetInstance().DoAutoSync(appId_, { { storeId_ } });
 }
 
 void SingleStoreImpl::OnRemoteDied()
@@ -1073,4 +1056,14 @@ Status SingleStoreImpl::SetIdentifier(const std::string &accountId, const std::s
     }
     return status;
 }
+
+void SingleStoreImpl::ReportDBCorruptedFault(Status status, const std::string &appendIX) const
+{
+    if (status == CRYPT_ERROR) {
+        Options options = { .encrypt = encrypt_, .autoSync = autoSync_, .securityLevel = securityLevel_,
+            .area = area_, .hapName = hapName_ };
+        KvStoreTuple tuple = { .appId = appId_, .storeId = storeId_ };
+        KVDBFaultHiViewReporter::ReportKVDBCorruptedFault(options, status, errno, tuple, appendIX);
+    }
+}
 } // namespace OHOS::DistributedKv
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_factory.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_factory.cpp
index e16eef88ec3bbfa2bbd4cd06a81f69bd6ddb1c73..77c7dba363d8b6871ca90da5fd6324696c6f4494 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_factory.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_factory.cpp
@@ -86,7 +86,7 @@ std::shared_ptr<SingleKvStore> StoreFactory::GetOrOpenStore(const AppId &appId,
                     StoreUtil::Anonymous(storeId.storeId).c_str(), static_cast<int>(status));
                 return !stores.empty();
             }
-            if (dbPassword.isKeyOutdated) {
+            if (dbPassword.isKeyOutdated && options.autoRekey) {
                 ReKey(storeId, path, dbPassword, dbManager, options);
             }
         }
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp
index 86861d641cc75d731b0cb9897a4462f40e0d233e..b34d220f9e00ad93a6aaffe89329b075b0f3dbe4 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/src/store_manager.cpp
@@ -21,6 +21,7 @@
 #include "security_manager.h"
 #include "store_factory.h"
 #include "store_util.h"
+#include "kv_hiview_reporter.h"
 namespace OHOS::DistributedKv {
 StoreManager &StoreManager::GetInstance()
 {
@@ -54,6 +55,10 @@ std::shared_ptr<SingleKvStore> StoreManager::GetKVStore(const AppId &appId, cons
 
     bool isCreate = false;
     auto kvStore = StoreFactory::GetInstance().GetOrOpenStore(appId, storeId, options, status, isCreate);
+    if (status == CRYPT_ERROR) {
+        KvStoreTuple tuple = { .appId = appId.appId, .storeId = storeId.storeId };
+        KVDBFaultHiViewReporter::ReportKVDBCorruptedFault(options, status, errno, tuple, OPEN_STORE);
+    }
     if (isCreate && options.persistent) {
         auto dbPassword = SecurityManager::GetInstance().GetDBPassword(storeId.storeId,
             path, options.encrypt);
@@ -64,12 +69,6 @@ std::shared_ptr<SingleKvStore> StoreManager::GetKVStore(const AppId &appId, cons
         }
         pwd.assign(pwd.size(), 0);
     }
-    if (status == SUCCESS && service != nullptr) {
-        auto serviceAgent = service->GetServiceAgent(appId);
-        if (serviceAgent == nullptr) {
-            ZLOGE("invalid agent app:%{public}s", appId.appId.c_str());
-        }
-    }
     return kvStore;
 }
 
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn b/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn
index 4a74ca363e40b04ff53136fdd6aee1fb0dc9b779..ee7b787312ed89d484d51e7597be50c330e0dc14 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/BUILD.gn
@@ -63,7 +63,6 @@ ohos_source_set("kvdb_src_file") {
   kvdb_sources = [
     "../src/backup_manager.cpp",
     "../src/convertor.cpp",
-    "../src/data_change_notifier.cpp",
     "../src/dev_manager.cpp",
     "../src/device_convertor.cpp",
     "../src/kv_types_util.cpp",
@@ -81,6 +80,11 @@ ohos_source_set("kvdb_src_file") {
   ]
 
   sources = old_sources + kvdb_sources
+  if (qemu_disable) {
+    sources += [ "../src/auto_sync_timer.cpp" ]
+  } else {
+    sources += [ "../src/auto_sync_timer_mock.cpp" ]
+  }
   configs = [ ":module_private_config" ]
 
   deps = [
@@ -90,6 +94,8 @@ ohos_source_set("kvdb_src_file") {
     "//foundation/distributedhardware/device_manager/interfaces/inner_kits/native_cpp:devicemanagersdk",
   ]
   external_deps = [
+    "access_token:libaccesstoken_sdk",
+    "access_token:libtokenid_sdk",
     "c_utils:utils",
     "file_api:securitylabel",
     "hilog:libhilog",
@@ -100,6 +106,9 @@ ohos_source_set("kvdb_src_file") {
     "ipc:ipc_single",
     "samgr:samgr_proxy",
   ]
+  if (dms_service_enable && qemu_disable) {
+    external_deps += [ "dmsfwk:distributed_sdk" ]
+  }
 
   public_external_deps = [
     "data_share:datashare_common",
@@ -112,7 +121,10 @@ ohos_source_set("kvdb_src_file") {
 ohos_unittest("SingleStoreImplTest") {
   module_out_path = module_output_path
 
-  sources = [ "single_store_impl_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "single_store_impl_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -126,7 +138,6 @@ ohos_unittest("SingleStoreImplTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -135,7 +146,10 @@ ohos_unittest("SingleStoreImplTest") {
 ohos_unittest("StoreUtilTest") {
   module_out_path = module_output_path
 
-  sources = [ "store_util_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "store_util_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -149,7 +163,6 @@ ohos_unittest("StoreUtilTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -158,30 +171,10 @@ ohos_unittest("StoreUtilTest") {
 ohos_unittest("BackupManagerTest") {
   module_out_path = module_output_path
 
-  sources = [ "backup_manager_test.cpp" ]
-
-  configs = [ ":module_private_config" ]
-
-  external_deps = [
-    "c_utils:utils",
-    "hilog:libhilog",
-    "ipc:ipc_single",
-    "safwk:system_ability_fwk",
-    "samgr:samgr_proxy",
-  ]
-
-  deps = [
-    ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
-    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
-    "//third_party/googletest:gtest",
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "backup_manager_test.cpp",
   ]
-}
-
-ohos_unittest("DataChangeNotifierTest") {
-  module_out_path = module_output_path
-
-  sources = [ "data_change_notifier_test.cpp" ]
 
   configs = [ ":module_private_config" ]
 
@@ -195,7 +188,6 @@ ohos_unittest("DataChangeNotifierTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -204,7 +196,10 @@ ohos_unittest("DataChangeNotifierTest") {
 ohos_unittest("DevManagerTest") {
   module_out_path = module_output_path
 
-  sources = [ "dev_manager_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "dev_manager_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -218,7 +213,6 @@ ohos_unittest("DevManagerTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -227,7 +221,10 @@ ohos_unittest("DevManagerTest") {
 ohos_unittest("SingleStoreImplGetTopTest") {
   module_out_path = module_output_path
 
-  sources = [ "single_store_impl_get_top_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "single_store_impl_get_top_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -241,7 +238,6 @@ ohos_unittest("SingleStoreImplGetTopTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -250,7 +246,10 @@ ohos_unittest("SingleStoreImplGetTopTest") {
 ohos_unittest("StoreFactoryTest") {
   module_out_path = module_output_path
 
-  sources = [ "store_factory_test.cpp" ]
+  sources = [
+    "../../kvdb/src/kv_hiview_reporter_mock.cpp",
+    "store_factory_test.cpp",
+  ]
 
   configs = [ ":module_private_config" ]
 
@@ -264,7 +263,6 @@ ohos_unittest("StoreFactoryTest") {
 
   deps = [
     ":kvdb_src_file",
-    "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter:distributeddata_adapter",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/:distributeddb",
     "//third_party/googletest:gtest",
   ]
@@ -277,7 +275,6 @@ group("unittest") {
   deps = []
   deps += [
     ":BackupManagerTest",
-    ":DataChangeNotifierTest",
     ":DevManagerTest",
     ":SingleStoreImplGetTopTest",
     ":SingleStoreImplTest",
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/data_change_notifier_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/data_change_notifier_test.cpp
deleted file mode 100644
index 368486da801630804915e502bf8b5d4957283332..0000000000000000000000000000000000000000
--- a/kv_store/frameworks/innerkitsimpl/kvdb/test/data_change_notifier_test.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
-* Copyright (c) 2022 Huawei Device Co., Ltd.
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-#include "data_change_notifier.h"
-
-#include <gtest/gtest.h>
-
-#include "block_data.h"
-#include "kvdb_service_client.h"
-#include "store_manager.h"
-
-using namespace OHOS;
-using namespace testing::ext;
-using namespace OHOS::DistributedKv;
-using namespace std::chrono;
-namespace OHOS::Test {
-class DataChangeNotifierTest : public testing::Test {
-public:
-    class KVDBServiceMock : public KVDBServiceClient {
-    private:
-        static KVDBServiceMock *instance_;
-
-    public:
-        static KVDBServiceMock *GetInstance()
-        {
-            KVDBServiceClient::GetInstance();
-            return instance_;
-        }
-        explicit KVDBServiceMock(const sptr<IRemoteObject> &object) : KVDBServiceClient(object)
-        {
-            instance_ = this;
-        }
-        virtual ~KVDBServiceMock()
-        {
-            instance_ = nullptr;
-        }
-
-        Status NotifyDataChange(const AppId &appId, const StoreId &storeId) override
-        {
-            endTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-            values_[appId.appId].insert(storeId.storeId);
-            {
-                std::lock_guard<decltype(mutex_)> guard(mutex_);
-                ++callCount;
-                value_.SetValue(callCount);
-            }
-            return KVDBServiceClient::NotifyDataChange(appId, storeId);
-        }
-
-        uint32_t GetCallCount(uint32_t value)
-        {
-            uint32_t retry = 0;
-            uint32_t callTimes = 0;
-            while (retry < value) {
-                callTimes = value_.GetValue();
-                if (callTimes >= value) {
-                    break;
-                }
-                std::lock_guard<decltype(mutex_)> guard(mutex_);
-                callTimes = value_.GetValue();
-                if (callTimes >= value) {
-                    break;
-                }
-                value_.Clear(callTimes);
-                retry++;
-            }
-            return callTimes;
-        }
-
-        void ResetToZero()
-        {
-            std::lock_guard<decltype(mutex_)> guard(mutex_);
-            callCount = 0;
-            value_.Clear(0);
-        }
-
-        uint64_t startTime = 0;
-        uint64_t endTime = 0;
-        uint32_t callCount = 0;
-        std::map<std::string, std::set<std::string>> values_;
-        BlockData<uint32_t> value_{ 5, 0 };
-        std::mutex mutex_;
-    };
-    class TestSyncCallback : public KvStoreSyncCallback {
-    public:
-        void SyncCompleted(const std::map<std::string, Status> &results) override
-        {
-            ASSERT_TRUE(true);
-        }
-        void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override
-        {
-            ASSERT_TRUE(true);
-        }
-    };
-    static void SetUpTestCase(void);
-    static void TearDownTestCase(void);
-    void SetUp();
-    void TearDown();
-
-protected:
-    static BrokerDelegator<KVDBServiceMock> delegator_;
-    static constexpr int SLEEP_TIME = 10;
-};
-BrokerDelegator<DataChangeNotifierTest::KVDBServiceMock> DataChangeNotifierTest::delegator_;
-DataChangeNotifierTest::KVDBServiceMock *DataChangeNotifierTest::KVDBServiceMock::instance_ = nullptr;
-void DataChangeNotifierTest::SetUpTestCase(void)
-{
-}
-
-void DataChangeNotifierTest::TearDownTestCase(void)
-{
-}
-
-void DataChangeNotifierTest::SetUp(void)
-{
-}
-
-void DataChangeNotifierTest::TearDown(void)
-{
-    sleep(SLEEP_TIME); // make sure the case has executed completely
-}
-
-/**
-* @tc.name: SingleWriteAtOnce
-* @tc.desc: single write, and notify change at once
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(DataChangeNotifierTest, SingleWriteAtOnce, TestSize.Level0)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", { { "ut_test_store" } }, true);
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(1)), 1);
-    auto it = instance->values_.find("ut_test");
-    ASSERT_NE(it, instance->values_.end());
-    ASSERT_EQ(it->second.count("ut_test_store"), 1);
-    ASSERT_LT(instance->endTime - instance->startTime, 50);
-}
-
-/**
-* @tc.name: SingleWriteOverFiveKvStoreAtOnce
-* @tc.desc: single write over five kvstore, and notify change at once
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(DataChangeNotifierTest, SingleWriteOverFiveKvStoreAtOnce, TestSize.Level0)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", {
-                                                                    { "ut_test_store_0" },
-                                                                    { "ut_test_store_1" },
-                                                                    { "ut_test_store_2" },
-                                                                    { "ut_test_store_3" },
-                                                                    { "ut_test_store_4" },
-                                                                    { "ut_test_store_5" },
-                                                                }, true);
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(6)), 6);
-    auto it = instance->values_.find("ut_test");
-    ASSERT_NE(it, instance->values_.end());
-    ASSERT_EQ(it->second.count("ut_test_store_0"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store_1"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store_2"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store_3"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store_4"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store_5"), 1);
-    ASSERT_LT(instance->endTime - instance->startTime, 50);
-}
-
-/**
-* @tc.name: SingleWrite
-* @tc.desc: single write
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(DataChangeNotifierTest, SingleWrite, TestSize.Level0)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", { { "ut_test_store" } });
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(1)), 1);
-    auto it = instance->values_.find("ut_test");
-    ASSERT_NE(it, instance->values_.end());
-    ASSERT_EQ(it->second.count("ut_test_store"), 1);
-    ASSERT_GE(instance->endTime - instance->startTime, 1000);
-}
-
-/**
-* @tc.name: MultiWrite
-* @tc.desc: write every 100 milliseconds reached 5 times
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
- */
-HWTEST_F(DataChangeNotifierTest, MultiWrite, TestSize.Level1)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    std::thread thread([] {
-        int times = 0;
-        while (times < 5) {
-            DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", { { "ut_test_store" } });
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            times++;
-        }
-    });
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(1)), 1);
-    ASSERT_GE(instance->endTime - instance->startTime, 1400);
-    thread.join();
-    auto it = instance->values_.find("ut_test");
-    ASSERT_NE(it, instance->values_.end());
-    ASSERT_EQ(it->second.count("ut_test_store"), 1);
-}
-
-/**
-* @tc.name: MultiWriteOverFiveKVStores
-* @tc.desc: write every 100 milliseconds reached 5 times
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
-*/
-HWTEST_F(DataChangeNotifierTest, MultiWriteOverFiveKVStores, TestSize.Level1)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    std::thread thread([] {
-        int times = 0;
-        while (times < 5) {
-            DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", {
-                                                                   { "ut_test_store0" },
-                                                                   { "ut_test_store1" },
-                                                                   { "ut_test_store2" },
-                                                                   { "ut_test_store3" },
-                                                                   { "ut_test_store4" },
-                                                                   { "ut_test_store5" },
-                                                               });
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            times++;
-        }
-    });
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(6)), 6);
-    ASSERT_GE(instance->endTime - instance->startTime, 1400);
-    auto it = instance->values_.find("ut_test");
-    ASSERT_EQ(it->second.count("ut_test_store0"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store1"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store2"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store3"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store4"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store5"), 1);
-    thread.join();
-}
-
-/**
-* @tc.name: DoubleWrite
-* @tc.desc: double wirte
-* @tc.type: FUNC
-* @tc.require:
-* @tc.author: zuojiangjiang
- */
-HWTEST_F(DataChangeNotifierTest, DoubleWrite, TestSize.Level1)
-{
-    auto *instance = KVDBServiceMock::GetInstance();
-    ASSERT_NE(instance, nullptr);
-    instance->ResetToZero();
-    instance->startTime = time_point_cast<milliseconds>(system_clock::now()).time_since_epoch().count();
-    instance->endTime = 0;
-    instance->values_.clear();
-    DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", {
-                                                           { "ut_test_store0" },
-                                                           { "ut_test_store1" },
-                                                           { "ut_test_store2" },
-                                                           { "ut_test_store3" },
-                                                           { "ut_test_store4" },
-                                                           { "ut_test_store5" },
-                                                       });
-    DataChangeNotifier::GetInstance().DoNotifyChange("ut_test", {
-                                                           { "ut_test_store-0" },
-                                                           { "ut_test_store-1" },
-                                                           { "ut_test_store-2" },
-                                                           { "ut_test_store-3" },
-                                                           { "ut_test_store-4" },
-                                                           { "ut_test_store-5" },
-                                                       });
-    EXPECT_EQ(static_cast<int>(instance->GetCallCount(12)), 12);
-    ASSERT_GE(instance->endTime - instance->startTime, 1000);
-    auto it = instance->values_.find("ut_test");
-    ASSERT_EQ(it->second.count("ut_test_store0"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store1"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store2"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store3"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store4"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store5"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-0"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-1"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-2"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-3"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-4"), 1);
-    ASSERT_EQ(it->second.count("ut_test_store-5"), 1);
-}
-} // namespace OHOS::Test
\ No newline at end of file
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp
index 853ae072c5c628d04de1f1db179aa0e6d41015f3..11e349a9245bdbcbc7f82078812147eeaae020a4 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/single_store_impl_test.cpp
@@ -1061,6 +1061,26 @@ HWTEST_F(SingleStoreImplTest, GetCount, TestSize.Level0)
     ASSERT_EQ(count, 10);
 }
 
+void ChangeOwnerToService(std::string baseDir, std::string hashId)
+{
+    static constexpr int ddmsId = 3012;
+    std::string path = baseDir;
+    chown(path.c_str(), ddmsId, ddmsId);
+    path = path + "/kvdb";
+    chown(path.c_str(), ddmsId, ddmsId);
+    path = path + "/" + hashId;
+    chown(path.c_str(), ddmsId, ddmsId);
+    path = path + "/single_ver";
+    chown(path.c_str(), ddmsId, ddmsId);
+    chown((path + "/meta").c_str(), ddmsId, ddmsId);
+    chown((path + "/cache").c_str(), ddmsId, ddmsId);
+    path = path + "/main";
+    chown(path.c_str(), ddmsId, ddmsId);
+    chown((path + "/gen_natural_store.db").c_str(), ddmsId, ddmsId);
+    chown((path + "/gen_natural_store.db-shm").c_str(), ddmsId, ddmsId);
+    chown((path + "/gen_natural_store.db-wal").c_str(), ddmsId, ddmsId);
+}
+
 /**
  * @tc.name: RemoveDeviceData
  * @tc.desc: remove local device data
@@ -1088,7 +1108,10 @@ HWTEST_F(SingleStoreImplTest, RemoveDeviceData, TestSize.Level0)
     status = store->GetCount({}, count);
     ASSERT_EQ(status, SUCCESS);
     ASSERT_EQ(count, 10);
-    status = store->RemoveDeviceData(DevManager::GetInstance().GetLocalDevice().uuid);
+    ChangeOwnerToService(
+        "/data/service/el1/public/database/SingleStoreImplTest",
+        "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
+    status = store->RemoveDeviceData(DevManager::GetInstance().GetLocalDevice().networkId);
     ASSERT_EQ(status, SUCCESS);
     status = store->GetCount({}, count);
     ASSERT_EQ(status, SUCCESS);
@@ -1299,6 +1322,9 @@ HWTEST_F(SingleStoreImplTest, RemoveNullDeviceData, TestSize.Level0)
     ASSERT_EQ(status, SUCCESS);
     ASSERT_EQ(count, 10);
     const string device = { "" };
+    ChangeOwnerToService(
+        "/data/service/el1/public/database/SingleStoreImplTest",
+        "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
     status = store->RemoveDeviceData(device);
     ASSERT_EQ(status, SUCCESS);
 }
diff --git a/kv_store/frameworks/innerkitsimpl/kvdb/test/store_factory_test.cpp b/kv_store/frameworks/innerkitsimpl/kvdb/test/store_factory_test.cpp
index 87731f07885120c1dd7635927493e03eca5d217e..f69b0cf80a7443812ff7ca09f4060f5394958ed1 100644
--- a/kv_store/frameworks/innerkitsimpl/kvdb/test/store_factory_test.cpp
+++ b/kv_store/frameworks/innerkitsimpl/kvdb/test/store_factory_test.cpp
@@ -216,6 +216,7 @@ bool StoreFactoryTest::ModifyDate(int time)
 HWTEST_F(StoreFactoryTest, Rekey, TestSize.Level1)
 {
     Status status = DB_ERROR;
+    options.autoRekey = true;
     StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
     ASSERT_EQ(status, SUCCESS);
diff --git a/kv_store/frameworks/jskitsimpl/distributeddata/include/js_schema.h b/kv_store/frameworks/jskitsimpl/distributeddata/include/js_schema.h
index 6cbf7dcafe022a407d5483ab7d9bd2171fde3d48..615b43cb98b63a7255b3e8067a66c91c21d26922 100644
--- a/kv_store/frameworks/jskitsimpl/distributeddata/include/js_schema.h
+++ b/kv_store/frameworks/jskitsimpl/distributeddata/include/js_schema.h
@@ -47,8 +47,8 @@ private:
     static JsSchema* GetSchema(napi_env env, napi_callback_info info, std::shared_ptr<ContextBase> &ctxt);
 
     enum {
-        SCHEMA_MODE_STRICT,
         SCHEMA_MODE_SLOPPY,
+        SCHEMA_MODE_STRICT,
     };
     JsFieldNode* rootNode_ = nullptr;
     napi_env env_ = nullptr;     // manage the root. set/get.
diff --git a/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_schema.h b/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_schema.h
index 38066c28c204d9fcb13fda21443804ea7727d986..f1d5779775be943aa1dcf861e63be5f7e5c637ff 100644
--- a/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_schema.h
+++ b/kv_store/frameworks/jskitsimpl/distributedkvstore/include/js_schema.h
@@ -49,8 +49,8 @@ private:
     static JsSchema* GetSchema(napi_env env, napi_callback_info info, std::shared_ptr<ContextBase> &ctxt);
 
     enum {
-        SCHEMA_MODE_STRICT,
         SCHEMA_MODE_SLOPPY,
+        SCHEMA_MODE_STRICT,
     };
     JsFieldNode* rootNode_ = nullptr;
     napi_env env_ = nullptr;     // manage the root. set/get.
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_constant.h b/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_constant.h
index e8451ca4efcfeba71193b1e35d585683d976d0a6..788ea9c4da27c35270b2c42f3fcf3d9bfe6a7937 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_constant.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_constant.h
@@ -49,6 +49,7 @@ public:
     static constexpr const char *TIMESTAMP = "timestamp";
     static constexpr const char *HASH_KEY = "hash_key";
     static constexpr const char *STATUS = "status";
+    static constexpr const char *CLOUD_FLAG = "cloud_flag";
 
     // kv cloud field
     static constexpr const char *CLOUD_KV_FIELD_KEY = "key";
@@ -71,10 +72,13 @@ public:
 
     static constexpr const char *CLOUD_VERSION_RECORD_PREFIX_KEY = "naturalbase_cloud_version_";
 
+    static constexpr const char *FLAG_AND_DATA_MODE_NOTIFY = "DELETE#ALL_CLOUDDATA";
+
     // cloud data timestamp is utc ms precision
     // used for 100ns to ms when handle cloud data timestamp
     static constexpr uint32_t TEN_THOUSAND = 10000;
     static constexpr int64_t CLOUD_DEFAULT_TIMEOUT = -1;
+    static constexpr uint32_t ONE_SECOND = 1000 * TEN_THOUSAND; // 1000ms
 
     static constexpr int32_t MAX_UPLOAD_BATCH_COUNT = 2000;
     static constexpr int32_t MIN_UPLOAD_BATCH_COUNT = 1;
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h b/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h
index c31de2e2d714ef6822d00f5a2c2410d4b3980d6b..e57916ddc44d01e78320309dbab32f3fbaa1329f 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/cloud/cloud_db_types.h
@@ -23,7 +23,8 @@ namespace DistributedDB {
 enum class CloudWaterType {
     INSERT,
     UPDATE,
-    DELETE
+    DELETE,
+    BUTT // invalid cloud water type
 };
 
 struct CloudSyncBatch {
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_base64_utils.h b/kv_store/frameworks/libs/distributeddb/common/include/db_base64_utils.h
index 07462fb7c9adadbda1ab2628e3f0bda277e839f1..71121f70509e20248bd451ee9e09fb1253afc4fc 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/db_base64_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/db_base64_utils.h
@@ -24,6 +24,9 @@ class DBBase64Utils {
 public:
     static std::string Encode(const std::vector<uint8_t> &source);
     static std::vector<uint8_t> Decode(const std::string &encoded);
+
+    static std::string Encode(const std::string &source);
+    static std::string DecodeIfNeed(const std::string &source);
 };
 }
 #endif // DB_BASE64_UTILS_H
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_common.h b/kv_store/frameworks/libs/distributeddb/common/include/db_common.h
index b1135a2d52a3c43914fa21040e2a672a62da4ea4..94e5a895db3e8a40dfe5e813e2d2eb31c5cff635 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/db_common.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/db_common.h
@@ -42,6 +42,11 @@ public:
         return {CloudWaterType::DELETE, CloudWaterType::UPDATE, CloudWaterType::INSERT};
     }
 
+    static inline std::string GetMetaTableName()
+    {
+        return DBConstant::RELATIONAL_PREFIX + DBConstant::META_TABLE_POSTFIX;
+    }
+
     static std::string VectorToHexString(const std::vector<uint8_t> &inVec, const std::string &separator = "");
 
     static void PrintHexVector(const std::vector<uint8_t> &data, int line = 0, const std::string &tag = "");
@@ -68,6 +73,8 @@ public:
 
     static std::string StringMasking(const std::string &oriStr, size_t remain = 3); // remain 3 unmask
 
+    static std::string StringMiddleMasking(const std::string &name);
+
     static std::string GetDistributedTableName(const std::string &device, const std::string &tableName);
 
     static std::string GetDistributedTableName(const std::string &device, const std::string &tableName,
@@ -112,17 +119,37 @@ public:
 
     static bool IsRecordError(const VBucket &record);
 
+    static bool IsIntTypeRecordError(const VBucket &record);
+
     static bool IsRecordIgnored(const VBucket &record);
 
     static bool IsRecordVersionConflict(const VBucket &record);
 
+    static bool IsRecordAssetsMissing(const VBucket &record);
+
     static bool IsRecordDelete(const VBucket &record);
 
+    static bool IsCloudRecordNotFound(const VBucket &record);
+
+    static bool IsCloudRecordAlreadyExisted(const VBucket &record);
+
+    static bool IsNeedCompensatedForUpload(const VBucket &uploadExtend, const CloudWaterType &type);
+
+    static bool IsRecordSuccess(const VBucket &record);
+
     static std::string GenerateHashLabel(const DBInfo &dbInfo);
 
     static uint64_t EraseBit(uint64_t origin, uint64_t eraseBit);
 
+    static void LoadGrdLib(void);
+
+    static bool IsGrdLibLoaded(void);
+
     static bool CheckCloudSyncConfigValid(const CloudSyncConfig &config);
+
+    static std::string GetCursorKey(const std::string &tableName);
+
+    static void RemoveDuplicateAssetsData(std::vector<Asset> &assets);
 private:
     static void InsertNodesByScore(const std::map<std::string, std::map<std::string, bool>> &graph,
         const std::vector<std::string> &generateNodes, const std::map<std::string, int> &scoreGraph,
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h b/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h
index d1b4e80e100d7689e704d6b3bc27aa03737b663d..67ef145fa7c02cea9965d4264ef7fbfc2dbb17e9 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/db_constant.h
@@ -25,7 +25,6 @@ public:
     static constexpr size_t MAX_VALUE_SIZE = 4194304;
     static constexpr size_t MAX_BATCH_SIZE = 128;
     static constexpr size_t MAX_DEV_LENGTH = 128;
-    static constexpr size_t MAX_TRANSACTION_ENTRY_SIZE = 128;
     static constexpr size_t MAX_TRANSACTION_KEY_VALUE_LENS = 512 * 1024 * 1024; // 512M
 
     static constexpr size_t MAX_DATA_DIR_LENGTH = 512;
@@ -70,59 +69,57 @@ public:
     static const std::string METADB_DIR;
     static const std::string CACHEDB_DIR;
 
-    static const std::string LOCAL_DATABASE_NAME;
-    static const std::string MULTI_VER_DATA_STORE;
-    static const std::string MULTI_VER_COMMIT_STORE;
-    static const std::string MULTI_VER_VALUE_STORE;
-    static const std::string MULTI_VER_META_STORE;
+    static constexpr const char *LOCAL_DATABASE_NAME = "local";
+    static constexpr const char *MULTI_VER_DATA_STORE = "multi_ver_data";
+    static constexpr const char *MULTI_VER_COMMIT_STORE = "commit_logs";
+    static constexpr const char *MULTI_VER_VALUE_STORE = "value_storage";
+    static constexpr const char *MULTI_VER_META_STORE = "meta_storage";
     static const std::string SINGLE_VER_DATA_STORE;
     static const std::string SINGLE_VER_META_STORE;
     static const std::string SINGLE_VER_CACHE_STORE;
 
-    static const std::string SQLITE_URL_PRE;
-    static const std::string DB_EXTENSION;
-    static const std::string SQLITE_MEMDB_IDENTIFY;
-    static const std::string SCHEMA_KEY;
+    static constexpr const char *SQLITE_URL_PRE = "file:";
+    static constexpr const char *DB_EXTENSION = ".db";
+    static constexpr const char *SQLITE_MEMDB_IDENTIFY = "?mode=memory&cache=shared";
+
+    static constexpr const char *SCHEMA_KEY = "schemaKey";
     static const std::string RELATIONAL_SCHEMA_KEY;
     static const std::string RELATIONAL_TRACKER_SCHEMA_KEY;
 
-    static const std::string RD_KV_COLLECTION_MODE;
-    static const std::string RD_KV_HASH_COLLECTION_MODE;
+    static constexpr const char *RD_KV_COLLECTION_MODE = "{\"mode\" : \"kv\"}";
+    static constexpr const char *RD_KV_HASH_COLLECTION_MODE = "{\"mode\" : \"kv\",\"indextype\" : \"hash\"}";
 
-    static const std::string PATH_POSTFIX_UNPACKED;
-    static const std::string PATH_POSTFIX_IMPORT_BACKUP;
-    static const std::string PATH_POSTFIX_IMPORT_ORIGIN;
-    static const std::string PATH_POSTFIX_IMPORT_DUP;
-    static const std::string PATH_POSTFIX_EXPORT_BACKUP;
-    static const std::string PATH_POSTFIX_DB_INCOMPLETE; // use for make sure create datebase and set label complete
+    static constexpr const char *PATH_POSTFIX_UNPACKED = "_unpacked";
+    static constexpr const char *PATH_POSTFIX_IMPORT_BACKUP = "_import_bak";
+    static constexpr const char *PATH_POSTFIX_IMPORT_ORIGIN = "_import_ori";
+    static constexpr const char *PATH_POSTFIX_IMPORT_DUP = "_import_dup";
+    static constexpr const char *PATH_POSTFIX_EXPORT_BACKUP = "_export_bak";
+    // use for make sure create datebase and set label complete
+    static constexpr const char *PATH_POSTFIX_DB_INCOMPLETE = "_db_incomplete.lock";
 
-    static const std::string REKEY_FILENAME_POSTFIX_PRE;
-    static const std::string REKEY_FILENAME_POSTFIX_OK;
-    static const std::string UPGRADE_POSTFIX;
-    static const std::string SET_SECOPT_POSTFIX; // used for make sure meta split upgrade atomically
+    static constexpr const char *REKEY_FILENAME_POSTFIX_PRE = "_ctrl_pre";
+    static constexpr const char *REKEY_FILENAME_POSTFIX_OK = "_ctrl_ok";
+    static constexpr const char *UPGRADE_POSTFIX = "_upgrade.lock";
+    // used for make sure meta split upgrade atomically
+    static constexpr const char *SET_SECOPT_POSTFIX = "_secopt.lock";
+    static constexpr const char *PATH_BACKUP_POSTFIX = "_bak";
 
-    static const std::string PATH_BACKUP_POSTFIX;
+    static constexpr const char *ID_CONNECTOR = "-";
 
-    static const std::string ID_CONNECTOR;
+    static constexpr const char *DELETE_KVSTORE_REMOVING = "_removing";
+    static constexpr const char *DB_LOCK_POSTFIX = ".lock";
 
-    static const std::string DELETE_KVSTORE_REMOVING;
-    static const std::string DB_LOCK_POSTFIX;
+    static constexpr const char *SUBSCRIBE_QUERY_PREFIX = "subscribe_query_";
 
-    static const std::string SUBSCRIBE_QUERY_PREFIX;
-    static const std::string TRIGGER_REFERENCES_NEW;
-    static const std::string TRIGGER_REFERENCES_OLD;
+    static constexpr const char *TRIGGER_REFERENCES_NEW = "NEW.";
+    static constexpr const char *TRIGGER_REFERENCES_OLD = "OLD.";
 
     static const std::string UPDATE_META_FUNC;
 
-    static const std::string SYSTEM_TABLE_PREFIX;
-
     // Prefix Key in meta db
-    static const std::string DEVICEID_PREFIX_KEY;
-    static const std::string QUERY_SYNC_PREFIX_KEY;
-    static const std::string DELETE_SYNC_PREFIX_KEY;
-
-    static constexpr uint32_t AUTO_SYNC_TIMEOUT = 5000; // 5s
-    static constexpr uint32_t MANUAL_SYNC_TIMEOUT = 5000; // 5s
+    static constexpr const char *DEVICEID_PREFIX_KEY = "deviceId";
+    static constexpr const char *QUERY_SYNC_PREFIX_KEY = "querySync";
+    static constexpr const char *DELETE_SYNC_PREFIX_KEY = "deleteSync";
 
     static const size_t MAX_NORMAL_PACK_ITEM_SIZE = 4000;
     static const size_t MAX_HPMODE_PACK_ITEM_SIZE = 2000; // slide window mode to reduce last ack transfer time
@@ -155,27 +152,23 @@ public:
     static constexpr int MAX_OBSERVER_COUNT = 8;
 
     // For relational
+    static const std::string SYSTEM_TABLE_PREFIX;
     static const std::string RELATIONAL_PREFIX;
     static const std::string TIMESTAMP_ALIAS;
-    static const std::string LOG_POSTFIX;
+    static constexpr const char *LOG_POSTFIX = "_log";
+    static constexpr const char *META_TABLE_POSTFIX = "metadata";
 
-    static const std::string LOG_TABLE_VERSION_1;
-    static const std::string LOG_TABLE_VERSION_2;
     static constexpr const char *LOG_TABLE_VERSION_3 = "3.0";
-    static constexpr const char *LOG_TABLE_VERSION_4 = "4.0";
-    static constexpr const char *LOG_TABLE_VERSION_5 = "5.0";
     static constexpr const char *LOG_TABLE_VERSION_5_1 = "5.01";
-    static constexpr const char *LOG_TABLE_VERSION_5_2 = "5.02"; // fix failure caused by comparing NULL using <>
     static constexpr const char *LOG_TABLE_VERSION_5_3 = "5.03"; // add sharing_resource field
-    static constexpr const char *LOG_TABLE_VERSION_5_4 = "5.04"; // new flag bit 0x20 added, upgrade trigger
     static constexpr const char *LOG_TABLE_VERSION_5_5 = "5.05"; // add status field
-    static constexpr const char *LOG_TABLE_VERSION_5_6 = "5.06"; // upgrade trigger for simple tracker log table
-    static constexpr const char *LOG_TABLE_VERSION_5_7 = "5.07"; // trigger slow sql optimization
-    static const std::string LOG_TABLE_VERSION_CURRENT;
+    static constexpr const char *LOG_TABLE_VERSION_5_8 = "5.08"; // migrate cursor to meta table
+    static constexpr const char *LOG_TABLE_VERSION_5_9 = "5.09"; // insert retains the old version
+    static constexpr const char *LOG_TABLE_VERSION_CURRENT = LOG_TABLE_VERSION_5_9;
 
     static const std::string LOG_TABLE_VERSION_KEY;
 
-    static const std::string REMOTE_DEVICE_SCHEMA_KEY_PREFIX;
+    static constexpr const char *REMOTE_DEVICE_SCHEMA_KEY_PREFIX = "remote_device_schema_";
 
     static constexpr uint32_t MAX_CONDITION_KEY_LEN = 128;
     static constexpr uint32_t MAX_CONDITION_VALUE_LEN = 128;
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h b/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h
index 9de6910e91f3b6b83f4fafb8d09d6e1f2299964d..e8f136de1b27f999e435ea6dbefeab2a8d50b393 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/db_errno.h
@@ -146,6 +146,7 @@ constexpr int E_CLOUD_GID_MISMATCH = (E_BASE + 125); // cloud gid cannot match i
 constexpr int E_WITH_INVENTORY_DATA = (E_BASE + 126); // inventory data exists when setTracker for the first time
 constexpr int E_WAIT_COMPENSATED_SYNC = (E_BASE + 127); // need to do compensated sync
 constexpr int E_CLOUD_SYNC_TASK_MERGED = (E_BASE + 128); // sync task is merged
+constexpr int E_SQLITE_CANT_OPEN = (E_BASE + 129); // the sqlite cannot open
 // Num 150+ is reserved for schema related errno, since it may be added regularly
 constexpr int E_JSON_PARSE_FAIL = (E_BASE + 150); // Parse json fail in grammatical level
 constexpr int E_JSON_INSERT_PATH_EXIST = (E_BASE + 151); // Path already exist before insert
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/db_types.h b/kv_store/frameworks/libs/distributeddb/common/include/db_types.h
index b6d5ce1fa9e5ae4d68934f28f39a6b35cf10a64f..28cdad4dd1215f801df68adb8b48b499ddcfd1a0 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/db_types.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/db_types.h
@@ -53,6 +53,7 @@ struct DataItem {
     Timestamp createTime = 0;
     std::string version; // use for cloud
     std::string gid; // use for cloud
+    uint32_t cloud_flag = 0; // use for cloud
     static constexpr uint64_t DELETE_FLAG = 0x01;
     static constexpr uint64_t LOCAL_FLAG = 0x02;
     static constexpr uint64_t REMOVE_DEVICE_DATA_FLAG = 0x04; // only use for cachedb
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/log_print.h b/kv_store/frameworks/libs/distributeddb/common/include/log_print.h
index 0c164d3efb4d8e1d4c91ac3fc2317183d906d5e0..a7592f66251bebadb0a4b341e998a9ca2a42c742 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/log_print.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/log_print.h
@@ -22,7 +22,7 @@
 #include <string>
 
 namespace DistributedDB {
-const std::string LOG_TAG_KV = "DistributedDB";
+constexpr const char *LOG_TAG_KV = "DistributedDB";
 
 class Logger {
 public:
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/param_check_utils.h b/kv_store/frameworks/libs/distributeddb/common/include/param_check_utils.h
index 39a355f40c2c2bfaf827ea9bbe7ea64abe4cb80c..e217f55e1773d610850072acd464f6fc5f208ac2 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/param_check_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/param_check_utils.h
@@ -29,12 +29,15 @@ public:
     static bool CheckDataDir(const std::string &dir, std::string &canonicalDir);
 
     // Check if the storeID is a safe arg.
-    static bool IsStoreIdSafe(const std::string &storeId);
+    static bool IsStoreIdSafe(const std::string &storeId, bool allowStoreIdWithDot = false);
 
     // check appId, userId, storeId, subUser.
     static bool CheckStoreParameter(const std::string &storeId, const std::string &appId, const std::string &userId,
         bool isIgnoreUserIdCheck = false, const std::string &subUser = "");
 
+    static bool CheckStoreParameter(const StoreInfo &info, bool isIgnoreUserIdCheck = false,
+        const std::string &subUser = "", bool allowStoreIdWithDot = false);
+
     // check encrypted args for KvStore.
     static bool CheckEncryptedParameter(CipherType cipher, const CipherPassword &passwd);
 
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/query_utils.h b/kv_store/frameworks/libs/distributeddb/common/include/query_utils.h
index 3e6d53be8d81659b2435be20007b727b3285bc5a..4161a36e86b41495899ef26b19adafb01b6c812b 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/query_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/query_utils.h
@@ -22,7 +22,10 @@
 namespace DistributedDB {
 class QueryUtils {
 public:
-    static void FillQueryInKeys(const std::string &col, const std::vector<Type> &data, size_t valueType, Query &query);
+    static void FillQueryIn(const std::string &col, const std::vector<Type> &data, size_t valueType, Query &query);
+
+    static void FillQueryInKeys(const std::map<std::string, std::vector<Type>> &syncPk,
+        std::map<std::string, size_t> dataIndex, Query &query);
 };
 } // DistributedDB
 #endif // QUERY_UTILS_H
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/relational/tracker_table.h b/kv_store/frameworks/libs/distributeddb/common/include/relational/tracker_table.h
index 3bba847e16eeb9450c9516cb3d4ff719772cb58c..fe7251c2e417a0e9014a62fdff0c0b9f4674086c 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/relational/tracker_table.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/relational/tracker_table.h
@@ -19,9 +19,14 @@
 #include "db_types.h"
 #include "db_errno.h"
 #include "json_object.h"
+#include "sqlite_import.h"
 
 #ifdef RELATIONAL_STORE
 namespace DistributedDB {
+using AfterBuildAction = std::function<int()>;
+namespace TriggerMode {
+enum class TriggerModeEnum;
+}
 class TrackerTable {
 public:
     TrackerTable() = default;
@@ -38,14 +43,17 @@ public:
     std::string ToString() const;
     const std::vector<std::string> GetDropTempTriggerSql() const;
     const std::string GetTempInsertTriggerSql() const;
+    const std::string GetDropTempTriggerSql(TriggerMode::TriggerModeEnum mode) const;
+    const std::string GetCreateTempTriggerSql(TriggerMode::TriggerModeEnum mode) const;
+    const std::string GetTempTriggerName(TriggerMode::TriggerModeEnum mode) const;
     const std::string GetTempUpdateTriggerSql() const;
     const std::string GetTempDeleteTriggerSql() const;
-    const std::string GetUpgradedExtendValSql() const;
     void SetTableName(const std::string &tableName);
     void SetExtendName(const std::string &colName);
     void SetTrackerNames(const std::set<std::string> &trackerNames);
     bool IsEmpty() const;
     bool IsChanging(const TrackerSchema &schema);
+    int ReBuildTempTrigger(sqlite3 *db, TriggerMode::TriggerModeEnum mode, const AfterBuildAction &action);
 
 private:
     std::string tableName_;
diff --git a/kv_store/frameworks/libs/distributeddb/common/include/version.h b/kv_store/frameworks/libs/distributeddb/common/include/version.h
index 057b42ac99827876c45615f0872e971eb1b1a43d..89632fe05eb577c3cf5bf027c93b30e3240e41c0 100644
--- a/kv_store/frameworks/libs/distributeddb/common/include/version.h
+++ b/kv_store/frameworks/libs/distributeddb/common/include/version.h
@@ -30,7 +30,7 @@ namespace DistributedDB {
 // if now version of B is 105, and C is 101, thus version of A is 105; if now release version is 106 and we upgrade
 // submodule C, if we simply change version of C to 102 then version of A is still 105, but if we change version of C
 // to 106 then version of A is now 106, so we can know that something had changed for module A.
-const std::string SOFTWARE_VERSION_STRING = "1.1.5"; // DistributedDB current version string.
+constexpr const char *SOFTWARE_VERSION_STRING = "1.1.5"; // DistributedDB current version string.
 constexpr uint32_t SOFTWARE_VERSION_BASE = 100; // Software version base value, do not change it
 constexpr uint32_t SOFTWARE_VERSION_RELEASE_1_0 = SOFTWARE_VERSION_BASE + 1; // 1 for first released version
 constexpr uint32_t SOFTWARE_VERSION_RELEASE_2_0 = SOFTWARE_VERSION_BASE + 2; // 2 for second released version
@@ -46,8 +46,10 @@ constexpr uint32_t SOFTWARE_VERSION_RELEASE_8_0 = SOFTWARE_VERSION_BASE + 8; //
 // add schema version in ability request
 // add schema version, system time offset, sender local time offset in data request
 constexpr uint32_t SOFTWARE_VERSION_RELEASE_9_0 = SOFTWARE_VERSION_BASE + 9; // 9 for ninth released version
+// 110 version add totalDataCount field in DataRequestPkt
+constexpr uint32_t SOFTWARE_VERSION_RELEASE_10_0 = SOFTWARE_VERSION_BASE + 10;
 constexpr uint32_t SOFTWARE_VERSION_EARLIEST = SOFTWARE_VERSION_RELEASE_1_0;
-constexpr uint32_t SOFTWARE_VERSION_CURRENT = SOFTWARE_VERSION_RELEASE_9_0;
+constexpr uint32_t SOFTWARE_VERSION_CURRENT = SOFTWARE_VERSION_RELEASE_10_0;
 constexpr int VERSION_INVALID = INT32_MAX;
 
 // Storage Related Version
@@ -74,6 +76,10 @@ constexpr int ABILITY_SYNC_VERSION_V1 = SOFTWARE_VERSION_RELEASE_2_0; // Ability
 constexpr uint32_t SINGLE_VER_SYNC_PROCTOL_V1 = SOFTWARE_VERSION_RELEASE_1_0; // The 1st version num
 constexpr uint32_t SINGLE_VER_SYNC_PROCTOL_V2 = SOFTWARE_VERSION_RELEASE_2_0; // The 2nd version num
 constexpr uint32_t SINGLE_VER_SYNC_PROCTOL_V3 = SOFTWARE_VERSION_RELEASE_3_0; // The third version num
+
+// Local Meta Data Version
+constexpr uint32_t LOCAL_META_DATA_VERSION_V1 = SOFTWARE_VERSION_RELEASE_8_0;
+constexpr uint32_t LOCAL_META_DATA_VERSION_V2 = SOFTWARE_VERSION_RELEASE_9_0;
 } // namespace DistributedDB
 
 #endif // VERSION_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp b/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp
index 4ef74be558599da6289cba167e5a4fd0ac666a91..32e6cdedc42c359935f282abc81f50ea48e11440 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/auto_launch.cpp
@@ -59,14 +59,15 @@ void AutoLaunch::SetCommunicatorAggregator(ICommunicatorAggregator *aggregator)
         LOGI("[AutoLaunch] SetCommunicatorAggregator aggregator is nullptr");
         return;
     }
-    errCode = aggregator->RegOnConnectCallback(std::bind(&AutoLaunch::OnlineCallBack, this,
-        std::placeholders::_1, std::placeholders::_2), nullptr);
+    errCode = aggregator->RegOnConnectCallback(
+        [this](const std::string &device, bool isConnect) { OnlineCallBack(device, isConnect); }, nullptr);
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] RegOnConnectCallback errCode:%d", errCode);
     }
     errCode = aggregator->RegCommunicatorLackCallback(
-        std::bind(&AutoLaunch::ReceiveUnknownIdentifierCallBack, this, std::placeholders::_1, std::placeholders::_2),
-        nullptr);
+        [this](const LabelType &label, const std::string &originalUserId) {
+            return ReceiveUnknownIdentifierCallBack(label, originalUserId);
+        }, nullptr);
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] RegCommunicatorLackCallback errCode:%d", errCode);
     }
@@ -106,7 +107,7 @@ AutoLaunch::~AutoLaunch()
                 (!autoLaunchItemMap_[identifierInfo.first][identifierInfo.second].isDisable);
         });
         if (autoLaunchItemMap_.count(identifierInfo.first) != 0 &&
-            autoLaunchItemMap_[identifierInfo.first].count(identifierInfo.second)) {
+            autoLaunchItemMap_[identifierInfo.first].count(identifierInfo.second)) { // LCOV_EXCL_BR_LINE
             TryCloseConnection(autoLaunchItemMap_[identifierInfo.first][identifierInfo.second]);
         }
     }
@@ -502,8 +503,8 @@ void AutoLaunch::ConnectionLifeCycleCallbackTask(const std::string &identifier,
 void AutoLaunch::ConnectionLifeCycleCallback(const std::string &identifier, const std::string &userId)
 {
     LOGI("[AutoLaunch] ConnectionLifeCycleCallback identifier=%.6s", STR_TO_HEX(identifier));
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(&AutoLaunch::ConnectionLifeCycleCallbackTask,
-        this, identifier, userId));
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask(
+        [this, identifier, userId] { ConnectionLifeCycleCallbackTask(identifier, userId); });
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] ConnectionLifeCycleCallback ScheduleTask failed");
     }
@@ -539,7 +540,7 @@ void AutoLaunch::OnlineCallBack(const std::string &device, bool isConnect)
         onlineDevices_.insert(device);
     }
 
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(&AutoLaunch::OnlineCallBackTask, this));
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this] { OnlineCallBackTask(); });
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] OnlineCallBack ScheduleTask failed");
     }
@@ -592,13 +593,13 @@ void AutoLaunch::GetConnInDoOpenMapInner(std::pair<const std::string, std::map<s
         int errCode = RuntimeContext::GetInstance()->ScheduleTask([&sema, &iter, &items, this] {
             int ret = OpenOneConnection(iter.second);
             LOGI("[AutoLaunch] GetConnInDoOpenMap GetOneConnection errCode:%d", ret);
-            if (iter.second.conn == nullptr) {
+            if (ret != E_OK) { // LCOV_EXCL_BR_LINE
                 sema.SendSemaphore();
                 LOGI("[AutoLaunch] GetConnInDoOpenMap in open thread finish SendSemaphore");
                 return;
             }
             ret = RegisterObserverAndLifeCycleCallback(iter.second, items.first, false);
-            if (ret != E_OK) {
+            if (ret != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("[AutoLaunch] GetConnInDoOpenMap failed, we do CloseConnection");
                 TryCloseConnection(iter.second); // if here failed, do nothing
                 iter.second.conn = nullptr;
@@ -606,7 +607,7 @@ void AutoLaunch::GetConnInDoOpenMapInner(std::pair<const std::string, std::map<s
             sema.SendSemaphore();
             LOGI("[AutoLaunch] GetConnInDoOpenMap in open thread finish SendSemaphore");
         });
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[AutoLaunch] GetConnInDoOpenMap ScheduleTask failed, SendSemaphore");
             sema.SendSemaphore();
         }
@@ -720,8 +721,8 @@ int AutoLaunch::ReceiveUnknownIdentifierCallBack(const LabelType &label, const s
         LOGI("[AutoLaunch] ReceiveUnknownIdentifierCallBack set state IN_COMMUNICATOR_CALL_BACK");
     }
 
-    errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(
-        &AutoLaunch::ReceiveUnknownIdentifierCallBackTask, this, identifier, userId));
+    errCode = RuntimeContext::GetInstance()->ScheduleTask(
+        [this, identifier, userId] { ReceiveUnknownIdentifierCallBackTask(identifier, userId); });
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] ReceiveUnknownIdentifierCallBack ScheduleTask failed");
         std::lock_guard<std::mutex> autoLock(dataLock_);
@@ -777,8 +778,10 @@ int AutoLaunch::AutoLaunchExt(const std::string &identifier, const std::string &
     autoLaunchItem.isAutoSync = param.option.isAutoSync;
     autoLaunchItem.type = openType;
     autoLaunchItem.storeObserver = param.option.storeObserver;
-    errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(&AutoLaunch::AutoLaunchExtTask, this,
-        identifier, param.userId, autoLaunchItem));
+    errCode = RuntimeContext::GetInstance()->ScheduleTask([this, identifier, userId = param.userId, autoLaunchItem] {
+        AutoLaunchItem item = autoLaunchItem;
+        AutoLaunchExtTask(identifier, userId, item);
+    });
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] AutoLaunchExt ScheduleTask errCode:%d", errCode);
     }
@@ -881,8 +884,8 @@ void AutoLaunch::ExtObserverFunc(const KvDBCommitNotifyData &notifyData, const s
 void AutoLaunch::ExtConnectionLifeCycleCallback(const std::string &identifier, const std::string &userId)
 {
     LOGI("[AutoLaunch] ExtConnectionLifeCycleCallback identifier=%.6s", STR_TO_HEX(identifier));
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(
-        &AutoLaunch::ExtConnectionLifeCycleCallbackTask, this, identifier, userId));
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask(
+        [this, identifier, userId] { ExtConnectionLifeCycleCallbackTask(identifier, userId); });
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] ExtConnectionLifeCycleCallback ScheduleTask failed");
     }
@@ -1012,6 +1015,7 @@ int AutoLaunch::GetAutoLaunchKVProperties(const AutoLaunchParam &param,
     propertiesPtr->SetBoolProp(KvDBProperties::MEMORY_MODE, false);
     propertiesPtr->SetBoolProp(KvDBProperties::ENCRYPTED_MODE, param.option.isEncryptedDb);
     propertiesPtr->SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
+    propertiesPtr->SetIntProp(KvDBProperties::CONFLICT_RESOLVE_POLICY, param.option.conflictResolvePolicy);
     propertiesPtr->SetSchema(schemaObject);
     if (RuntimeContext::GetInstance()->IsProcessSystemApiAdapterValid()) {
         propertiesPtr->SetIntProp(KvDBProperties::SECURITY_LABEL, param.option.secOption.securityLabel);
@@ -1033,7 +1037,7 @@ int AutoLaunch::GetAutoLaunchKVProperties(const AutoLaunchParam &param,
 int AutoLaunch::GetAutoLaunchRelationProperties(const AutoLaunchParam &param,
     const std::shared_ptr<RelationalDBProperties> &propertiesPtr)
 {
-    if (!ParamCheckUtils::CheckStoreParameter(param.storeId, param.appId, param.userId)) {
+    if (!ParamCheckUtils::CheckStoreParameter({param.storeId, param.appId, param.userId}, false, "", true)) {
         LOGE("[AutoLaunch] CheckStoreParameter is invalid.");
         return -E_INVALID_ARGS;
     }
@@ -1100,7 +1104,7 @@ int AutoLaunch::OpenRelationalConnection(AutoLaunchItem &autoLaunchItem)
     std::shared_ptr<RelationalDBProperties> properties =
         std::static_pointer_cast<RelationalDBProperties>(autoLaunchItem.propertiesPtr);
     int errCode = E_OK;
-    auto conn = RelationalStoreInstance::GetDatabaseConnection(*properties, errCode);
+    auto conn = RelationalStoreInstance::GetDatabaseConnection(*properties, errCode, false);
     if (errCode == -E_ALREADY_OPENED) {
         LOGI("[AutoLaunch] GetOneConnection user already openstore by self");
     } else if (conn == nullptr) {
@@ -1116,11 +1120,13 @@ int AutoLaunch::RegisterLifeCycleCallback(AutoLaunchItem &autoLaunchItem, const
     int errCode = E_OK;
     DatabaseLifeCycleNotifier notifier;
     if (isExt) {
-        notifier = std::bind(
-            &AutoLaunch::ExtConnectionLifeCycleCallback, this, std::placeholders::_1, std::placeholders::_2);
+        notifier = [this](const std::string &identifierExt, const std::string &userId) {
+            ExtConnectionLifeCycleCallback(identifierExt, userId);
+        };
     } else {
-        notifier = std::bind(&AutoLaunch::ConnectionLifeCycleCallback,
-            this, std::placeholders::_1, std::placeholders::_2);
+        notifier = [this](const std::string &identifierExt, const std::string &userId) {
+            ConnectionLifeCycleCallback(identifierExt, userId);
+        };
     }
     switch (autoLaunchItem.type) {
         case DBTypeInner::DB_KV:
@@ -1261,8 +1267,13 @@ int AutoLaunch::RegisterKvObserver(AutoLaunchItem &autoLaunchItem, const std::st
     KvDBObserverHandle *observerHandle = nullptr;
     IKvDBConnection *kvConn = static_cast<IKvDBConnection *>(autoLaunchItem.conn);
     observerHandle = kvConn->RegisterObserver(OBSERVER_CHANGES_FOREIGN, key,
-        std::bind((isExt ? &AutoLaunch::ExtObserverFunc : &AutoLaunch::ObserverFunc), this, std::placeholders::_1,
-        identifier, userId), errCode);
+        [this, isExt, identifier, userId](const KvDBCommitNotifyData &notifyData) {
+            if (isExt) {
+                ExtObserverFunc(notifyData, identifier, userId);
+            } else {
+                ObserverFunc(notifyData, identifier, userId);
+            }
+        }, errCode);
     if (errCode != E_OK) {
         LOGE("[AutoLaunch] RegisterObserver failed:%d!", errCode);
         return errCode;
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_base64_utils.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_base64_utils.cpp
index 5cd543b1954042afe531b6406b9e168b740bfe40..6afb94a7481f1648250a5e161a90136d391ad12e 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/db_base64_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/db_base64_utils.cpp
@@ -27,7 +27,7 @@ static constexpr const std::string_view BASE64_CHARS = /* NOLINT */
 static constexpr const uint32_t CHAR_ARRAY_LENGTH_THREE = 3;
 static constexpr const uint32_t CHAR_ARRAY_LENGTH_FOUR = 4;
 
-enum BASE64_ENCODE_CONSTANT : uint8_t {
+enum class BASE64_ENCODE_CONSTANT : uint8_t {
     BASE64_ENCODE_MASK1 = 0xfc,
     BASE64_ENCODE_MASK2 = 0x03,
     BASE64_ENCODE_MASK3 = 0x0f,
@@ -42,7 +42,7 @@ enum BASE64_ENCODE_CONSTANT : uint8_t {
     BASE64_ENCODE_INDEX2 = 2,
 };
 
-enum BASE64_DECODE_CONSTANT : uint8_t {
+enum class BASE64_DECODE_CONSTANT : uint8_t {
     BASE64_DECODE_MASK1 = 0x30,
     BASE64_DECODE_MASK2 = 0xf,
     BASE64_DECODE_MASK3 = 0x3c,
@@ -65,12 +65,23 @@ static void MakeCharFour(const std::array<uint8_t, CHAR_ARRAY_LENGTH_THREE> &cha
     std::array<uint8_t, CHAR_ARRAY_LENGTH_FOUR> &charArrayFour)
 {
     const uint8_t table[CHAR_ARRAY_LENGTH_FOUR] = {
-        static_cast<uint8_t>((charArrayThree[BASE64_ENCODE_INDEX0] & BASE64_ENCODE_MASK1) >> BASE64_ENCODE_OFFSET2),
-        static_cast<uint8_t>(((charArrayThree[BASE64_ENCODE_INDEX0] & BASE64_ENCODE_MASK2) << BASE64_ENCODE_OFFSET4) +
-                             ((charArrayThree[BASE64_ENCODE_INDEX1] & BASE64_ENCODE_MASK5) >> BASE64_ENCODE_OFFSET4)),
-        static_cast<uint8_t>(((charArrayThree[BASE64_ENCODE_INDEX1] & BASE64_ENCODE_MASK3) << BASE64_ENCODE_OFFSET2) +
-                             ((charArrayThree[BASE64_ENCODE_INDEX2] & BASE64_ENCODE_MASK6) >> BASE64_ENCODE_OFFSET6)),
-        static_cast<uint8_t>(charArrayThree[BASE64_ENCODE_INDEX2] & BASE64_ENCODE_MASK4),
+        static_cast<uint8_t>((charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX0)] &
+                                static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK1)) >>
+                            static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_OFFSET2)),
+        static_cast<uint8_t>(((charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX0)] &
+                                  static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK2))
+                                << static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_OFFSET4)) +
+                                ((charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX1)] &
+                                    static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK5)) >>
+                                  static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_OFFSET4))),
+        static_cast<uint8_t>(((charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX1)] &
+                                  static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK3))
+                                << static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_OFFSET2)) +
+                             ((charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX2)] &
+                                  static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK6)) >>
+                                static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_OFFSET6))),
+        static_cast<uint8_t>(charArrayThree[static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_INDEX2)] &
+                            static_cast<uint8_t>(BASE64_ENCODE_CONSTANT::BASE64_ENCODE_MASK4)),
     };
     for (size_t index = 0; index < CHAR_ARRAY_LENGTH_FOUR; ++index) {
         charArrayFour[index] = table[index];
@@ -81,12 +92,21 @@ static void MakeCharTree(const std::array<uint8_t, CHAR_ARRAY_LENGTH_FOUR> &char
     std::array<uint8_t, CHAR_ARRAY_LENGTH_THREE> &charArrayThree)
 {
     const uint8_t table[CHAR_ARRAY_LENGTH_THREE] = {
-        static_cast<uint8_t>((charArrayFour[BASE64_DECODE_INDEX0] << BASE64_DECODE_OFFSET2) +
-                             ((charArrayFour[BASE64_DECODE_INDEX1] & BASE64_DECODE_MASK1) >> BASE64_DECODE_OFFSET4)),
-        static_cast<uint8_t>(((charArrayFour[BASE64_DECODE_INDEX1] & BASE64_DECODE_MASK2) << BASE64_DECODE_OFFSET4) +
-                             ((charArrayFour[BASE64_DECODE_INDEX2] & BASE64_DECODE_MASK3) >> BASE64_DECODE_OFFSET2)),
-        static_cast<uint8_t>(((charArrayFour[BASE64_DECODE_INDEX2] & BASE64_DECODE_MASK4) << BASE64_DECODE_OFFSET6) +
-                             charArrayFour[BASE64_DECODE_INDEX3]),
+        static_cast<uint8_t>((charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX0)]
+                                << static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_OFFSET2)) +
+                             ((charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX1)] &
+                                  static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_MASK1)) >>
+                                static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_OFFSET4))),
+        static_cast<uint8_t>(((charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX1)] &
+                                  static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_MASK2))
+                                  << static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_OFFSET4)) +
+                             ((charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX2)] &
+                                  static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_MASK3)) >>
+                                static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_OFFSET2))),
+        static_cast<uint8_t>(((charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX2)] &
+                                  static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_MASK4))
+                                << static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_OFFSET6)) +
+                             charArrayFour[static_cast<uint8_t>(BASE64_DECODE_CONSTANT::BASE64_DECODE_INDEX3)]),
     };
     for (size_t index = 0; index < CHAR_ARRAY_LENGTH_THREE; ++index) {
         charArrayThree[index] = table[index];
@@ -178,4 +198,18 @@ std::vector<uint8_t> DBBase64Utils::Decode(const std::string &encoded)
     }
     return ret;
 }
+
+std::string DBBase64Utils::Encode(const std::string &source)
+{
+    return Encode(std::vector<uint8_t>(source.begin(), source.end()));
+}
+
+std::string DBBase64Utils::DecodeIfNeed(const std::string &source)
+{
+    auto decodeRes = Decode(source);
+    if (decodeRes.empty()) {
+        return source;
+    }
+    return std::string(decodeRes.begin(), decodeRes.end());
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp
index 47f3cf661e46b7a0009ec6647b8ab68ba04a94d6..e543a1b5371301417b8536e197b64624e15aa3ad 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/db_common.cpp
@@ -15,8 +15,13 @@
 
 #include "db_common.h"
 
+#include <atomic>
 #include <climits>
 #include <cstdio>
+#ifndef _WIN32
+#include <dlfcn.h>
+#endif
+#include <mutex>
 #include <queue>
 
 #include "cloud/cloud_db_constant.h"
@@ -30,6 +35,12 @@
 
 namespace DistributedDB {
 namespace {
+    constexpr const int32_t HEAD_SIZE = 3;
+    constexpr const int32_t END_SIZE = 3;
+    constexpr const int32_t MIN_SIZE = HEAD_SIZE + END_SIZE + 3;
+    constexpr const char *REPLACE_CHAIN = "***";
+    constexpr const char *DEFAULT_ANONYMOUS = "******";
+
     void RemoveFiles(const std::list<OS::FileAttr> &fileList, OS::FileType type)
     {
         for (const auto &item : fileList) {
@@ -59,6 +70,8 @@ namespace {
     const std::string CAP_HEX_CHAR_MAP = "0123456789ABCDEF";
 }
 
+static std::atomic_bool g_isGrdLoaded = false;
+
 int DBCommon::CreateDirectory(const std::string &directory)
 {
     bool isExisted = OS::CheckPathExistence(directory);
@@ -330,6 +343,19 @@ std::string DBCommon::StringMasking(const std::string &oriStr, size_t remain)
     return oriStr;
 }
 
+std::string DBCommon::StringMiddleMasking(const std::string &name)
+{
+    if (name.length() <= HEAD_SIZE) {
+        return DEFAULT_ANONYMOUS;
+    }
+
+    if (name.length() < MIN_SIZE) {
+        return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN);
+    }
+
+    return (name.substr(0, HEAD_SIZE) + REPLACE_CHAIN + name.substr(name.length() - END_SIZE, END_SIZE));
+}
+
 std::string DBCommon::GetDistributedTableName(const std::string &device, const std::string &tableName)
 {
     if (!RuntimeContext::GetInstance()->ExistTranslateDevIdCallback()) {
@@ -606,10 +632,25 @@ bool DBCommon::HasPrimaryKey(const std::vector<Field> &fields)
 
 bool DBCommon::IsRecordError(const VBucket &record)
 {
+    // check record err should deal or skip, false is no error or error is considered, true is error not considered
     if (record.find(CloudDbConstant::ERROR_FIELD) == record.end()) {
         return false;
     }
-    return record.at(CloudDbConstant::ERROR_FIELD).index() == TYPE_INDEX<std::string>;
+    if (record.at(CloudDbConstant::ERROR_FIELD).index() != TYPE_INDEX<int64_t>) {
+        return false;
+    }
+    auto status = std::get<int64_t>(record.at(CloudDbConstant::ERROR_FIELD));
+    return status != static_cast<int64_t>(DBStatus::CLOUD_RECORD_EXIST_CONFLICT) &&
+           status != static_cast<int64_t>(DBStatus::CLOUD_RECORD_ALREADY_EXISTED) &&
+           status != static_cast<int64_t>(DBStatus::CLOUD_RECORD_NOT_FOUND);
+}
+
+bool DBCommon::IsIntTypeRecordError(const VBucket &record)
+{
+    if (record.find(CloudDbConstant::ERROR_FIELD) == record.end()) {
+        return false;
+    }
+    return record.at(CloudDbConstant::ERROR_FIELD).index() == TYPE_INDEX<int64_t>;
 }
 
 bool DBCommon::IsRecordIgnored(const VBucket &record)
@@ -636,6 +677,18 @@ bool DBCommon::IsRecordVersionConflict(const VBucket &record)
     return status == static_cast<int64_t>(DBStatus::CLOUD_VERSION_CONFLICT);
 }
 
+bool DBCommon::IsRecordAssetsMissing(const VBucket &record)
+{
+    if (record.find(CloudDbConstant::ERROR_FIELD) == record.end()) {
+        return false;
+    }
+    if (record.at(CloudDbConstant::ERROR_FIELD).index() != TYPE_INDEX<int64_t>) {
+        return false;
+    }
+    auto status = std::get<int64_t>(record.at(CloudDbConstant::ERROR_FIELD));
+    return status == static_cast<int64_t>(DBStatus::LOCAL_ASSET_NOT_FOUND);
+}
+
 bool DBCommon::IsRecordDelete(const VBucket &record)
 {
     if (record.find(CloudDbConstant::DELETE_FIELD) == record.end()) {
@@ -647,6 +700,41 @@ bool DBCommon::IsRecordDelete(const VBucket &record)
     return std::get<bool>(record.at(CloudDbConstant::DELETE_FIELD));
 }
 
+bool DBCommon::IsCloudRecordNotFound(const VBucket &record)
+{
+    if (record.find(CloudDbConstant::ERROR_FIELD) == record.end()) {
+        return false;
+    }
+    if (record.at(CloudDbConstant::ERROR_FIELD).index() != TYPE_INDEX<int64_t>) {
+        return false;
+    }
+    auto status = std::get<int64_t>(record.at(CloudDbConstant::ERROR_FIELD));
+    return status == static_cast<int64_t>(DBStatus::CLOUD_RECORD_NOT_FOUND);
+}
+
+bool DBCommon::IsCloudRecordAlreadyExisted(const VBucket &record)
+{
+    if (record.find(CloudDbConstant::ERROR_FIELD) == record.end()) {
+        return false;
+    }
+    if (record.at(CloudDbConstant::ERROR_FIELD).index() != TYPE_INDEX<int64_t>) {
+        return false;
+    }
+    auto status = std::get<int64_t>(record.at(CloudDbConstant::ERROR_FIELD));
+    return status == static_cast<int64_t>(DBStatus::CLOUD_RECORD_ALREADY_EXISTED);
+}
+
+bool DBCommon::IsNeedCompensatedForUpload(const VBucket &uploadExtend, const CloudWaterType &type)
+{
+    return (DBCommon::IsCloudRecordAlreadyExisted(uploadExtend) && type == CloudWaterType::INSERT) ||
+        (DBCommon::IsCloudRecordNotFound(uploadExtend) && type == CloudWaterType::UPDATE);
+}
+
+bool DBCommon::IsRecordSuccess(const VBucket &record)
+{
+    return record.find(CloudDbConstant::ERROR_FIELD) == record.end();
+}
+
 std::string DBCommon::GenerateHashLabel(const DBInfo &dbInfo)
 {
     if (dbInfo.syncDualTupleMode) {
@@ -660,6 +748,27 @@ uint64_t DBCommon::EraseBit(uint64_t origin, uint64_t eraseBit)
     return origin & (~eraseBit);
 }
 
+void DBCommon::LoadGrdLib(void)
+{
+    static std::once_flag loadOnceFlag;
+    std::call_once(loadOnceFlag, []() {
+        if (!g_isGrdLoaded) {
+#ifndef _WIN32
+            if (dlopen("libarkdata_db_core.z.so", RTLD_LAZY) != NULL) {
+                g_isGrdLoaded = true;
+            } else {
+                LOGW("[DBCommon] unable to load grd lib, errno: %d, %s", errno, dlerror());
+            }
+#endif
+        }
+    });
+}
+
+bool DBCommon::IsGrdLibLoaded(void)
+{
+    return g_isGrdLoaded;
+}
+
 bool DBCommon::CheckCloudSyncConfigValid(const CloudSyncConfig &config)
 {
     if (config.maxUploadCount < CloudDbConstant::MIN_UPLOAD_BATCH_COUNT ||
@@ -678,4 +787,57 @@ bool DBCommon::CheckCloudSyncConfigValid(const CloudSyncConfig &config)
     }
     return true;
 }
+
+std::string DBCommon::GetCursorKey(const std::string &tableName)
+{
+    return DBConstant::RELATIONAL_PREFIX + "cursor_" + ToLowerCase(tableName);
+}
+
+void DBCommon::RemoveDuplicateAssetsData(std::vector<Asset> &assets)
+{
+    std::unordered_map<std::string, size_t> indexMap;
+    size_t vectorSize = assets.size();
+    std::vector<size_t> arr(vectorSize, 0);
+    for (std::vector<DistributedDB::Asset>::size_type i = 0; i < assets.size(); ++i) {
+        DistributedDB::Asset asset = assets.at(i);
+        auto it = indexMap.find(asset.name);
+        if (it == indexMap.end()) {
+            indexMap[asset.name] = i;
+            continue;
+        }
+        size_t prevIndex = it->second;
+        Asset &prevAsset = assets.at(prevIndex);
+        if (prevAsset.assetId.empty()) {
+            arr[prevIndex] = 1;
+            indexMap[asset.name] = i;
+            continue;
+        }
+        if (asset.assetId.empty()) {
+            arr[i] = 1;
+            indexMap[asset.name] = prevIndex;
+            continue;
+        }
+        if (std::all_of(asset.modifyTime.begin(), asset.modifyTime.end(), ::isdigit) &&
+            std::all_of(prevAsset.modifyTime.begin(), prevAsset.modifyTime.end(), ::isdigit) &&
+            !asset.modifyTime.empty() && !prevAsset.modifyTime.empty()) {
+            auto modifyTime = std::stoll(asset.modifyTime);
+            auto prevModifyTime = std::stoll(prevAsset.modifyTime);
+            arr[modifyTime > prevModifyTime ? prevIndex : i] = 1;
+            indexMap[asset.name] = modifyTime > prevModifyTime ? i : prevIndex;
+            continue;
+        }
+        arr[i] = 1;
+        indexMap[asset.name] = prevIndex;
+    }
+    indexMap.clear();
+    size_t arrIndex = 0;
+    for (auto it = assets.begin(); it != assets.end();) {
+        if (arr[arrIndex] == 1) {
+            it = assets.erase(it);
+        } else {
+            it++;
+        }
+        arrIndex++;
+    }
+}
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp
index fbf407ce877a34874379a7cd817144565251c272..d9af352faeb956cd80c61c5b1ad10211d4f5a402 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/db_constant.cpp
@@ -19,70 +19,17 @@ namespace DistributedDB {
 const std::string DBConstant::MULTI_SUB_DIR = "multi_ver";
 const std::string DBConstant::SINGLE_SUB_DIR = "single_ver";
 const std::string DBConstant::LOCAL_SUB_DIR = "local";
-
 const std::string DBConstant::MAINDB_DIR = "main";
 const std::string DBConstant::METADB_DIR = "meta";
 const std::string DBConstant::CACHEDB_DIR = "cache";
-
-const std::string DBConstant::LOCAL_DATABASE_NAME = "local";
-const std::string DBConstant::MULTI_VER_DATA_STORE = "multi_ver_data";
-const std::string DBConstant::MULTI_VER_COMMIT_STORE = "commit_logs";
-const std::string DBConstant::MULTI_VER_VALUE_STORE = "value_storage";
-const std::string DBConstant::MULTI_VER_META_STORE = "meta_storage";
-const std::string DBConstant::SINGLE_VER_DATA_STORE = "gen_natural_store";
-const std::string DBConstant::SINGLE_VER_META_STORE = "meta";
-const std::string DBConstant::SINGLE_VER_CACHE_STORE = "cache";
-
-const std::string DBConstant::SQLITE_URL_PRE = "file:";
-const std::string DBConstant::DB_EXTENSION = ".db";
-const std::string DBConstant::SQLITE_MEMDB_IDENTIFY = "?mode=memory&cache=shared";
-
-const std::string DBConstant::SCHEMA_KEY = "schemaKey";
-const std::string DBConstant::RELATIONAL_SCHEMA_KEY = "relational_schema";
-const std::string DBConstant::RELATIONAL_TRACKER_SCHEMA_KEY = "relational_tracker_schema";
-
-const std::string DBConstant::RD_KV_COLLECTION_MODE = "{\"mode\" : \"kv\"}";
-const std::string DBConstant::RD_KV_HASH_COLLECTION_MODE = "{\"mode\" : \"kv\",\"indextype\" : \"hash\"}";
-
-const std::string DBConstant::PATH_POSTFIX_UNPACKED = "_unpacked";
-const std::string DBConstant::PATH_POSTFIX_IMPORT_BACKUP = "_import_bak";
-const std::string DBConstant::PATH_POSTFIX_IMPORT_ORIGIN = "_import_ori";
-const std::string DBConstant::PATH_POSTFIX_IMPORT_DUP = "_import_dup";
-const std::string DBConstant::PATH_POSTFIX_EXPORT_BACKUP = "_export_bak";
-const std::string DBConstant::PATH_POSTFIX_DB_INCOMPLETE = "_db_incomplete.lock";
-
-const std::string DBConstant::REKEY_FILENAME_POSTFIX_PRE = "_ctrl_pre";
-const std::string DBConstant::REKEY_FILENAME_POSTFIX_OK = "_ctrl_ok";
-const std::string DBConstant::UPGRADE_POSTFIX = "_upgrade.lock";
-const std::string DBConstant::SET_SECOPT_POSTFIX = "_secopt.lock";
-const std::string DBConstant::PATH_BACKUP_POSTFIX = "_bak";
-
-const std::string DBConstant::ID_CONNECTOR = "-";
-
-const std::string DBConstant::DELETE_KVSTORE_REMOVING = "_removing";
-const std::string DBConstant::DB_LOCK_POSTFIX = ".lock";
-
-const std::string DBConstant::SUBSCRIBE_QUERY_PREFIX = "subscribe_query_";
-
-const std::string DBConstant::TRIGGER_REFERENCES_NEW = "NEW.";
-const std::string DBConstant::TRIGGER_REFERENCES_OLD = "OLD.";
-
-const std::string DBConstant::UPDATE_META_FUNC = "update_meta_within_trigger";
-
 const std::string DBConstant::SYSTEM_TABLE_PREFIX = "naturalbase_rdb_";
 const std::string DBConstant::RELATIONAL_PREFIX = "naturalbase_rdb_aux_";
-const std::string DBConstant::TIMESTAMP_ALIAS = "naturalbase_rdb_aux_timestamp";
-const std::string DBConstant::LOG_POSTFIX = "_log";
-
-const std::string DBConstant::LOG_TABLE_VERSION_1 = "1.0";
-const std::string DBConstant::LOG_TABLE_VERSION_2 = "2.0";
-const std::string DBConstant::LOG_TABLE_VERSION_CURRENT = LOG_TABLE_VERSION_5_7;
-
+const std::string DBConstant::RELATIONAL_SCHEMA_KEY = "relational_schema";
+const std::string DBConstant::RELATIONAL_TRACKER_SCHEMA_KEY = "relational_tracker_schema";
 const std::string DBConstant::LOG_TABLE_VERSION_KEY = "log_table_version";
-
-const std::string DBConstant::REMOTE_DEVICE_SCHEMA_KEY_PREFIX = "remote_device_schema_";
-
-const std::string DBConstant::DEVICEID_PREFIX_KEY = "deviceId";
-const std::string DBConstant::QUERY_SYNC_PREFIX_KEY = "querySync";
-const std::string DBConstant::DELETE_SYNC_PREFIX_KEY = "deleteSync";
+const std::string DBConstant::TIMESTAMP_ALIAS = "naturalbase_rdb_aux_timestamp";
+const std::string DBConstant::UPDATE_META_FUNC = "update_meta_within_trigger";
+const std::string DBConstant::SINGLE_VER_DATA_STORE = "gen_natural_store";
+const std::string DBConstant::SINGLE_VER_META_STORE = "meta";
+const std::string DBConstant::SINGLE_VER_CACHE_STORE = "cache";
 }
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp b/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp
index 2e62ba47594380d83d6a4accb6d1d5b036e38b9c..2652b3659646a53df195b4081c55d8764a06bc83 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/db_dfx_adapter.cpp
@@ -69,7 +69,11 @@ void DBDfxAdapter::Dump(int fd, const std::vector<std::u16string> &args)
     }
     DBDumpHelper::Dump(fd, "DistributedDB Dump Message Info:\n\n");
     DBDumpHelper::Dump(fd, "DistributedDB Database Basic Message Info:\n");
-    KvDBManager::GetInstance()->Dump(fd);
+    auto kvDBManager = KvDBManager::GetInstance();
+    if (kvDBManager == nullptr) {
+        return;
+    }
+    kvDBManager->Dump(fd);
     RelationalStoreInstance::GetInstance()->Dump(fd);
     DBDumpHelper::Dump(fd, "DistributedDB Common Message Info:\n");
     RuntimeContext::GetInstance()->DumpCommonInfo(fd);
@@ -80,18 +84,43 @@ void DBDfxAdapter::Dump(int fd, const std::vector<std::u16string> &args)
 void DBDfxAdapter::ReportBehavior(const ReportTask &reportTask)
 {
     int dbDfxErrCode = -(reportTask.errCode - E_BASE) + E_DB_DFX_BASE;
+    struct HiSysEventParam params[] = {
+        {.name = {"ORG_PKG"},
+            .t = HISYSEVENT_STRING,
+            .v = {.s = const_cast<char *>(ORG_PKG_NAME.c_str())},
+            .arraySize = 0},
+        {.name = {"FUNC"},
+            .t = HISYSEVENT_STRING,
+            .v = {.s = const_cast<char *>(reportTask.funcName.c_str())},
+            .arraySize = 0},
+        {.name = {"BIZ_SCENE"},
+            .t = HISYSEVENT_INT32,
+            .v = {.i32 = static_cast<int32_t>(reportTask.scene)},
+            .arraySize = 0 },
+        {.name = {"BIZ_STATE"},
+            .t = HISYSEVENT_INT32,
+            .v = {.i32 = static_cast<int32_t>(reportTask.state)},
+            .arraySize = 0 },
+        {.name = {"BIZ_STAGE"},
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = static_cast<int32_t>(reportTask.stage)},
+            .arraySize = 0 },
+        {.name = {"STAGE_RES"},
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = static_cast<int32_t>(reportTask.result)},
+            .arraySize = 0 },
+        {.name = {"ERROR_CODE"},
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = static_cast<int32_t>(dbDfxErrCode)},
+            .arraySize = 0 },
+    };
     RuntimeContext::GetInstance()->ScheduleTask([=]() {
         // call hievent here
-        HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DATAMGR,
-            DISTRIBUTED_DB_BEHAVIOR,
-            OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-            ORG_PKG, ORG_PKG_NAME,
-            FUNC, reportTask.funcName,
-            BIZ_SCENE, static_cast<int>(reportTask.scene),
-            BIZ_STATE, static_cast<int>(reportTask.state),
-            BIZ_STAGE, static_cast<int>(reportTask.stage),
-            STAGE_RES, static_cast<int>(reportTask.result),
-            ERROR_CODE, dbDfxErrCode);
+        OH_HiSysEvent_Write(OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DATAMGR,
+            DISTRIBUTED_DB_BEHAVIOR.c_str(),
+            HISYSEVENT_BEHAVIOR,
+            params,
+            sizeof(params) / sizeof(params[0]));
     });
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_epoll.cpp b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_epoll.cpp
index 62ed583525bd2c904f11182021070823b89f3963..21d1aae2110b4f040d9a23490c424c711fa558aa 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_epoll.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/evloop/src/event_loop_epoll.cpp
@@ -171,13 +171,13 @@ void EventLoopEpoll::EpollWokenUp()
 uint32_t EventLoopEpoll::CalEpollEvents(EventsMask events) const
 {
     uint32_t epollEvents = 0;
-    if (events & IEvent::ET_READ) {
+    if (events & IEvent::ET_READ) { // LCOV_EXCL_BR_LINE
         epollEvents |= EPOLLIN;
     }
-    if (events & IEvent::ET_WRITE) {
+    if (events & IEvent::ET_WRITE) { // LCOV_EXCL_BR_LINE
         epollEvents |= EPOLLOUT;
     }
-    if (events & IEvent::ET_ERROR) {
+    if (events & IEvent::ET_ERROR) { // LCOV_EXCL_BR_LINE
         epollEvents |= EPOLLERR;
     }
     return epollEvents;
@@ -186,13 +186,13 @@ uint32_t EventLoopEpoll::CalEpollEvents(EventsMask events) const
 EventsMask EventLoopEpoll::CalEventsMask(uint32_t epollEvents)
 {
     EventsMask events = 0;
-    if (epollEvents & EPOLLIN) {
+    if (epollEvents & EPOLLIN) { // LCOV_EXCL_BR_LINE
         events |= IEvent::ET_READ;
     }
-    if (epollEvents & EPOLLOUT) {
+    if (epollEvents & EPOLLOUT) { // LCOV_EXCL_BR_LINE
         events |= IEvent::ET_WRITE;
     }
-    if (epollEvents & EPOLLERR) {
+    if (epollEvents & EPOLLERR) { // LCOV_EXCL_BR_LINE
         events |= IEvent::ET_ERROR;
     }
     return events;
@@ -202,15 +202,15 @@ int EventLoopEpoll::EpollCtl(int operation, EventImpl *event, EventsMask events)
 {
     if (operation != EPOLL_CTL_ADD &&
         operation != EPOLL_CTL_MOD &&
-        operation != EPOLL_CTL_DEL) {
+        operation != EPOLL_CTL_DEL) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
-    if (event == nullptr) {
+    if (event == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     EventFd fd = event->GetEventFd();
-    if (fd.IsValid()) {
+    if (fd.IsValid()) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
@@ -220,7 +220,7 @@ int EventLoopEpoll::EpollCtl(int operation, EventImpl *event, EventsMask events)
     epollEvent.data.ptr = event;
 
     int errCode = epoll_ctl(epollFd_, operation, fd, &epollEvent);
-    if (errCode < 0) {
+    if (errCode < 0) { // LCOV_EXCL_BR_LINE
         errCode = -errno;
         return errCode;
     }
@@ -229,13 +229,13 @@ int EventLoopEpoll::EpollCtl(int operation, EventImpl *event, EventsMask events)
 
 int EventLoopEpoll::AddEvent(EventImpl *event)
 {
-    if (event == nullptr) {
+    if (event == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     EventsMask events = event->GetEvents();
     int errCode = EpollCtl(EPOLL_CTL_ADD, event, events);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Add fd to epoll set failed, err:'%d'", errCode);
         return errCode;
     }
@@ -246,13 +246,13 @@ int EventLoopEpoll::AddEvent(EventImpl *event)
 
 int EventLoopEpoll::RemoveEvent(EventImpl *event)
 {
-    if (event == nullptr) {
+    if (event == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     EventsMask events = event->GetEvents();
     int errCode = EpollCtl(EPOLL_CTL_DEL, event, events);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Remove fd from epoll set failed, err:'%d'", errCode);
         return errCode;
     }
@@ -263,19 +263,19 @@ int EventLoopEpoll::RemoveEvent(EventImpl *event)
 
 int EventLoopEpoll::ModifyEvent(EventImpl *event, bool isAdd, EventsMask events)
 {
-    if (event == nullptr) {
+    if (event == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     EventsMask newEvents = event->GetEvents();
-    if (isAdd) {
+    if (isAdd) { // LCOV_EXCL_BR_LINE
         newEvents |= events;
     } else {
         newEvents &= ~events;
     }
 
     int errCode = EpollCtl(EPOLL_CTL_MOD, event, newEvents);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Modify fd in epoll set failed, err:'%d'", errCode);
         return errCode;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/param_check_utils.cpp b/kv_store/frameworks/libs/distributeddb/common/src/param_check_utils.cpp
index 59af44922b99a397aaff485bdbdcecfc3e204441..f4e73096108716789b81928c3e1b47ae00436b62 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/param_check_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/param_check_utils.cpp
@@ -36,7 +36,7 @@ bool ParamCheckUtils::CheckDataDir(const std::string &dataDir, std::string &cano
     return (OS::GetRealPath(dataDir, canonicalDir) == E_OK);
 }
 
-bool ParamCheckUtils::IsStoreIdSafe(const std::string &storeId)
+bool ParamCheckUtils::IsStoreIdSafe(const std::string &storeId, bool allowStoreIdWithDot)
 {
     if (storeId.empty() || (storeId.length() > DBConstant::MAX_STORE_ID_LENGTH)) {
         LOGE("Invalid store id[%zu]", storeId.length());
@@ -44,7 +44,9 @@ bool ParamCheckUtils::IsStoreIdSafe(const std::string &storeId)
     }
 
     auto iter = std::find_if_not(storeId.begin(), storeId.end(),
-        [](char value) { return (std::isalnum(value) || value == '_'); });
+        [allowStoreIdWithDot](char value) {
+        return (std::isalnum(value) || value == '_') || (allowStoreIdWithDot && value == '.');
+    });
     if (iter != storeId.end()) {
         LOGE("Invalid store id format");
         return false;
@@ -55,7 +57,16 @@ bool ParamCheckUtils::IsStoreIdSafe(const std::string &storeId)
 bool ParamCheckUtils::CheckStoreParameter(const std::string &storeId, const std::string &appId,
     const std::string &userId, bool isIgnoreUserIdCheck, const std::string &subUser)
 {
-    if (!IsStoreIdSafe(storeId)) {
+    return CheckStoreParameter({userId, appId, storeId}, isIgnoreUserIdCheck, subUser);
+}
+
+bool ParamCheckUtils::CheckStoreParameter(const StoreInfo &info, bool isIgnoreUserIdCheck,
+    const std::string &subUser, bool allowStoreIdWithDot)
+{
+    const auto &storeId = info.storeId;
+    const auto &userId = info.userId;
+    const auto &appId = info.appId;
+    if (!IsStoreIdSafe(storeId, allowStoreIdWithDot)) {
         return false;
     }
     if (!isIgnoreUserIdCheck) {
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp b/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp
index 44739c6f2dd9dfd7d6546e7fa8357633eff4f1c1..6bfb9e0bfce2438de95aacbd62fa2de40247babb 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/performance_analysis.cpp
@@ -31,7 +31,7 @@ std::once_flag PerformanceAnalysis::initFlag_;
 PerformanceAnalysis *PerformanceAnalysis::GetInstance(int stepNum)
 {
     static PerformanceAnalysis inst(stepNum);
-    std::call_once(initFlag_, std::bind(&PerformanceAnalysis::Initialization, &inst));
+    std::call_once(initFlag_, [] { inst.Initialization(); });
     return &inst;
 }
 
@@ -82,7 +82,7 @@ void PerformanceAnalysis::ClosePerformanceAnalysis()
 
 bool PerformanceAnalysis::InsertTimeRecord(const TimePair &timePair, uint32_t step)
 {
-    if (!IsStepValid(step)) {
+    if (!IsStepValid(step)) { // LCOV_EXCL_BR_LINE
         return false;
     }
     timeRecordData_.timeInfo[step] = timePair;
@@ -91,7 +91,7 @@ bool PerformanceAnalysis::InsertTimeRecord(const TimePair &timePair, uint32_t st
 
 bool PerformanceAnalysis::GetTimeRecord(uint32_t step, TimePair &timePair) const
 {
-    if (!IsStepValid(step)) {
+    if (!IsStepValid(step)) { // LCOV_EXCL_BR_LINE
         return false;
     }
     timePair = timeRecordData_.timeInfo[step];
@@ -100,7 +100,7 @@ bool PerformanceAnalysis::GetTimeRecord(uint32_t step, TimePair &timePair) const
 
 void PerformanceAnalysis::TimeRecordStart()
 {
-    if (!IsOpen()) {
+    if (!IsOpen()) { // LCOV_EXCL_BR_LINE
         return;
     }
     StepTimeRecordStart(0);
@@ -108,7 +108,7 @@ void PerformanceAnalysis::TimeRecordStart()
 
 void PerformanceAnalysis::TimeRecordEnd()
 {
-    if (!IsOpen()) {
+    if (!IsOpen()) { // LCOV_EXCL_BR_LINE
         return;
     }
     StepTimeRecordEnd(0);
@@ -119,13 +119,13 @@ void PerformanceAnalysis::StepTimeRecordStart(uint32_t step)
     if (!IsOpen()) {
         return;
     }
-    if (!IsStepValid(step)) {
+    if (!IsStepValid(step)) { // LCOV_EXCL_BR_LINE
         return;
     }
     TimePair timePair = {0, 0};
     uint64_t curTime = 0;
     int errCode = OS::GetCurrentSysTimeInMicrosecond(curTime);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[performance_analysis] GetCurrentSysTimeInMicrosecond fail");
     } else {
         timePair.startTime = curTime;
@@ -139,12 +139,12 @@ void PerformanceAnalysis::StepTimeRecordEnd(uint32_t step)
     if (!IsOpen()) {
         return;
     }
-    if (!IsStepValid(step)) {
+    if (!IsStepValid(step)) { // LCOV_EXCL_BR_LINE
         return;
     }
     TimePair timePair = {0, 0};
     bool errCode = GetTimeRecord(step, timePair);
-    if (!errCode) {
+    if (!errCode) { // LCOV_EXCL_BR_LINE
         return;
     }
     (void)InsertTimeRecord({0, 0}, step);
@@ -154,18 +154,19 @@ void PerformanceAnalysis::StepTimeRecordEnd(uint32_t step)
     timePair.endTime = curTime;
     LOGD("[performance_analysis] StepTimeRecordEnd step:%" PRIu32 ", curTime:%" PRIu64, step, curTime);
 
-    if ((timePair.endTime < timePair.startTime) || (timePair.startTime == 0) || (timePair.endTime == 0)) {
+    if ((timePair.endTime < timePair.startTime) || (timePair.startTime == 0)
+        || (timePair.endTime == 0)) { // LCOV_EXCL_BR_LINE
         return;
     }
     Timestamp offset = timePair.endTime - timePair.startTime;
-    if (stepTimeRecordInfo_[step].max < offset) {
+    if (stepTimeRecordInfo_[step].max < offset) { // LCOV_EXCL_BR_LINE
         stepTimeRecordInfo_[step].max = offset;
     }
-    if (offset < stepTimeRecordInfo_[step].min) {
+    if (offset < stepTimeRecordInfo_[step].min) { // LCOV_EXCL_BR_LINE
         stepTimeRecordInfo_[step].min = offset;
     }
     counts_[step]++;
-    if (counts_[step] == 0) {
+    if (counts_[step] == 0) { // LCOV_EXCL_BR_LINE
         stepTimeRecordInfo_[step].average = 0;
         return;
     }
@@ -177,7 +178,7 @@ std::string PerformanceAnalysis::GetStatistics()
 {
     std::string result;
     for (size_t i = 0; i < stepTimeRecordInfo_.size(); i++) {
-        if (stepTimeRecordInfo_[i].max != 0) {
+        if (stepTimeRecordInfo_[i].max != 0) { // LCOV_EXCL_BR_LINE
             result += "\nstep : " + std::to_string(i) + "\n";
             result += "max:                 " + std::to_string(stepTimeRecordInfo_[i].max) + "\n";
             result += "min:                 " + std::to_string(stepTimeRecordInfo_[i].min) + "\n";
@@ -201,7 +202,7 @@ void PerformanceAnalysis::OutStatistics()
     // This part filters the zeros data
     outFile << "stepNum, maxTime(us), minTime(us), averageTime(us), count,\n";
     for (size_t i = 0; i < stepTimeRecordInfo_.size(); i++) { // output to performance file
-        if (stepTimeRecordInfo_[i].max != 0) {
+        if (stepTimeRecordInfo_[i].max != 0) { // LCOV_EXCL_BR_LINE
             outFile << i << "," << stepTimeRecordInfo_[i].max<< "," << stepTimeRecordInfo_[i].min
                 << "," << stepTimeRecordInfo_[i].average << "," << counts_[i] << "," << "\n";
         }
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/query_utils.cpp b/kv_store/frameworks/libs/distributeddb/common/src/query_utils.cpp
index 7545096ac2f991d71b4f5909d6592fb21c0c3e29..e9877197b3626ee93742b26aaaacf626e05f0048 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/query_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/query_utils.cpp
@@ -16,7 +16,7 @@
 #include "query_utils.h"
 
 namespace DistributedDB {
-void QueryUtils::FillQueryInKeys(const std::string &col, const std::vector<Type> &data, size_t valueType,
+void QueryUtils::FillQueryIn(const std::string &col, const std::vector<Type> &data, size_t valueType,
     Query &query)
 {
     switch (valueType) {
@@ -56,4 +56,30 @@ void QueryUtils::FillQueryInKeys(const std::string &col, const std::vector<Type>
             break;
     }
 }
+
+void QueryUtils::FillQueryInKeys(const std::map<std::string, std::vector<Type>> &syncPk,
+    std::map<std::string, size_t> dataIndex, Query &query)
+{
+    std::set<Key> keys;
+    for (const auto &[col, pkList] : syncPk) {
+        switch (dataIndex[col]) {
+            case TYPE_INDEX<std::string>:
+                for (const auto &pk : pkList) {
+                    std::string keyStr = std::get<std::string>(pk);
+                    keys.insert(Key(keyStr.begin(), keyStr.end()));
+                }
+                break;
+            case TYPE_INDEX<Bytes>:
+                for (const auto &pk : pkList) {
+                    keys.insert(std::get<Bytes>(pk));
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    if (!keys.empty()) {
+        query.InKeys(keys);
+    }
+}
 } // DistributedDB
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_schema_object.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_schema_object.cpp
index 0e882c30360f6059ac218300e94fd841ac961612..5b47602ea871474f8be9beef1c1a98a6f3f971ca 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_schema_object.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/relational_schema_object.cpp
@@ -312,13 +312,13 @@ int RelationalSchemaObject::ParseFromTrackerSchemaString(const std::string &inSc
 {
     JsonObject schemaObj;
     int errCode = schemaObj.Parse(inSchemaString);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Schema json string parse failed: %d.", errCode);
         return errCode;
     }
 
     errCode = ParseTrackerSchema(schemaObj);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Parse to tracker schema failed: %d.", errCode);
         return errCode;
     }
@@ -395,24 +395,24 @@ int RelationalSchemaObject::ParseTrackerSchema(const JsonObject &inJsonObject)
 {
     FieldType fieldType;
     int errCode = inJsonObject.GetFieldTypeByFieldPath(FieldPath {SchemaConstant::KEYWORD_SCHEMA_TABLE}, fieldType);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Get tracker schema TABLES fieldType failed: %d.", errCode);
         return -E_SCHEMA_PARSE_FAIL;
     }
-    if (FieldType::LEAF_FIELD_ARRAY != fieldType) {
+    if (FieldType::LEAF_FIELD_ARRAY != fieldType) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Expect tracker TABLES fieldType ARRAY but %s.",
              SchemaUtils::FieldTypeString(fieldType).c_str());
         return -E_SCHEMA_PARSE_FAIL;
     }
     std::vector<JsonObject> tables;
     errCode = inJsonObject.GetObjectArrayByFieldPath(FieldPath {SchemaConstant::KEYWORD_SCHEMA_TABLE}, tables);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Get tracker schema TABLES value failed: %d.", errCode);
         return -E_SCHEMA_PARSE_FAIL;
     }
     for (const JsonObject &table : tables) {
         errCode = ParseCheckTrackerTable(table);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RelationalSchema][Parse] Parse schema TABLES failed: %d.", errCode);
             return -E_SCHEMA_PARSE_FAIL;
         }
@@ -424,15 +424,15 @@ int RelationalSchemaObject::ParseCheckTrackerTable(const JsonObject &inJsonObjec
 {
     TrackerTable table;
     int errCode = ParseCheckTrackerTableName(inJsonObject, table);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
     errCode = ParseCheckTrackerExtendName(inJsonObject, table);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
     errCode = ParseCheckTrackerName(inJsonObject, table);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
     trackerTables_[table.GetTableName()].SetTrackerTable(table);
@@ -444,8 +444,8 @@ int RelationalSchemaObject::ParseCheckTrackerTableName(const JsonObject &inJsonO
     FieldValue fieldValue;
     int errCode = GetMemberFromJsonObject(inJsonObject, "NAME", FieldType::LEAF_FIELD_STRING,
         true, fieldValue);
-    if (errCode == E_OK) {
-        if (!DBCommon::CheckIsAlnumOrUnderscore(fieldValue.stringValue)) {
+    if (errCode == E_OK) { // LCOV_EXCL_BR_LINE
+        if (!DBCommon::CheckIsAlnumOrUnderscore(fieldValue.stringValue)) { // LCOV_EXCL_BR_LINE
             LOGE("[RelationalSchema][Parse] Invalid characters in table name, err=%d.", errCode);
             return -E_SCHEMA_PARSE_FAIL;
         }
@@ -459,8 +459,8 @@ int RelationalSchemaObject::ParseCheckTrackerExtendName(const JsonObject &inJson
     FieldValue fieldValue;
     int errCode = GetMemberFromJsonObject(inJsonObject, "EXTEND_NAME", FieldType::LEAF_FIELD_STRING,
         true, fieldValue);
-    if (errCode == E_OK) {
-        if (!DBCommon::CheckIsAlnumOrUnderscore(fieldValue.stringValue)) {
+    if (errCode == E_OK) { // LCOV_EXCL_BR_LINE
+        if (!DBCommon::CheckIsAlnumOrUnderscore(fieldValue.stringValue)) { // LCOV_EXCL_BR_LINE
             LOGE("[RelationalSchema][Parse] Invalid characters in extend name, err=%d.", errCode);
             return -E_SCHEMA_PARSE_FAIL;
         }
@@ -473,18 +473,18 @@ int RelationalSchemaObject::ParseCheckTrackerName(const JsonObject &inJsonObject
 {
     FieldType fieldType;
     int errCode = inJsonObject.GetFieldTypeByFieldPath(FieldPath {"TRACKER_NAMES"}, fieldType);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Get tracker col names fieldType failed: %d.", errCode);
         return -E_SCHEMA_PARSE_FAIL;
     }
-    if (FieldType::LEAF_FIELD_ARRAY != fieldType) {
+    if (FieldType::LEAF_FIELD_ARRAY != fieldType) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Expect tracker TABLES fieldType ARRAY but %s.",
             SchemaUtils::FieldTypeString(fieldType).c_str());
         return -E_SCHEMA_PARSE_FAIL;
     }
     std::vector<JsonObject> fieldValues;
     errCode = inJsonObject.GetObjectArrayByFieldPath(FieldPath{"TRACKER_NAMES"}, fieldValues);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalSchema][Parse] Get tracker col names value failed: %d.", errCode);
         return -E_SCHEMA_PARSE_FAIL;
     }
@@ -492,7 +492,7 @@ int RelationalSchemaObject::ParseCheckTrackerName(const JsonObject &inJsonObject
     for (const JsonObject &value : fieldValues) {
         FieldValue fieldValue;
         errCode = value.GetFieldValueByFieldPath(FieldPath {}, fieldValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RelationalSchema][Parse] Parse tracker col name failed: %d.", errCode);
             return -E_SCHEMA_PARSE_FAIL;
         }
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
index 389383099e83174ac0f2ed5bfe56226c8933327a..e9a184701134c4082cd7dbceb8bfcb4c9da6cd3c 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/table_info.cpp
@@ -353,7 +353,7 @@ const std::map<int, FieldName> &TableInfo::GetPrimaryKey() const
 CompositeFields TableInfo::GetIdentifyKey() const
 {
     if (primaryKey_.size() == 1 && primaryKey_.at(0) == ROW_ID) {
-        if (!uniqueDefines_.empty()) {
+        if (!uniqueDefines_.empty()) { // LCOV_EXCL_BR_LINE
             return uniqueDefines_.at(0);
         }
     }
@@ -579,18 +579,17 @@ int TableInfo::CompareWithTableIndex(const IndexInfoMap &inTableIndex) const
         -E_RELATIONAL_TABLE_COMPATIBLE;
 }
 
-
 namespace {
 void Difference(const FieldInfoMap &first, const FieldInfoMap &second, FieldInfoMap &orphanFst, FieldInfoMap &orphanSnd,
     FieldInfoMap &bothAppear)
 {
     auto itFirst = first.begin();
     auto itSecond = second.begin();
-    while (itFirst != first.end()) {
-        if (itSecond == second.end()) {
+    while (itFirst != first.end()) { // LCOV_EXCL_BR_LINE
+        if (itSecond == second.end()) { // LCOV_EXCL_BR_LINE
             break;
         }
-        if (itFirst->first == itSecond->first) {
+        if (itFirst->first == itSecond->first) { // LCOV_EXCL_BR_LINE
             bothAppear.insert(*itFirst);
             itFirst++;
             itSecond++;
@@ -602,11 +601,11 @@ void Difference(const FieldInfoMap &first, const FieldInfoMap &second, FieldInfo
         }
     }
 
-    while (itFirst != first.end()) {
+    while (itFirst != first.end()) { // LCOV_EXCL_BR_LINE
         orphanFst.insert(*itFirst++);
     }
 
-    while (itSecond != second.end()) {
+    while (itSecond != second.end()) { // LCOV_EXCL_BR_LINE
         orphanSnd.insert(*itSecond++);
     }
 }
@@ -619,27 +618,27 @@ int TableInfo::CompareWithLiteTableFields(const FieldInfoMap &liteTableFields) c
     FieldInfoMap bothAppear;
     Difference(fields_, liteTableFields, orphanLocal, orphanLite, bothAppear);
 
-    if (!orphanLocal.empty() && !orphanLite.empty()) {
+    if (!orphanLocal.empty() && !orphanLite.empty()) { // LCOV_EXCL_BR_LINE
         LOGE("[Relational][Compare] Only one side should have upgrade fields");
         return -E_RELATIONAL_TABLE_INCOMPATIBLE;
     }
 
     for (const auto &it : bothAppear) {
-        if (!it.second.CompareWithField(liteTableFields.at(it.first), true)) {
+        if (!it.second.CompareWithField(liteTableFields.at(it.first), true)) { // LCOV_EXCL_BR_LINE
             LOGE("[Relational][Compare] field is incompatible");
             return -E_RELATIONAL_TABLE_INCOMPATIBLE;
         }
     }
 
     for (const auto &it : orphanLocal) {
-        if (it.second.IsNotNull() && !it.second.HasDefaultValue()) {
+        if (it.second.IsNotNull() && !it.second.HasDefaultValue()) { // LCOV_EXCL_BR_LINE
             LOGE("[Relational][Compare] field is upgrade incompatible");
             return -E_RELATIONAL_TABLE_INCOMPATIBLE;
         }
     }
 
     for (const auto &it : orphanLite) {
-        if (it.second.IsNotNull() && !it.second.HasDefaultValue()) {
+        if (it.second.IsNotNull() && !it.second.HasDefaultValue()) { // LCOV_EXCL_BR_LINE
             LOGE("[Relational][Compare] field is upgrade incompatible");
             return -E_RELATIONAL_TABLE_INCOMPATIBLE;
         }
@@ -651,15 +650,15 @@ int TableInfo::CompareWithLiteTableFields(const FieldInfoMap &liteTableFields) c
 int TableInfo::CompareWithLiteSchemaTable(const TableInfo &liteTableInfo) const
 {
     if (!liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) != ROW_ID) &&
-        !CompareWithPrimaryKey(primaryKey_, liteTableInfo.GetPrimaryKey())) {
+        !CompareWithPrimaryKey(primaryKey_, liteTableInfo.GetPrimaryKey())) { // LCOV_EXCL_BR_LINE
         LOGE("[Relational][Compare] Table primary key is not same");
         return -E_RELATIONAL_TABLE_INCOMPATIBLE;
     }
-    if (!liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) == ROW_ID)) {
+    if (!liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) == ROW_ID)) { // LCOV_EXCL_BR_LINE
         LOGE("[Relational][Compare] Table primary key is not same");
         return -E_RELATIONAL_TABLE_INCOMPATIBLE;
     }
-    if ((liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) != ROW_ID) && !autoInc_)) {
+    if ((liteTableInfo.GetPrimaryKey().empty() && (primaryKey_.at(0) != ROW_ID) && !autoInc_)) { // LCOV_EXCL_BR_LINE
         LOGE("[Relational][Compare] Table primary key is not same");
         return -E_RELATIONAL_TABLE_INCOMPATIBLE;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/relational/tracker_table.cpp b/kv_store/frameworks/libs/distributeddb/common/src/relational/tracker_table.cpp
index 6582ef7bd5212cebbabc18c02954c55cc494a95d..ea406582c3c71d7b8cfd154f2bb9769c8b68c5ee 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/relational/tracker_table.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/relational/tracker_table.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 #ifdef RELATIONAL_STORE
+#include "cloud/cloud_storage_utils.h"
+#include "db_common.h"
 #include "tracker_table.h"
 #include "schema_constant.h"
 
@@ -55,16 +57,16 @@ const std::string TrackerTable::GetDiffTrackerValSql() const
     if (trackerColNames_.empty()) {
         return "0";
     }
-    std::string sql = " case when (";
+    std::string sql = " CASE WHEN (";
     size_t index = 0;
     for (const auto &colName: trackerColNames_) {
         sql += "(NEW." + colName + " IS NOT OLD." + colName + ")";
         if (index < trackerColNames_.size() - 1) {
-            sql += " or ";
+            sql += " OR ";
         }
         index++;
     }
-    sql += ") then 1 else 0 end";
+    sql += ") THEN 1 ELSE 0 END";
     return sql;
 }
 
@@ -73,17 +75,16 @@ const std::string TrackerTable::GetDiffIncCursorSql(const std::string &tableName
     if (trackerColNames_.empty()) {
         return "";
     }
-    std::string sql = ", cursor = case when (";
+    std::string sql = ", cursor = CASE WHEN (";
     size_t index = 0;
     for (const auto &colName: trackerColNames_) {
         sql += "(NEW." + colName + " IS NOT OLD." + colName + ")";
         if (index < trackerColNames_.size() - 1) {
-            sql += " or ";
+            sql += " OR ";
         }
         index++;
     }
-    sql += ") then (SELECT case when (MAX(cursor) is null) then 1 else (MAX(cursor) + 1) END ";
-    sql += " from " + tableName + ") ";
+    sql += ") THEN " + CloudStorageUtils::GetSelectIncCursorSql(tableName);
     sql += " ELSE cursor END ";
     return sql;
 }
@@ -114,23 +115,47 @@ const std::vector<std::string> TrackerTable::GetDropTempTriggerSql() const
         return {};
     }
     std::vector<std::string> dropSql;
-    dropSql.push_back("DROP TRIGGER IF EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_ON_INSERT_TEMP;");
-    dropSql.push_back("DROP TRIGGER IF EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_ON_UPDATE_TEMP;");
-    dropSql.push_back("DROP TRIGGER IF EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_ON_DELETE_TEMP;");
+    dropSql.push_back(GetDropTempTriggerSql(TriggerMode::TriggerModeEnum::INSERT));
+    dropSql.push_back(GetDropTempTriggerSql(TriggerMode::TriggerModeEnum::UPDATE));
+    dropSql.push_back(GetDropTempTriggerSql(TriggerMode::TriggerModeEnum::DELETE));
     return dropSql;
 }
 
+const std::string TrackerTable::GetDropTempTriggerSql(TriggerMode::TriggerModeEnum mode) const
+{
+    return "DROP TRIGGER IF EXISTS " + GetTempTriggerName(mode);
+}
+
+const std::string TrackerTable::GetCreateTempTriggerSql(TriggerMode::TriggerModeEnum mode) const
+{
+    switch (mode) {
+        case TriggerMode::TriggerModeEnum::INSERT:
+            return GetTempInsertTriggerSql();
+        case TriggerMode::TriggerModeEnum::UPDATE:
+            return GetTempUpdateTriggerSql();
+        case TriggerMode::TriggerModeEnum::DELETE:
+            return GetTempDeleteTriggerSql();
+        default:
+            return {};
+    }
+}
+
+const std::string TrackerTable::GetTempTriggerName(TriggerMode::TriggerModeEnum mode) const
+{
+    return DBConstant::RELATIONAL_PREFIX + tableName_ + "_ON_" + TriggerMode::GetTriggerModeString(mode) + "_TEMP";
+}
+
 const std::string TrackerTable::GetTempInsertTriggerSql() const
 {
     // This trigger is built on the log table
     std::string sql = "CREATE TEMP TRIGGER IF NOT EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_;
-    sql += "_ON_INSERT_TEMP AFTER INSERT ON " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" +
-        " WHEN (SELECT count(1) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
+    sql += "_ON_INSERT_TEMP AFTER INSERT ON " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log";
+    sql += " WHEN (SELECT 1 FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
         " WHERE key = 'log_trigger_switch' AND value = 'false')\n";
     sql += "BEGIN\n";
+    sql += CloudStorageUtils::GetCursorIncSql(tableName_) + "\n";
     sql += "UPDATE " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + " SET ";
-    sql += "cursor = (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END ";
-    sql += "FROM " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + ") WHERE ";
+    sql += "cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName_) + " WHERE";
     sql += " hash_key = NEW.hash_key;\n";
     if (!IsEmpty()) {
         sql += "SELECT server_observer('" + tableName_ + "', 1);";
@@ -142,16 +167,16 @@ const std::string TrackerTable::GetTempInsertTriggerSql() const
 const std::string TrackerTable::GetTempUpdateTriggerSql() const
 {
     std::string sql = "CREATE TEMP TRIGGER IF NOT EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_;
-    sql += "_ON_UPDATE_TEMP AFTER UPDATE ON " + tableName_ +
-        " WHEN (SELECT count(1) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
+    sql += "_ON_UPDATE_TEMP AFTER UPDATE ON " + tableName_;
+    sql += " WHEN (SELECT 1 FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
         " WHERE key = 'log_trigger_switch' AND value = 'false')\n";
     sql += "BEGIN\n";
+    sql += CloudStorageUtils::GetCursorIncSql(tableName_) + "\n";
     sql += "UPDATE " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + " SET ";
     if (!IsEmpty()) {
         sql += "extend_field=" + GetAssignValSql() + ",";
     }
-    sql += " cursor = (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END ";
-    sql += "FROM " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + ") WHERE ";
+    sql += "cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName_) + " WHERE";
     sql += " data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
     if (!IsEmpty()) {
         sql += "SELECT server_observer('" + tableName_ + "', " + GetDiffTrackerValSql() + ");";
@@ -164,15 +189,15 @@ const std::string TrackerTable::GetTempDeleteTriggerSql() const
 {
     std::string sql = "CREATE TEMP TRIGGER IF NOT EXISTS " + DBConstant::RELATIONAL_PREFIX + tableName_;
     sql += "_ON_DELETE_TEMP AFTER DELETE ON " + tableName_ +
-        " WHEN (SELECT count(1) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
+        " WHEN (SELECT 1 FROM " + DBConstant::RELATIONAL_PREFIX + "metadata" +
         " WHERE key = 'log_trigger_switch' AND value = 'false')\n";
     sql += "BEGIN\n";
+    sql += CloudStorageUtils::GetCursorIncSql(tableName_) + "\n";
     sql += "UPDATE " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + " SET ";
     if (!IsEmpty()) {
         sql += "extend_field=" + GetAssignValSql(true) + ",";
     }
-    sql += " cursor = (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END ";
-    sql += "FROM " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log" + ") WHERE ";
+    sql += "cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName_) + " WHERE";
     sql += " data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
     if (!IsEmpty()) {
         sql += "SELECT server_observer('" + tableName_ + "', 1);";
@@ -181,17 +206,6 @@ const std::string TrackerTable::GetTempDeleteTriggerSql() const
     return sql;
 }
 
-const std::string TrackerTable::GetUpgradedExtendValSql() const
-{
-    if (IsEmpty() || extendColName_.empty()) {
-        return "''";
-    }
-    std::string sql = " (SELECT " + extendColName_ + " from " + tableName_ + " WHERE " + tableName_ + "." +
-        std::string(DBConstant::SQLITE_INNER_ROWID) +
-        " = " + DBConstant::RELATIONAL_PREFIX + tableName_ + "_log.data_key) ";
-    return sql;
-}
-
 void TrackerTable::SetTableName(const std::string &tableName)
 {
     tableName_ = tableName;
@@ -227,5 +241,47 @@ bool TrackerTable::IsChanging(const TrackerSchema &schema)
     }
     return false;
 }
+
+int TrackerTable::ReBuildTempTrigger(sqlite3 *db, TriggerMode::TriggerModeEnum mode, const AfterBuildAction &action)
+{
+    sqlite3_stmt *stmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(db, "SELECT 1 FROM sqlite_temp_master where name='" +
+        GetTempTriggerName(mode) + "' and type='trigger' COLLATE NOCASE;", stmt);
+    if (errCode != E_OK) {
+        LOGE("Failed to select temp trigger mode:%d err:%d", mode, errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::StepWithRetry(stmt);
+    bool isExists = (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) ? true : false;
+    int ret = E_OK;
+    SQLiteUtils::ResetStatement(stmt, true, ret);
+    if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_ROW) && errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        LOGE("Select temp trigger step mode:%d err:%d", mode, errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::ExecuteRawSQL(db, GetDropTempTriggerSql(mode));
+    if (errCode != E_OK) {
+        LOGE("Failed to drop temp trigger mode:%d err:%d", mode, errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::ExecuteRawSQL(db, GetCreateTempTriggerSql(mode));
+    if (errCode != E_OK) {
+        LOGE("Failed to create temp trigger mode:%d err:%d", mode, errCode);
+        return errCode;
+    }
+    if (action != nullptr) {
+        errCode = action();
+        if (errCode != E_OK) {
+            return errCode;
+        }
+    }
+    if (!isExists) {
+        errCode = SQLiteUtils::ExecuteRawSQL(db, GetDropTempTriggerSql(mode));
+        if (errCode != E_OK) {
+            LOGE("Failed to clear temp trigger mode:%d err:%d", mode, errCode);
+        }
+    }
+    return errCode;
+}
 }
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp
index 72d6911642f94f63a1d190b451615e8083c1ca3d..7c84bba70ebe22d9fa66f2e30d764964c44a52ad 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context.cpp
@@ -20,7 +20,9 @@
 namespace DistributedDB {
 RuntimeContext *RuntimeContext::GetInstance()
 {
-    static char instMemory[sizeof(RuntimeContextImpl)];
+    const int MEMORY_MAX_SIZE = 4096;
+    static_assert(sizeof(RuntimeContextImpl) < MEMORY_MAX_SIZE);
+    static char instMemory[MEMORY_MAX_SIZE];
     static std::mutex instLock_;
     static std::atomic<RuntimeContext *> instPtr = nullptr;
     // For Double-Checked Locking, we need check insPtr twice
@@ -30,7 +32,7 @@ RuntimeContext *RuntimeContext::GetInstance()
             // Use instMemory to make sure this singleton not free before other object.
             // This operation needn't to malloc memory, we needn't to check nullptr.
             instPtr = new (instMemory) RuntimeContextImpl;
-            LOGI("DistributedDB Version : %s", SOFTWARE_VERSION_STRING.c_str());
+            LOGI("DistributedDB Version : %s", SOFTWARE_VERSION_STRING);
         }
     }
     return instPtr;
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
index eca5b2e6867bcc15aaa385801cca213f56966655..e4ab9353e1611508fd612ec3c92ab30ffd0812a4 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/runtime_context_impl.cpp
@@ -45,16 +45,16 @@ RuntimeContextImpl::RuntimeContextImpl()
 // Destruct the object.
 RuntimeContextImpl::~RuntimeContextImpl()
 {
-    if (taskPoolReportsTimerId_ > 0) {
+    if (taskPoolReportsTimerId_ > 0) { // LCOV_EXCL_BR_LINE
         RemoveTimer(taskPoolReportsTimerId_, true);
         taskPoolReportsTimerId_ = 0;
     }
-    if (taskPool_ != nullptr) {
+    if (taskPool_ != nullptr) { // LCOV_EXCL_BR_LINE
         taskPool_->Stop();
         taskPool_->Release(taskPool_);
         taskPool_ = nullptr;
     }
-    if (mainLoop_ != nullptr) {
+    if (mainLoop_ != nullptr) { // LCOV_EXCL_BR_LINE
         mainLoop_->Stop();
         mainLoop_->KillAndDecObjRef(mainLoop_);
         mainLoop_ = nullptr;
@@ -153,6 +153,7 @@ int RuntimeContextImpl::GetLocalIdentity(std::string &outTarget)
     if (communicatorAggregator_ != nullptr) {
         return communicatorAggregator_->GetLocalIdentity(outTarget);
     }
+    LOGW("[RuntimeContextImpl] Get local id without communicatorAggregator");
     return -E_NOT_INIT;
 }
 
@@ -308,7 +309,7 @@ int RuntimeContextImpl::ScheduleQueuedTask(const std::string &queueTag,
 void RuntimeContextImpl::ShrinkMemory(const std::string &description)
 {
     std::lock_guard<std::mutex> autoLock(taskLock_);
-    if (taskPool_ != nullptr) {
+    if (taskPool_ != nullptr) { // LCOV_EXCL_BR_LINE
         taskPool_->ShrinkMemory(description);
     }
 }
@@ -487,8 +488,9 @@ NotificationChain::Listener *RuntimeContextImpl::RegisterLockStatusLister(const
         }
 
         if (systemApiAdapter_ != nullptr) {
-            auto callback = std::bind(&LockStatusObserver::OnStatusChange,
-                lockStatusObserver_, std::placeholders::_1);
+            auto callback = [lockStatusObserver = lockStatusObserver_](bool isLocked) {
+                lockStatusObserver->OnStatusChange(isLocked);
+            };
             errCode = systemApiAdapter_->RegOnAccessControlledEvent(callback);
             if (errCode != OK) {
                 delete lockStatusObserver_;
@@ -599,8 +601,9 @@ int RuntimeContextImpl::SetProcessSystemApiAdapter(const std::shared_ptr<IProces
     std::lock_guard<std::recursive_mutex> systemApiAdapterLock(systemApiAdapterLock_, std::adopt_lock);
     systemApiAdapter_ = adapter;
     if (systemApiAdapter_ != nullptr && lockStatusObserver_ != nullptr && lockStatusObserver_->IsStarted()) {
-        auto callback = std::bind(&LockStatusObserver::OnStatusChange,
-            lockStatusObserver_, std::placeholders::_1);
+        auto callback = [lockStatusObserver = lockStatusObserver_](bool isLocked) {
+            lockStatusObserver->OnStatusChange(isLocked);
+        };
         int errCode = systemApiAdapter_->RegOnAccessControlledEvent(callback);
         if (errCode != OK) {
             LOGE("Register access controlled event failed while setting adapter, err = %d", errCode);
@@ -1145,6 +1148,7 @@ int RuntimeContextImpl::BlobToAssets(const std::vector<uint8_t> &blob, Assets &a
         return -E_NOT_INIT;
     }
     assets = dataTranslate_->BlobToAssets(blob);
+    DBCommon::RemoveDuplicateAssetsData(assets);
     return E_OK;
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp b/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp
index 324e5f413cf151812734c5f5804c0fec819e0f63..2488b497635ca5ac2cdd58ab8634fe42051001f3 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/schema_object.cpp
@@ -318,20 +318,20 @@ int SchemaObject::VerifyValue(ValueSource sourceType, const Value &inValue) cons
 
 int SchemaObject::VerifyValue(ValueSource sourceType, const RawValue &inValue) const
 {
-    if (inValue.first == nullptr) {
+    if (inValue.first == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
-    if (!isValid_ || schemaType_ != SchemaType::FLATBUFFER) {
+    if (!isValid_ || schemaType_ != SchemaType::FLATBUFFER) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
-    if (inValue.second <= schemaSkipSize_) {
+    if (inValue.second <= schemaSkipSize_) { // LCOV_EXCL_BR_LINE
         LOGE("[Schema][Verify] Value length=%" PRIu32 " invalid, skipsize=%" PRIu32, inValue.second, schemaSkipSize_);
         return -E_FLATBUFFER_VERIFY_FAIL;
     }
 
     RawValue rawValue;
     std::vector<uint8_t> cache;
-    if (schemaSkipSize_ % SchemaConstant::SECURE_BYTE_ALIGN == 0) {
+    if (schemaSkipSize_ % SchemaConstant::SECURE_BYTE_ALIGN == 0) { // LCOV_EXCL_BR_LINE
         rawValue = {inValue.first + schemaSkipSize_, inValue.second - schemaSkipSize_};
     } else {
         cache.assign(inValue.first + schemaSkipSize_, inValue.first + inValue.second);
@@ -340,7 +340,7 @@ int SchemaObject::VerifyValue(ValueSource sourceType, const RawValue &inValue) c
 
     // Currently do not try no sizePrefix, future may depend on sourceType
     int errCode = flatbufferSchema_.VerifyFlatBufferValue(rawValue, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[Schema][Verify] Value verify fail, srcType=%d.", static_cast<int>(sourceType));
         return errCode;
     }
@@ -351,20 +351,20 @@ int SchemaObject::ExtractValue(ValueSource sourceType, RawString inPath, const R
     TypeValue &outExtract, std::vector<uint8_t> *cache) const
 {
     // NOTE!!! This function is performance sensitive !!! Carefully not to allocate memory often!!!
-    if (!isValid_ || schemaType_ != SchemaType::FLATBUFFER) {
+    if (!isValid_ || schemaType_ != SchemaType::FLATBUFFER) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
-    if (inPath == nullptr || inValue.first == nullptr) {
+    if (inPath == nullptr || inValue.first == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
-    if (inValue.second <= schemaSkipSize_) {
+    if (inValue.second <= schemaSkipSize_) { // LCOV_EXCL_BR_LINE
         LOGE("[Schema][Extract] Value length=%" PRIu32 " invalid, skip:%" PRIu32, inValue.second, schemaSkipSize_);
         return -E_FLATBUFFER_VERIFY_FAIL;
     }
 
     RawValue rawValue;
     std::vector<uint8_t> *tempCache = nullptr; // A temporary cache for use when input cache can not hold.
-    if (schemaSkipSize_ % SchemaConstant::SECURE_BYTE_ALIGN == 0) {
+    if (schemaSkipSize_ % SchemaConstant::SECURE_BYTE_ALIGN == 0) { // LCOV_EXCL_BR_LINE
         rawValue = {inValue.first + schemaSkipSize_, inValue.second - schemaSkipSize_};
     } else if ((cache != nullptr) && (cache->size() >= (inValue.second - schemaSkipSize_))) {
         // Do not expand the cache if it can not hold
@@ -384,7 +384,7 @@ int SchemaObject::ExtractValue(ValueSource sourceType, RawString inPath, const R
 
     // Currently do not try no sizePrefix, future may depend on sourceType
     int errCode = flatbufferSchema_.ExtractFlatBufferValue(inPath, rawValue, outExtract, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[Schema][Extract] Fail, srcType=%d.", static_cast<int>(sourceType));
     }
     delete tempCache; // delete nullptr is safe
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/semaphore_utils.cpp b/kv_store/frameworks/libs/distributeddb/common/src/semaphore_utils.cpp
index 05d99dd3c1cdb76e577faf964b3f4536956a82c2..7eedf114ca1681837d9f3f61fc6b286a244ed843 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/semaphore_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/semaphore_utils.cpp
@@ -34,7 +34,7 @@ bool SemaphoreUtils::WaitSemaphore(int waitSecond)
 {
     unique_lock<mutex> lock(lockMutex_);
     bool result = cv_.wait_for(lock, std::chrono::seconds(waitSecond),
-        std::bind(&SemaphoreUtils::CompareCount, this));
+        [this] { return CompareCount(); });
     if (result == true) {
         --count_;
     }
@@ -44,7 +44,7 @@ bool SemaphoreUtils::WaitSemaphore(int waitSecond)
 void SemaphoreUtils::WaitSemaphore()
 {
     unique_lock<mutex> lock(lockMutex_);
-    cv_.wait(lock, std::bind(&SemaphoreUtils::CompareCount, this));
+    cv_.wait(lock, [this] { return CompareCount(); });
     --count_;
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/time_tick_monitor.cpp b/kv_store/frameworks/libs/distributeddb/common/src/time_tick_monitor.cpp
index 34a0c4d02121cb12c8978afd8134b4d731c0b2af..1c692cc7d7fe2074670b56dd450040e97926881c 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/time_tick_monitor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/time_tick_monitor.cpp
@@ -32,7 +32,6 @@ TimeTickMonitor::TimeTickMonitor()
 
 TimeTickMonitor::~TimeTickMonitor()
 {
-    LOGD("TimeTickMonitor destroy");
     StopTimeTickMonitor();
     runtimeCxt_ = nullptr;
 }
@@ -50,7 +49,7 @@ int TimeTickMonitor::StartTimeTickMonitor()
 
     lastMonotonicTime_ = GetMonotonicTime();
     lastSystemTime_ = GetSysCurrentTime();
-    monitorCallback_ = std::bind(&TimeTickMonitor::TimeTick, this, std::placeholders::_1);
+    monitorCallback_ = [this](TimerId timerId) { return TimeTick(timerId); };
     runtimeCxt_ = RuntimeContext::GetInstance();
     monitorTimerId_ = 0;
     errCode = runtimeCxt_->SetTimer(MONITOR_INTERVAL, monitorCallback_, nullptr, monitorTimerId_);
diff --git a/kv_store/frameworks/libs/distributeddb/common/src/value_object.cpp b/kv_store/frameworks/libs/distributeddb/common/src/value_object.cpp
index 3ec6ee999f052209e2771ca5334a0b5a3c2cf835..c4315f94cb2ea0820b4a259bb144eeb2eaa492c3 100644
--- a/kv_store/frameworks/libs/distributeddb/common/src/value_object.cpp
+++ b/kv_store/frameworks/libs/distributeddb/common/src/value_object.cpp
@@ -27,7 +27,7 @@ ValueObject::ValueObject(const ValueObject &other)
 
 ValueObject& ValueObject::operator=(const ValueObject &other)
 {
-    if (&other != this) {
+    if (&other != this) { // LCOV_EXCL_BR_LINE
         isValid_ = other.isValid_;
         value_ = other.value_;
         dataBeforeOffset_ = other.dataBeforeOffset_;
@@ -106,7 +106,7 @@ bool ValueObject::IsFieldPathExist(const FieldPath &inPath) const
 
 int ValueObject::GetFieldTypeByFieldPath(const FieldPath &inPath, FieldType &outType) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetFieldTypeByFieldPath(inPath, outType);
@@ -114,7 +114,7 @@ int ValueObject::GetFieldTypeByFieldPath(const FieldPath &inPath, FieldType &out
 
 int ValueObject::GetFieldValueByFieldPath(const FieldPath &inPath, FieldValue &outValue) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetFieldValueByFieldPath(inPath, outValue);
@@ -122,7 +122,7 @@ int ValueObject::GetFieldValueByFieldPath(const FieldPath &inPath, FieldValue &o
 
 int ValueObject::GetSubFieldPath(const FieldPath &inPath, std::set<FieldPath> &outSubPath) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetSubFieldPath(inPath, outSubPath);
@@ -130,7 +130,7 @@ int ValueObject::GetSubFieldPath(const FieldPath &inPath, std::set<FieldPath> &o
 
 int ValueObject::GetSubFieldPath(const std::set<FieldPath> &inPath, std::set<FieldPath> &outSubPath) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetSubFieldPath(inPath, outSubPath);
@@ -138,7 +138,7 @@ int ValueObject::GetSubFieldPath(const std::set<FieldPath> &inPath, std::set<Fie
 
 int ValueObject::GetSubFieldPathAndType(const FieldPath &inPath, std::map<FieldPath, FieldType> &outSubPathType) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetSubFieldPathAndType(inPath, outSubPathType);
@@ -147,7 +147,7 @@ int ValueObject::GetSubFieldPathAndType(const FieldPath &inPath, std::map<FieldP
 int ValueObject::GetSubFieldPathAndType(const std::set<FieldPath> &inPath,
     std::map<FieldPath, FieldType> &outSubPathType) const
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.GetSubFieldPathAndType(inPath, outSubPathType);
@@ -164,7 +164,7 @@ int ValueObject::InsertField(const FieldPath &inPath, FieldType inType, const Fi
 
 int ValueObject::DeleteField(const FieldPath &inPath)
 {
-    if (!isValid_) {
+    if (!isValid_) { // LCOV_EXCL_BR_LINE
         return -E_NOT_PERMIT;
     }
     return value_.DeleteField(inPath);
diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
index 0ab33930d28e9f3b62b2763a4c308ba1ab4040d5..ad7ca8c46e9f84278bb94b9458ca39dbb85f2d59 100644
--- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
+++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_aggregator.cpp
@@ -278,14 +278,14 @@ void CommunicatorAggregator::ActivateCommunicator(const LabelType &commLabel)
 namespace {
 void DoOnSendEndByTaskIfNeed(const OnSendEnd &onEnd, int result)
 {
-    if (onEnd) {
+    if (onEnd) { // LCOV_EXCL_BR_LINE
         TaskAction onSendEndTask = [onEnd, result]() {
             LOGD("[CommAggr][SendEndTask] Before On Send End.");
             onEnd(result);
             LOGD("[CommAggr][SendEndTask] After On Send End.");
         };
         int errCode = RuntimeContext::GetInstance()->ScheduleTask(onSendEndTask);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[CommAggr][SendEndTask] ScheduleTask failed, errCode = %d.", errCode);
         }
     }
@@ -345,7 +345,7 @@ int CommunicatorAggregator::GetRemoteCommunicatorVersion(const std::string &targ
 {
     std::lock_guard<std::mutex> versionMapLockGuard(versionMapMutex_);
     auto pair = versionMap_.find(target);
-    if (pair == versionMap_.end()) {
+    if (pair == versionMap_.end()) { // LCOV_EXCL_BR_LINE
         return -E_NOT_FOUND;
     }
     outVersion = pair->second;
@@ -720,9 +720,9 @@ int CommunicatorAggregator::RegCallbackToAdapter()
 {
     RefObject::IncObjRef(this); // Reference to be hold by adapter
     int errCode = adapterHandle_->RegBytesReceiveCallback(
-        std::bind(&CommunicatorAggregator::OnBytesReceive, this, std::placeholders::_1, std::placeholders::_2,
-            std::placeholders::_3, std::placeholders::_4),
-        [this]() { RefObject::DecObjRef(this); });
+        [this](const std::string &srcTarget, const uint8_t *bytes, uint32_t length, const std::string &userId) {
+            OnBytesReceive(srcTarget, bytes, length, userId);
+        }, [this]() { RefObject::DecObjRef(this); });
     if (errCode != E_OK) {
         RefObject::DecObjRef(this); // Rollback in case reg failed
         return errCode;
@@ -730,7 +730,7 @@ int CommunicatorAggregator::RegCallbackToAdapter()
 
     RefObject::IncObjRef(this); // Reference to be hold by adapter
     errCode = adapterHandle_->RegTargetChangeCallback(
-        std::bind(&CommunicatorAggregator::OnTargetChange, this, std::placeholders::_1, std::placeholders::_2),
+        [this](const std::string &target, bool isConnect) { OnTargetChange(target, isConnect); },
         [this]() { RefObject::DecObjRef(this); });
     if (errCode != E_OK) {
         RefObject::DecObjRef(this); // Rollback in case reg failed
@@ -901,7 +901,7 @@ void CommunicatorAggregator::NotifyConnectChange(const std::string &srcTarget,
         // Ignore nonactivated communicator
         if (commMap_.count(entry.first) != 0 && commMap_.at(entry.first).second) {
             LOGI("[CommAggr][NotifyConnectChange] label=%s, srcTarget=%s{private}, isOnline=%d.",
-                 VEC_TO_STR(entry.first), srcTarget.c_str(), entry.second);
+                VEC_TO_STR(entry.first), srcTarget.c_str(), entry.second);
             commMap_.at(entry.first).first->OnConnectChange(srcTarget, entry.second);
         }
     }
@@ -932,7 +932,7 @@ void CommunicatorAggregator::InitSendThread()
     if (RuntimeContext::GetInstance()->GetThreadPool() != nullptr) {
         return;
     }
-    exclusiveThread_ = std::thread(&CommunicatorAggregator::SendDataRoutine, this);
+    exclusiveThread_ = std::thread([this] { SendDataRoutine(); });
     useExclusiveThread_ = true;
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
index 9b0ac6022884cfaf10239d59ad8de9e6560d9b57..37f61b2c9447b1bf0cc23f9554b3590726ea6620 100644
--- a/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
+++ b/kv_store/frameworks/libs/distributeddb/communicator/src/communicator_linker.cpp
@@ -483,12 +483,12 @@ bool CommunicatorLinker::TriggerLabelExchangeEvent(bool checkAdapter)
     if (checkAdapter && statusAdapter_ != nullptr && !statusAdapter_->IsSendLabelExchange()) {
         return false;
     }
-    bool everFail = false;
     std::set<std::string> totalOnlineTargets;
     {
         std::lock_guard<std::mutex> entireInfoLockGuard(entireInfoMutex_);
         totalOnlineTargets = remoteOnlineTarget_;
     }
+    bool everFail = false;
     for (auto &entry : totalOnlineTargets) {
         if (TriggerLabelExchangeEvent(entry) != E_OK) {
             everFail = true;
diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
index c36ca75543528f89b41e2f42b66fb003a2a290e8..79c076683a080c36a305f49fb4a055e9eb2100b3 100644
--- a/kv_store/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
+++ b/kv_store/frameworks/libs/distributeddb/communicator/src/db_status_adapter.cpp
@@ -303,7 +303,7 @@ bool DBStatusAdapter::MergeDBInfos(const std::vector<DBInfo> &srcDbInfos, std::v
 {
     bool isDbInfoChange = false;
     for (const auto &srcInfo: srcDbInfos) {
-        if (!ParamCheckUtils::CheckStoreParameter(srcInfo.storeId, srcInfo.appId, srcInfo.userId)) {
+        if (!ParamCheckUtils::CheckStoreParameter({srcInfo.storeId, srcInfo.appId, srcInfo.userId}, false, "", true)) {
             continue;
         }
         auto res = std::find_if(dstDbInfos.begin(), dstDbInfos.end(), [&srcInfo](const DBInfo &dstInfo) {
diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
index 729bccaadf557de8413f46dfaabaa1f8195594fd..1ff6e7615e653dbf9fd20282908cebb590ffdba3 100644
--- a/kv_store/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
+++ b/kv_store/frameworks/libs/distributeddb/communicator/src/network_adapter.cpp
@@ -61,8 +61,10 @@ int NetworkAdapter::StartAdapter()
         LOGE("[NAdapt][Start] Start Fail, errCode=%d.", static_cast<int>(errCode));
         return -E_PERIPHERAL_INTERFACE_FAIL;
     }
-    errCode = processCommunicator_->RegOnDataReceive(std::bind(&NetworkAdapter::OnDataReceiveHandler, this,
-        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    errCode = processCommunicator_->RegOnDataReceive(
+        [this](const DeviceInfos &srcDevInfo, const uint8_t *data, uint32_t length) {
+            OnDataReceiveHandler(srcDevInfo, data, length);
+        });
     if (errCode != DBStatus::OK) {
         LOGE("[NAdapt][Start] RegOnDataReceive Fail, errCode=%d.", static_cast<int>(errCode));
         // DO ROLLBACK
@@ -70,8 +72,9 @@ int NetworkAdapter::StartAdapter()
         LOGI("[NAdapt][Start] ROLLBACK: Stop errCode=%d.", static_cast<int>(errCode));
         return -E_PERIPHERAL_INTERFACE_FAIL;
     }
-    errCode = processCommunicator_->RegOnDeviceChange(std::bind(&NetworkAdapter::OnDeviceChangeHandler, this,
-        std::placeholders::_1, std::placeholders::_2));
+    errCode = processCommunicator_->RegOnDeviceChange([this](const DeviceInfos &devInfo, bool isOnline) {
+        OnDeviceChangeHandler(devInfo, isOnline);
+    });
     if (errCode != DBStatus::OK) {
         LOGE("[NAdapt][Start] RegOnDeviceChange Fail, errCode=%d.", static_cast<int>(errCode));
         // DO ROLLBACK
@@ -201,6 +204,7 @@ int NetworkAdapter::GetLocalIdentity(std::string &outTarget)
     std::lock_guard<std::mutex> identityLockGuard(identityMutex_);
     DeviceInfos devInfo = processCommunicator_->GetLocalDeviceInfos();
     if (devInfo.identifier.empty()) {
+        LOGE("[NetworkAdapter] Get empty local id");
         return -E_PERIPHERAL_INTERFACE_FAIL;
     }
     if (devInfo.identifier != localIdentity_) {
@@ -326,7 +330,7 @@ void NetworkAdapter::OnDeviceChangeHandler(const DeviceInfos &devInfo, bool isOn
 void NetworkAdapter::SearchOnlineRemoteDeviceAtStartup()
 {
     std::vector<DeviceInfos> onlineDev = processCommunicator_->GetRemoteOnlineDeviceInfosList();
-    LOGE("[NAdapt][SearchOnline] onlineDev count = %zu.", onlineDev.size());
+    LOGI("[NAdapt][SearchOnline] onlineDev count = %zu.", onlineDev.size());
     if (onlineDev.empty()) {
         return;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp b/kv_store/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
index 84048d9810cc1fa363217ae2af5dd60228dcc534..3cf9bb19789fe379e49f7c8e39a4df0cac356261 100644
--- a/kv_store/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
+++ b/kv_store/frameworks/libs/distributeddb/communicator/src/protocol_proto.cpp
@@ -50,6 +50,7 @@ void SetFrameType(FrameType inFrameType, uint8_t &inPacketType)
     inPacketType &= 0x0F; // Use 0x0F to clear high four bits
     inPacketType |= (static_cast<uint8_t>(inFrameType) << 4); // frame type is on high 4 bits
 }
+
 FrameType GetFrameType(uint8_t inPacketType)
 {
     uint8_t frameType = ((inPacketType & 0xF0) >> 4); // Use 0xF0 to get high 4 bits
@@ -58,10 +59,12 @@ FrameType GetFrameType(uint8_t inPacketType)
     }
     return static_cast<FrameType>(frameType);
 }
+
 bool IsSendLabelExchange(uint8_t inPacketType)
 {
     return ((inPacketType & 0x08) >> 3) == 0; // Use 0x08 and remove low 3 bit, it is Communication negotiation mark
 }
+
 void SetSendLabelExchange(uint8_t &inPacketType, bool sendLabelExchange)
 {
     if (!sendLabelExchange) {
diff --git a/kv_store/frameworks/libs/distributeddb/distributeddb.gni b/kv_store/frameworks/libs/distributeddb/distributeddb.gni
index a9c00a254f99cf1f5019c93a9d582159e9e47666..edad8b1888960ec1faf32dbe990507a45218f895 100644
--- a/kv_store/frameworks/libs/distributeddb/distributeddb.gni
+++ b/kv_store/frameworks/libs/distributeddb/distributeddb.gni
@@ -95,6 +95,7 @@ distributeddb_src = [
   "${distributeddb_path}/interfaces/src/runtime_config.cpp",
   "${distributeddb_path}/storage/src/cloud/cloud_meta_data.cpp",
   "${distributeddb_path}/storage/src/cloud/cloud_storage_utils.cpp",
+  "${distributeddb_path}/storage/src/cloud/cloud_upload_recorder.cpp",
   "${distributeddb_path}/storage/src/cloud/schema_mgr.cpp",
   "${distributeddb_path}/storage/src/data_transformer.cpp",
   "${distributeddb_path}/storage/src/db_properties.cpp",
@@ -212,6 +213,7 @@ distributeddb_src = [
   "${distributeddb_path}/syncer/src/cloud/cloud_sync_tag_assets.cpp",
   "${distributeddb_path}/syncer/src/cloud/cloud_sync_utils.cpp",
   "${distributeddb_path}/syncer/src/cloud/process_notifier.cpp",
+  "${distributeddb_path}/syncer/src/cloud/process_recorder.cpp",
   "${distributeddb_path}/syncer/src/cloud/strategy_factory.cpp",
   "${distributeddb_path}/syncer/src/device/ability_sync.cpp",
   "${distributeddb_path}/syncer/src/device/commit_history_sync.cpp",
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_db_api.h b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_db_api.h
index 0b05fa4d77718eaeea837241035761e99517cdf6..066581ef753914000751bfd8b53d421abd566abf 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_db_api.h
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_db_api.h
@@ -26,11 +26,14 @@ GRD_API int32_t GRD_DBOpen(const char *dbPath, const char *configStr, uint32_t f
 
 GRD_API int32_t GRD_DBClose(GRD_DB *db, uint32_t flags);
 
+GRD_API int32_t GRD_DBBackup(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen);
+
+GRD_API int32_t GRD_DBRestore(const char *dbFile, const char *backupDbFile, uint8_t *decryptedKey,
+    uint32_t decryptedKeyLen);
+
 GRD_API int32_t GRD_IndexPreload(GRD_DB *db, const char *collectionName);
 
 GRD_API int32_t GRD_Flush(GRD_DB *db, uint32_t flags);
-
-GRD_API void GRD_SetLibType(bool isHash = false);
 #ifdef __cplusplus
 }
 #endif // __cplusplus
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_error.h b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_error.h
index df75287b5d1becc3c8d7b76512efd7afedb10439..c862fddfd0ceec2b7c42c04623795ebae7ef953d 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_error.h
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/include/grd_base/grd_error.h
@@ -48,6 +48,8 @@ extern "C" {
 #define GRD_DISK_SPACE_FULL (-41000)
 #define GRD_CRC_CHECK_DISABLED (-42000)
 #define GRD_PERMISSION_DENIED (-43000)
+#define GRD_DATA_CORRUPTED (-45000)
+#define GRD_DB_BUSY (-46000)
 
 // not support
 #define GRD_JSON_OPERATION_NOT_SUPPORT (-5001001)
@@ -78,6 +80,9 @@ extern "C" {
 #define GRD_KEY_CONFLICT (-5016002)
 #define GRD_FIELD_TYPE_CONFLICT (-5016003)
 
+// data exception
+#define GRD_DATA_EXCEPTION (-5017001)
+
 // Cursor or ResultSet not available
 #define GRD_RESULT_SET_NOT_AVAILABLE (-5019001)
 
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/include/grd_api_manager.h b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/include/grd_api_manager.h
index 3fff77afa4efc4ddd082d6a4b310732616573c7c..14b5748b679efdc4623ada7a57773472c0c65c5d 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/include/grd_api_manager.h
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/include/grd_api_manager.h
@@ -21,6 +21,9 @@
 namespace DocumentDB {
 typedef int32_t (*DBOpen)(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db);
 typedef int32_t (*DBClose)(GRD_DB *db, uint32_t flags);
+typedef int32_t (*DBBackup)(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen);
+typedef int32_t (*DBRestore)(const char *dbFile, const char *backupDbFile, uint8_t *decryptedKey,
+    uint32_t decryptedKeyLen);
 typedef int32_t (*DBFlush)(GRD_DB *db, uint32_t flags);
 typedef int32_t (*IndexPreload)(GRD_DB *db, const char *collectionName);
 typedef int32_t (*CreateCollection)(GRD_DB *db, const char *collectionName, const char *optionStr, uint32_t flags);
@@ -58,6 +61,8 @@ typedef int32_t (*KVBatchDestory)(GRD_KVBatchT *batch);
 struct GRD_APIInfo {
     DBOpen DBOpenApi = nullptr;
     DBClose DBCloseApi = nullptr;
+    DBBackup DBBackupApi = nullptr;
+    DBRestore DBRestoreApi = nullptr;
     DBFlush FlushApi = nullptr;
     IndexPreload IndexPreloadApi = nullptr;
     CreateCollection CreateCollectionApi = nullptr;
@@ -88,6 +93,6 @@ struct GRD_APIInfo {
     KVBatchDestory KVBatchDestoryApi = nullptr;
 };
 GRD_APIInfo GetApiInfoInstance();
-void SetLibType(bool isHash);
+void InitApiInfo(const char *configStr);
 } // namespace DocumentDB
 #endif // __cplusplus
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/src/grd_api_manager.cpp b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/src/grd_api_manager.cpp
index dc4caa1fd1a2a3aeffb7ee109e0ca26712d48466..4352bf1072de49cb2fa29fafb60dea71e66f5119 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/src/grd_api_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/common/src/grd_api_manager.cpp
@@ -35,7 +35,7 @@
 static void *g_library = nullptr;
 #endif
 
-static bool g_isHashLib = false;
+static bool g_isGmdbLib = false;
 
 namespace DocumentDB {
 void GRD_DBApiInitCommon(GRD_APIInfo &GRD_DBApiInfo)
@@ -77,6 +77,8 @@ void GRD_DBApiInitEnhance(GRD_APIInfo &GRD_DBApiInfo)
 #ifndef _WIN32
     GRD_DBApiInfo.DBOpenApi = (DBOpen)dlsym(g_library, "GRD_DBOpen");
     GRD_DBApiInfo.DBCloseApi = (DBClose)dlsym(g_library, "GRD_DBClose");
+    GRD_DBApiInfo.DBBackupApi = (DBBackup)dlsym(g_library, "GRD_DBBackup");
+    GRD_DBApiInfo.DBRestoreApi = (DBRestore)dlsym(g_library, "GRD_DBRestore");
     GRD_DBApiInfo.FlushApi = (DBFlush)dlsym(g_library, "GRD_Flush");
     GRD_DBApiInfo.IndexPreloadApi = (IndexPreload)dlsym(g_library, "GRD_IndexPreload");
     GRD_DBApiInfo.CreateCollectionApi = (CreateCollection)dlsym(g_library, "GRD_CreateCollection");
@@ -108,16 +110,16 @@ void GRD_DBApiInitEnhance(GRD_APIInfo &GRD_DBApiInfo)
 #endif
 }
 
-void SetLibType(bool isHash)
+void InitApiInfo(const char *configStr)
 {
-    g_isHashLib = isHash;
+    g_isGmdbLib = (configStr != nullptr);
 }
 
 GRD_APIInfo GetApiInfoInstance()
 {
     GRD_APIInfo GRD_TempApiStruct;
 #ifndef _WIN32
-    std::string libPath = g_isHashLib ? "libgaussdb_rd_vector.z.so" : "libgaussdb_rd.z.so";
+    std::string libPath = g_isGmdbLib ? "libarkdata_db_core.z.so" : "libgaussdb_rd.z.so";
     g_library = dlopen(libPath.c_str(), RTLD_LAZY);
     if (!g_library) {
         GRD_DBApiInitCommon(GRD_TempApiStruct); // When calling specific function, read whether init is successful.
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/executor/base/grd_db_api.cpp b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/executor/base/grd_db_api.cpp
index f777b46352161de361f9ed0e7fe3989f0edb0dfa..931b070d43ef3bfdd669c9be2128b4d349a3ca0c 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/executor/base/grd_db_api.cpp
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/src/executor/base/grd_db_api.cpp
@@ -28,6 +28,7 @@ static GRD_APIInfo GRD_DBApiInfo;
 GRD_API int32_t GRD_DBOpen(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db)
 {
     if (GRD_DBApiInfo.DBOpenApi == nullptr) {
+        InitApiInfo(configStr);
         GRD_DBApiInfo = GetApiInfoInstance();
     }
     if (GRD_DBApiInfo.DBOpenApi == nullptr) {
@@ -49,6 +50,31 @@ GRD_API int32_t GRD_DBClose(GRD_DB *db, uint32_t flags)
     return GRD_DBApiInfo.DBCloseApi(db, flags);
 }
 
+GRD_API int32_t GRD_DBBackup(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen)
+{
+    if (GRD_DBApiInfo.DBBackupApi == nullptr) {
+        GRD_DBApiInfo = GetApiInfoInstance();
+    }
+    if (GRD_DBApiInfo.DBBackupApi == nullptr) {
+        GLOGE("Fail to dlysm RD api symbol");
+        return GRD_INNER_ERR;
+    }
+    return GRD_DBApiInfo.DBBackupApi(db, backupDbFile, encryptedKey, encryptedKeyLen);
+}
+
+GRD_API int32_t GRD_DBRestore(const char *dbFile, const char *backupDbFile, uint8_t *decryptedKey,
+    uint32_t decryptedKeyLen)
+{
+    if (GRD_DBApiInfo.DBRestoreApi == nullptr) {
+        GRD_DBApiInfo = GetApiInfoInstance();
+    }
+    if (GRD_DBApiInfo.DBRestoreApi == nullptr) {
+        GLOGE("Fail to dlysm RD api symbol");
+        return GRD_INNER_ERR;
+    }
+    return GRD_DBApiInfo.DBRestoreApi(dbFile, backupDbFile, decryptedKey, decryptedKeyLen);
+}
+
 GRD_API int32_t GRD_Flush(GRD_DB *db, uint32_t flags)
 {
     if (GRD_DBApiInfo.FlushApi == nullptr) {
@@ -71,9 +97,4 @@ GRD_API int32_t GRD_IndexPreload(GRD_DB *db, const char *collectionName)
         return GRD_INNER_ERR;
     }
     return GRD_DBApiInfo.IndexPreloadApi(db, collectionName);
-}
-
-void GRD_SetLibType(bool isHash)
-{
-    SetLibType(isHash);
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/test/unittest/api/documentdb_api_test.cpp b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/test/unittest/api/documentdb_api_test.cpp
index 3f20da25973c38f84af2c44670013a17abf330dc..8a7d3409b9bd3f230ecf225b0534f8730c8e6a2e 100644
--- a/kv_store/frameworks/libs/distributeddb/gaussdb_rd/test/unittest/api/documentdb_api_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/gaussdb_rd/test/unittest/api/documentdb_api_test.cpp
@@ -177,21 +177,6 @@ HWTEST_F(DocumentDBApiTest, OpenDBPathTest002, TestSize.Level0)
     EXPECT_EQ(status, GRD_FAILED_FILE_OPERATION);
 }
 
-/**
- * @tc.name: OpenDBPathTest004
- * @tc.desc: call GRD_DBOpen, input dbFile as existed menu
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: mazhao
- */
-HWTEST_F(DocumentDBApiTest, OpenDBPathTest004, TestSize.Level0)
-{
-    GRD_DB *db = nullptr;
-    std::string pathNoPerm = "../test";
-    int status = GRD_DBOpen(pathNoPerm.c_str(), nullptr, GRD_DB_OPEN_CREATE, &db);
-    EXPECT_EQ(status, GRD_INVALID_ARGS);
-}
-
 /**
  * @tc.name: OpenDBConfigTest001
  * @tc.desc: Test open document db with invalid config option
diff --git a/kv_store/frameworks/libs/distributeddb/include/auto_launch_export.h b/kv_store/frameworks/libs/distributeddb/include/auto_launch_export.h
index 5db17e939cf655f4ce9cd888d8e8b0268a9949b6..485c395da208a5f181add61528df4af97a0f5789 100644
--- a/kv_store/frameworks/libs/distributeddb/include/auto_launch_export.h
+++ b/kv_store/frameworks/libs/distributeddb/include/auto_launch_export.h
@@ -42,6 +42,7 @@ struct AutoLaunchOption {
     StoreObserver *storeObserver = nullptr;
     bool syncDualTupleMode = false; // communicator label use dualTuple hash or not
     uint32_t iterateTimes = 0;
+    int conflictResolvePolicy = LAST_WIN;
 };
 
 struct AutoLaunchParam {
diff --git a/kv_store/frameworks/libs/distributeddb/include/types_export.h b/kv_store/frameworks/libs/distributeddb/include/types_export.h
index 9772f2a8837ccffeedd1d1f5e13b72641bcf8c3e..21158ebc6a0300d612850ccb1fe2316a8ab04f64 100644
--- a/kv_store/frameworks/libs/distributeddb/include/types_export.h
+++ b/kv_store/frameworks/libs/distributeddb/include/types_export.h
@@ -189,6 +189,11 @@ struct SecurityOption {
     {
         return securityLabel == rhs.securityLabel && securityFlag == rhs.securityFlag;
     }
+
+    bool operator!=(const SecurityOption &rhs) const
+    {
+        return !(*this == rhs);
+    }
 };
 
 enum class ResultSetCacheMode : int {
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h b/kv_store/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h
index 341b83a17f70463f91759284d8f806b5eaa71866..7c0ebe6beec45f4275d02ad19b2d50001ef53d42 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/include/cloud/iAssetLoader.h
@@ -38,6 +38,12 @@ public:
     {
         return DBStatus::OK;
     }
+
+    virtual DBStatus RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix,
+        std::map<std::string, Assets> &assets)
+    {
+        return DBStatus::OK;
+    }
 };
 } // namespace DistributedDB
 
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_errno.h b/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_errno.h
index ba0835389b851e7a484b6a34bdaa2e52ae63c10a..d5177782c31a9d846e8d84e2466421c09faface1 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_errno.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_errno.h
@@ -20,6 +20,6 @@
 
 namespace DistributedDB {
 // Transfer the db error code to the DBStatus.
-DBStatus TransferDBErrno(int err);
+DBStatus TransferDBErrno(int err, bool isPass = false);
 } // DistributedDB
 #endif // KV_STORE_ERRNO_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h b/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
index 43f467197b5671766644a26996be8ae40d9dcc01..90926d77842888e22f477b62523c6f4c985e14ae 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/include/kv_store_nb_delegate.h
@@ -199,6 +199,12 @@ public:
         const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
         const Query &query, bool wait) = 0;
 
+    // Sync with device, provides sync count information
+    DB_API virtual DBStatus Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess) = 0;
+
+    // Cancel sync by syncId
+    DB_API virtual DBStatus CancelSync(uint32_t syncId) = 0;
+
     // Check the integrity of this kvStore.
     DB_API virtual DBStatus CheckIntegrity() const = 0;
 
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/include/relational/relational_store_delegate.h b/kv_store/frameworks/libs/distributeddb/interfaces/include/relational/relational_store_delegate.h
index 132786ec61b7d541b6e53fb7082a9b7f496fd7b1..829a409a36c47d8597f4926879e0ecf85fae5bd2 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/include/relational/relational_store_delegate.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/include/relational/relational_store_delegate.h
@@ -100,6 +100,18 @@ public:
 
     // set the config for cloud sync task
     DB_API virtual DBStatus SetCloudSyncConfig(const CloudSyncConfig &config) = 0;
+
+    DB_API virtual DBStatus Sync([[gnu::unused]] const CloudSyncOption &option,
+        [[gnu::unused]] const SyncProcessCallback &onProcess,
+        [[gnu::unused]] uint64_t taskId)
+    {
+        return OK;
+    }
+
+    DB_API virtual SyncProcess GetCloudTaskStatus([[gnu::unused]] uint64_t taskId)
+    {
+        return {};
+    }
 protected:
     virtual DBStatus RemoveDeviceDataInner(const std::string &device, ClearMode mode) = 0;
     virtual DBStatus CreateDistributedTableInner(const std::string &tableName, TableSyncType type) = 0;
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/include/store_types.h b/kv_store/frameworks/libs/distributeddb/interfaces/include/store_types.h
index 60210dd60c7b0c54b89a34329cf55a1b3dc200d2..53080b4a7c1798fa182d37c96b5f9bf088cb9b6c 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/include/store_types.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/include/store_types.h
@@ -21,11 +21,12 @@
 #include <set>
 #include <string>
 
+#include "query.h"
 #include "types_export.h"
 
 namespace DistributedDB {
 enum DBStatus {
-    DB_ERROR = -1,
+    DB_ERROR = -1, // DBStatus in [27328512, 27394048]
     OK = 0,
     BUSY,
     NOT_FOUND,
@@ -85,6 +86,11 @@ enum DBStatus {
     WITH_INVENTORY_DATA, // inventory data exists when setTracker for the first time
     WAIT_COMPENSATED_SYNC, // need to do compensated sync
     CLOUD_SYNC_TASK_MERGED, // sync task is merged
+    CLOUD_RECORD_NOT_FOUND, // this error happen in BatchUpdate/BatchDelete
+    CLOUD_RECORD_ALREADY_EXISTED, // this error happen in BatchInsert
+    SQLITE_CANT_OPEN, // the sqlite cannot open
+    LOCAL_ASSET_NOT_FOUND, // file manager miss local assets
+    BUTT_STATUS // end of status
 };
 
 struct KvStoreConfig {
@@ -166,6 +172,9 @@ struct Info {
     uint32_t total = 0;
     uint32_t successCount = 0; // merge or upload success count
     uint32_t failCount = 0;
+    uint32_t insertCount = 0;
+    uint32_t updateCount = 0;
+    uint32_t deleteCount = 0;
 };
 
 struct TableProcessInfo {
@@ -180,6 +189,26 @@ struct SyncProcess {
     std::map<std::string, TableProcessInfo> tableProcess;
 };
 
+struct DeviceSyncOption {
+    std::vector<std::string> devices;
+    SyncMode mode = SYNC_MODE_PULL_ONLY;
+    Query query; // isQuery must be set to true if the query is set
+    bool isQuery = false;
+    bool isWait = true;
+};
+
+struct DeviceSyncInfo {
+    uint32_t total = 0;
+    uint32_t finishedCount = 0;
+};
+
+struct DeviceSyncProcess {
+    ProcessStatus process = PREPARED;
+    DBStatus errCode = OK;
+    uint32_t syncId;
+    DeviceSyncInfo pullInfo;
+};
+
 using KvStoreCorruptionHandler = std::function<void (const std::string &appId, const std::string &userId,
     const std::string &storeId)>;
 using StoreCorruptionHandler = std::function<void (const std::string &appId, const std::string &userId,
@@ -188,6 +217,8 @@ using SyncStatusCallback = std::function<void(const std::map<std::string, std::v
 
 using SyncProcessCallback = std::function<void(const std::map<std::string, SyncProcess> &process)>;
 
+using DeviceSyncProcessCallback = std::function<void(const std::map<std::string, DeviceSyncProcess> &processMap)>;
+
 struct RemoteCondition {
     std::string sql;  // The sql statement;
     std::vector<std::string> bindArgs;  // The bind args.
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
index 380bb2a51a9b34bfb4f8f14a49c1e754d62217ce..bff7d1535f05f672ec78ab4534b939655d5c63e6 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_delegate_manager.cpp
@@ -264,7 +264,7 @@ bool KvStoreDelegateManager::GetKvStoreParamCheck(const std::string &storeId, co
         LOGE("[KvStoreMgr] Invalid callback for kv store");
         return false;
     }
-    if (!CheckRdOption(option, callback)) {
+    if (!CheckParaOption(option, callback)) {
         LOGE("[KvStoreMgr] Unsupport option for RD mode");
         return false;
     }
@@ -315,15 +315,22 @@ void KvStoreDelegateManager::GetKvStore(const std::string &storeId, const KvStor
     if (!GetKvStoreParamCheck(storeId, option, callback)) {
         return;
     }
+    auto tmpOption = option;
+    if (tmpOption.storageEngineType == std::string(GAUSSDB_RD)) {
+        DBCommon::LoadGrdLib();
+        if (!DBCommon::IsGrdLibLoaded()) {
+            tmpOption.storageEngineType = std::string(SQLITE);
+        }
+    }
     // check if schema is supported and valid
     SchemaObject schema;
-    DBStatus retCode = CheckAndGetSchema(option.isMemoryDb, option.schema, schema);
+    DBStatus retCode = CheckAndGetSchema(tmpOption.isMemoryDb, tmpOption.schema, schema);
     if (retCode != OK) {
         callback(retCode, nullptr);
         return;
     }
     KvDBProperties properties;
-    InitPropWithNbOption(properties, GetKvStorePath(), schema, option);
+    InitPropWithNbOption(properties, GetKvStorePath(), schema, tmpOption);
     DbIdParam dbIdParam = { appId_, userId_, storeId, subUser_, instanceId_ };
     DBCommon::SetDatabaseIds(properties, dbIdParam);
 
@@ -343,7 +350,7 @@ void KvStoreDelegateManager::GetKvStore(const std::string &storeId, const KvStor
         return;
     }
 
-    status = SetObserverNotifier(kvStore, option);
+    status = SetObserverNotifier(kvStore, tmpOption);
     if (status != OK) {
         CloseKvStore(kvStore);
         callback(status, nullptr);
@@ -353,7 +360,7 @@ void KvStoreDelegateManager::GetKvStore(const std::string &storeId, const KvStor
     bool enAutoSync = false;
     (void)conn->Pragma(PRAGMA_AUTO_SYNC, static_cast<void *>(&enAutoSync));
 
-    SecurityOption secOption = option.secOption;
+    SecurityOption secOption = tmpOption.secOption;
     (void)conn->Pragma(PRAGMA_TRIGGER_TO_MIGRATE_DATA, &secOption);
 
     callback(OK, kvStore);
@@ -409,7 +416,7 @@ DBStatus KvStoreDelegateManager::DeleteKvStore(const std::string &storeId)
 
     KvDBProperties properties;
     properties.SetStringProp(KvDBProperties::DATA_DIR, GetKvStorePath());
-    DbIdParam dbIdParam = { appId_, userId_, storeId };
+    DbIdParam dbIdParam = { appId_, userId_, storeId, subUser_ };
     DBCommon::SetDatabaseIds(properties, dbIdParam);
     int errCode = KvDBManager::RemoveDatabase(properties);
     if (errCode == E_OK) {
@@ -479,7 +486,7 @@ DBStatus KvStoreDelegateManager::GetKvStoreDiskSize(const std::string &storeId,
     }
     KvDBProperties properties;
     properties.SetStringProp(KvDBProperties::DATA_DIR, dataDir);
-    DbIdParam dbIdParam = { appId_, userId_, storeId };
+    DbIdParam dbIdParam = { appId_, userId_, storeId, subUser_ };
     DBCommon::SetDatabaseIds(properties, dbIdParam);
     int errCode = KvDBManager::CalculateKvStoreSize(properties, size);
     if (errCode != E_OK) {
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_errno.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_errno.cpp
index 0d7fac08fef8e79f36e32fde4ea27789f99aa268..aef7e2c5c1b2643a4b3b0e86582079c283362c54 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_errno.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_errno.cpp
@@ -82,11 +82,15 @@ namespace {
         { -E_WITH_INVENTORY_DATA, WITH_INVENTORY_DATA },
         { -E_WAIT_COMPENSATED_SYNC, WAIT_COMPENSATED_SYNC },
         { -E_CLOUD_SYNC_TASK_MERGED, CLOUD_SYNC_TASK_MERGED },
+        { -E_SQLITE_CANT_OPEN, SQLITE_CANT_OPEN },
     };
 }
 
-DBStatus TransferDBErrno(int err)
+DBStatus TransferDBErrno(int err, bool isPass)
 {
+    if (isPass && err > 0) {
+        return static_cast<DBStatus>(err);
+    }
     for (const auto &item : ERRNO_MAP) {
         if (item.errCode == err) {
             return item.status;
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
index d360b50fc7c6c0041c1d527281164d21c144f7ec..3558ab16cf0483833129ba9b5fefd0c7b9a43c90 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.cpp
@@ -302,10 +302,9 @@ DBStatus KvStoreNbDelegateImpl::PublishLocal(const Key &key, bool deleteLocal, b
         PragmaPublishInfo publishInfo{ key, deleteLocal, updateTimestamp, onConflict };
         int errCode = conn_->Pragma(PRAGMA_PUBLISH_LOCAL, static_cast<PragmaData>(&publishInfo));
         if (errCode != E_OK) {
-            LOGD("[KvStoreNbDelegate] Publish local err:%d", errCode);
-            return TransferDBErrno(errCode);
+            LOGE("[KvStoreNbDelegate] Publish local err:%d", errCode);
         }
-        return OK;
+        return TransferDBErrno(errCode);
     }
 
     LOGE("%s", INVALID_CONNECTION);
@@ -323,10 +322,9 @@ DBStatus KvStoreNbDelegateImpl::UnpublishToLocal(const Key &key, bool deletePubl
         PragmaUnpublishInfo unpublishInfo{ key, deletePublic, updateTimestamp };
         int errCode = conn_->Pragma(PRAGMA_UNPUBLISH_SYNC, static_cast<PragmaData>(&unpublishInfo));
         if (errCode != E_OK) {
-            LOGD("[KvStoreNbDelegate] Unpublish result:%d", errCode);
-            return TransferDBErrno(errCode);
+            LOGE("[KvStoreNbDelegate] Unpublish result:%d", errCode);
         }
-        return OK;
+        return TransferDBErrno(errCode);
     }
 
     LOGE("%s", INVALID_CONNECTION);
@@ -345,10 +343,8 @@ DBStatus KvStoreNbDelegateImpl::PutLocalBatch(const std::vector<Entry> &entries)
     int errCode = conn_->PutBatch(option, entries);
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Put local batch data failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 DBStatus KvStoreNbDelegateImpl::DeleteLocalBatch(const std::vector<Key> &keys)
@@ -537,9 +533,8 @@ DBStatus KvStoreNbDelegateImpl::RemoveDeviceData(const std::string &device)
         const_cast<void *>(static_cast<const void *>(&device)));
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Remove device data failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 std::string KvStoreNbDelegateImpl::GetStoreId() const
@@ -560,8 +555,10 @@ DBStatus KvStoreNbDelegateImpl::Sync(const std::vector<std::string> &devices, Sy
         return NOT_SUPPORT;
     }
 
-    PragmaSync pragmaData(devices, mode, std::bind(&KvStoreNbDelegateImpl::OnSyncComplete,
-        this, std::placeholders::_1, onComplete), wait);
+    PragmaSync pragmaData(
+        devices, mode, [this, onComplete](const std::map<std::string, int> &statuses) {
+            OnSyncComplete(statuses, onComplete);
+        }, wait);
     int errCode = conn_->Pragma(PRAGMA_SYNC_DEVICES, &pragmaData);
     if (errCode < E_OK) {
         LOGE("[KvStoreNbDelegate] Sync data failed:%d", errCode);
@@ -592,8 +589,10 @@ DBStatus KvStoreNbDelegateImpl::Sync(const std::vector<std::string> &devices, Sy
         LOGE("not support order by timestamp and query by range");
         return NOT_SUPPORT;
     }
-    PragmaSync pragmaData(devices, mode, querySyncObj, std::bind(&KvStoreNbDelegateImpl::OnSyncComplete,
-        this, std::placeholders::_1, onComplete), wait);
+    PragmaSync pragmaData(
+        devices, mode, querySyncObj, [this, onComplete](const std::map<std::string, int> &statuses) {
+            OnSyncComplete(statuses, onComplete);
+        }, wait);
     int errCode = conn_->Pragma(PRAGMA_SYNC_DEVICES, &pragmaData);
     if (errCode < E_OK) {
         LOGE("[KvStoreNbDelegate] QuerySync data failed:%d", errCode);
@@ -602,6 +601,76 @@ DBStatus KvStoreNbDelegateImpl::Sync(const std::vector<std::string> &devices, Sy
     return OK;
 }
 
+void KvStoreNbDelegateImpl::OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &processMap,
+    const DeviceSyncProcessCallback &onProcess) const
+{
+    std::map<std::string, DeviceSyncProcess> result;
+    for (const auto &pair : processMap) {
+        DeviceSyncProcess info = pair.second;
+        int status = info.errCode;
+        info.errCode = SyncOperation::DBStatusTrans(status);
+        info.process = SyncOperation::DBStatusTransProcess(status);
+        result.insert(std::pair<std::string, DeviceSyncProcess>(pair.first, info));
+    }
+    if (onProcess) {
+        onProcess(result);
+    }
+}
+
+DBStatus KvStoreNbDelegateImpl::Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess)
+{
+    if (conn_ == nullptr) {
+        LOGE("%s", INVALID_CONNECTION);
+        return DB_ERROR;
+    }
+    if (option.mode != SYNC_MODE_PULL_ONLY) {
+        LOGE("Not support other mode");
+        return NOT_SUPPORT;
+    }
+    DeviceSyncProcessCallback onSyncProcess = [this, onProcess](const std::map<std::string, DeviceSyncProcess> &map) {
+        OnDeviceSyncProcess(map, onProcess);
+    };
+    int errCode = E_OK;
+    if (option.isQuery) {
+        QuerySyncObject querySyncObj(option.query);
+        if (!DBCommon::CheckQueryWithoutMultiTable(option.query)) {
+            LOGE("Not support for invalid query");
+            return NOT_SUPPORT;
+        }
+
+        if (querySyncObj.GetSortType() != SortType::NONE || querySyncObj.IsQueryByRange()) {
+            LOGE("Not support order by timestamp and query by range");
+            return NOT_SUPPORT;
+        }
+        PragmaSync pragmaData(option, querySyncObj, onSyncProcess);
+        errCode = conn_->Pragma(PRAGMA_SYNC_DEVICES, &pragmaData);
+    } else {
+        PragmaSync pragmaData(option, onSyncProcess);
+        errCode = conn_->Pragma(PRAGMA_SYNC_DEVICES, &pragmaData);
+    }
+
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] DeviceSync data failed:%d", errCode);
+        return TransferDBErrno(errCode);
+    }
+    return OK;
+}
+
+DBStatus KvStoreNbDelegateImpl::CancelSync(uint32_t syncId)
+{
+    if (conn_ == nullptr) {
+        LOGE("%s", INVALID_CONNECTION);
+        return DB_ERROR;
+    }
+    uint32_t tempSyncId = syncId;
+    int errCode = conn_->Pragma(PRAGMA_CANCEL_SYNC_DEVICES, &tempSyncId);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] CancelSync failed:%d", errCode);
+        return TransferDBErrno(errCode);
+    }
+    return OK;
+}
+
 DBStatus KvStoreNbDelegateImpl::Pragma(PragmaCmd cmd, PragmaData &paramData)
 {
     if (conn_ == nullptr) {
@@ -619,9 +688,8 @@ DBStatus KvStoreNbDelegateImpl::Pragma(PragmaCmd cmd, PragmaData &paramData)
 
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Pragma failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 DBStatus KvStoreNbDelegateImpl::SetConflictNotifier(int conflictType, const KvStoreNbConflictNotifier &notifier)
@@ -666,9 +734,8 @@ DBStatus KvStoreNbDelegateImpl::SetConflictNotifier(int conflictType, const KvSt
 END:
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Register conflict failed:%d!", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 DBStatus KvStoreNbDelegateImpl::Rekey(const CipherPassword &password)
@@ -762,9 +829,8 @@ DBStatus KvStoreNbDelegateImpl::StartTransaction()
     int errCode = conn_->StartTransaction();
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] StartTransaction failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 DBStatus KvStoreNbDelegateImpl::Commit()
@@ -777,9 +843,8 @@ DBStatus KvStoreNbDelegateImpl::Commit()
     int errCode = conn_->Commit();
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Commit failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 DBStatus KvStoreNbDelegateImpl::Rollback()
@@ -792,9 +857,8 @@ DBStatus KvStoreNbDelegateImpl::Rollback()
     int errCode = conn_->RollBack();
     if (errCode != E_OK) {
         LOGE("[KvStoreNbDelegate] Rollback failed:%d", errCode);
-        return TransferDBErrno(errCode);
     }
-    return OK;
+    return TransferDBErrno(errCode);
 }
 
 void KvStoreNbDelegateImpl::SetReleaseFlag(bool flag)
@@ -862,7 +926,7 @@ DBStatus KvStoreNbDelegateImpl::GetInner(const IOption &option, const Key &key,
     }
 
     if (errCode != -E_NOT_FOUND) {
-        LOGW("[KvStoreNbDelegate] [%s] Get the data failed:%d", storeId_.c_str(), errCode);
+        LOGE("[KvStoreNbDelegate] [%s] Get the data failed:%d", storeId_.c_str(), errCode);
     }
     return TransferDBErrno(errCode);
 }
@@ -879,7 +943,7 @@ DBStatus KvStoreNbDelegateImpl::GetEntriesInner(const IOption &option,
     if (errCode == E_OK) {
         return OK;
     }
-    LOGW("[KvStoreNbDelegate] Get the batch data failed:%d", errCode);
+    LOGE("[KvStoreNbDelegate] Get the batch data failed:%d", errCode);
     return TransferDBErrno(errCode);
 }
 
@@ -983,7 +1047,7 @@ DBStatus KvStoreNbDelegateImpl::SubscribeRemoteQuery(const std::vector<std::stri
         return NOT_SUPPORT;
     }
     PragmaSync pragmaData(devices, SyncModeType::SUBSCRIBE_QUERY, querySyncObj,
-        std::bind(&KvStoreNbDelegateImpl::OnSyncComplete, this, std::placeholders::_1, onComplete), wait);
+        [this, onComplete](const std::map<std::string, int> &statuses) { OnSyncComplete(statuses, onComplete); }, wait);
     int errCode = conn_->Pragma(PRAGMA_SUBSCRIBE_QUERY, &pragmaData);
     if (errCode < E_OK) {
         LOGE("[KvStoreNbDelegate] Subscribe remote data with query failed:%d", errCode);
@@ -1007,7 +1071,7 @@ DBStatus KvStoreNbDelegateImpl::UnSubscribeRemoteQuery(const std::vector<std::st
         return NOT_SUPPORT;
     }
     PragmaSync pragmaData(devices, SyncModeType::UNSUBSCRIBE_QUERY, querySyncObj,
-        std::bind(&KvStoreNbDelegateImpl::OnSyncComplete, this, std::placeholders::_1, onComplete), wait);
+        [this, onComplete](const std::map<std::string, int> &statuses) { OnSyncComplete(statuses, onComplete); }, wait);
     int errCode = conn_->Pragma(PRAGMA_SUBSCRIBE_QUERY, &pragmaData);
     if (errCode < E_OK) {
         LOGE("[KvStoreNbDelegate] Unsubscribe remote data with query failed:%d", errCode);
@@ -1044,7 +1108,7 @@ DBStatus KvStoreNbDelegateImpl::GetKeys(const Key &keyPrefix, std::vector<Key> &
     if (errCode == E_OK) {
         return OK;
     }
-    LOGW("[KvStoreNbDelegate] Get the keys failed:%d", errCode);
+    LOGE("[KvStoreNbDelegate] Get the keys failed:%d", errCode);
     return TransferDBErrno(errCode);
 }
 
@@ -1082,7 +1146,7 @@ DBStatus KvStoreNbDelegateImpl::UpdateKey(const UpdateKeyCallback &callback)
         LOGI("[KvStoreNbDelegate] update keys success");
         return OK;
     }
-    LOGW("[KvStoreNbDelegate] update keys failed:%d", errCode);
+    LOGE("[KvStoreNbDelegate] update keys failed:%d", errCode);
     return TransferDBErrno(errCode);
 }
 
@@ -1125,7 +1189,7 @@ DBStatus KvStoreNbDelegateImpl::SetCloudDB(const std::map<std::string, std::shar
         return DB_ERROR;
     }
     if (cloudDBs.empty()) {
-        LOGE("[KvStoreNbDelegateImpl] no cloud db");
+        LOGE("[KvStoreNbDelegate] no cloud db");
         return INVALID_ARGS;
     }
     return TransferDBErrno(conn_->SetCloudDB(cloudDBs));
@@ -1146,11 +1210,11 @@ DBStatus KvStoreNbDelegateImpl::RemoveDeviceData(const std::string &device, Clea
         LOGE("%s", INVALID_CONNECTION);
         return DB_ERROR;
     }
-    if (mode == ClearMode::DEFAULT) {
-        return device.empty() ? RemoveDeviceData() : RemoveDeviceData(device);
-    }
     int errCode = conn_->RemoveDeviceData(device, mode);
-    LOGI("[KvStoreNbDelegateImpl] remove device data res %d", errCode);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] remove device data res %d", errCode);
+    }
+    LOGI("[KvStoreNbDelegate] remove device data res");
     return TransferDBErrno(errCode);
 }
 
@@ -1161,15 +1225,15 @@ DBStatus KvStoreNbDelegateImpl::RemoveDeviceData(const std::string &device, cons
         LOGE("%s", INVALID_CONNECTION);
         return DB_ERROR;
     }
-    if (mode == ClearMode::DEFAULT) {
-        return device.empty() ? RemoveDeviceData() : RemoveDeviceData(device);
-    }
-    if (user.empty()) {
-        LOGE("[KvStoreNbDelegateImpl] remove device data with empty user!");
+    if (user.empty() && mode != ClearMode::DEFAULT) {
+        LOGE("[KvStoreNbDelegate] remove device data with empty user!");
         return INVALID_ARGS;
     }
     int errCode = conn_->RemoveDeviceData(device, user, mode);
-    LOGI("[KvStoreNbDelegateImpl] remove device data with user res %d", errCode);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] remove device data with user res %d", errCode);
+    }
+    LOGI("[KvStoreNbDelegate] remove device data with user res");
     return TransferDBErrno(errCode);
 }
 
@@ -1211,7 +1275,7 @@ std::pair<DBStatus, std::map<std::string, std::string>> KvStoreNbDelegateImpl::G
     } else {
         LOGE("[KvStoreNbDelegate] get cloudVersion failed:%d", errCode);
     }
-    if (res.second.empty()) {
+    if (errCode == E_OK && res.second.empty()) {
         errCode = -E_NOT_FOUND;
     }
     res.first = TransferDBErrno(errCode);
@@ -1225,7 +1289,10 @@ DBStatus KvStoreNbDelegateImpl::SetReceiveDataInterceptor(const DataInterceptor
         return DB_ERROR;
     }
     int errCode = conn_->SetReceiveDataInterceptor(interceptor);
-    LOGI("[KvStoreNbDelegate] Set receive data interceptor errCode:%d", errCode);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] Set receive data interceptor errCode:%d", errCode);
+    }
+    LOGI("[KvStoreNbDelegate] Set receive data interceptor");
     return TransferDBErrno(errCode);
 }
 
@@ -1239,7 +1306,10 @@ DBStatus KvStoreNbDelegateImpl::SetCloudSyncConfig(const CloudSyncConfig &config
         return INVALID_ARGS;
     }
     int errCode = conn_->SetCloudSyncConfig(config);
-    LOGI("[KvStoreNbDelegate] Set cloud sync config errCode:%d", errCode);
+    if (errCode != E_OK) {
+        LOGE("[KvStoreNbDelegate] Set cloud sync config errCode:%d", errCode);
+    }
+    LOGI("[KvStoreNbDelegate] Set cloud sync config");
     return TransferDBErrno(errCode);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
index 4f46f85cb25076c510b6488e85323c80cc2bd829..6bf1c508efd59964a24d16ea4af24698f3bf665d 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/kv_store_nb_delegate_impl.h
@@ -132,6 +132,12 @@ public:
         const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete,
         const Query &query, bool wait) override;
 
+    // Sync with devices, provides sync count information
+    DBStatus Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess) override;
+
+    // Cancel sync by syncId
+    DBStatus CancelSync(uint32_t syncId) override;
+
     DBStatus CheckIntegrity() const override;
 
     // Set an equal identifier for this database, After this called, send msg to the target will use this identifier
@@ -190,6 +196,9 @@ private:
 
     void OnSyncComplete(const std::map<std::string, int> &statuses,
         const std::function<void(const std::map<std::string, DBStatus> &devicesMap)> &onComplete) const;
+    
+    void OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &processMap,
+        const DeviceSyncProcessCallback &onProcess) const;
 
     DBStatus RegisterDeviceObserver(const Key &key, unsigned int mode, KvStoreObserver *observer);
 
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
index cbb0da6a3547c57033dfc548556adfa94fd71efc..fcb68b7ec38e9e805066028baa66ee5c42ab9e4d 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.cpp
@@ -119,7 +119,9 @@ DBStatus RelationalStoreDelegateImpl::Sync(const std::vector<std::string> &devic
         return NOT_SUPPORT;
     }
     RelationalStoreConnection::SyncInfo syncInfo{devices, mode,
-        std::bind(&RelationalStoreDelegateImpl::OnSyncComplete, std::placeholders::_1, onComplete), query, wait};
+        [this, onComplete](const std::map<std::string, std::vector<TableStatus>> &devicesStatus) {
+            OnSyncComplete(devicesStatus, onComplete);
+        }, query, wait};
     int errCode = conn_->SyncToDevice(syncInfo);
     if (errCode != E_OK) {
         LOGW("[RelationalStore Delegate] sync data to device failed:%d", errCode);
@@ -226,20 +228,12 @@ DBStatus RelationalStoreDelegateImpl::RemoveDeviceData()
 DBStatus RelationalStoreDelegateImpl::Sync(const std::vector<std::string> &devices, SyncMode mode, const Query &query,
     const SyncProcessCallback &onProcess, int64_t waitTime)
 {
-    if (conn_ == nullptr) {
-        return DB_ERROR;
-    }
     CloudSyncOption option;
     option.devices = devices;
     option.mode = mode;
     option.query = query;
     option.waitTime = waitTime;
-    int errCode = conn_->Sync(option, onProcess);
-    if (errCode != E_OK) {
-        LOGW("[RelationalStore Delegate] cloud sync failed:%d", errCode);
-        return TransferDBErrno(errCode);
-    }
-    return OK;
+    return Sync(option, onProcess);
 }
 
 DBStatus RelationalStoreDelegateImpl::SetCloudDB(const std::shared_ptr<ICloudDb> &cloudDb)
@@ -330,15 +324,8 @@ DBStatus RelationalStoreDelegateImpl::UnRegisterObserver(StoreObserver *observer
 
 DBStatus RelationalStoreDelegateImpl::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess)
 {
-    if (conn_ == nullptr) {
-        return DB_ERROR;
-    }
-    int errCode = conn_->Sync(option, onProcess);
-    if (errCode != E_OK) {
-        LOGE("[RelationalStore Delegate] cloud sync failed:%d", errCode);
-        return TransferDBErrno(errCode);
-    }
-    return OK;
+    uint64_t taskId = 0;
+    return Sync(option, onProcess, taskId);
 }
 
 DBStatus RelationalStoreDelegateImpl::SetTrackerTable(const TrackerSchema &schema)
@@ -469,5 +456,31 @@ DBStatus RelationalStoreDelegateImpl::SetCloudSyncConfig(const CloudSyncConfig &
     LOGI("[RelationalStore Delegate] SetCloudSyncConfig success");
     return OK;
 }
+
+DBStatus RelationalStoreDelegateImpl::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess,
+    uint64_t taskId)
+{
+    if (conn_ == nullptr) {
+        LOGE("[RelationalStore Delegate] Invalid connection for sync!");
+        return DB_ERROR;
+    }
+    int errCode = conn_->Sync(option, onProcess, taskId);
+    if (errCode != E_OK) {
+        LOGE("[RelationalStore Delegate] Cloud sync failed:%d", errCode);
+        return TransferDBErrno(errCode);
+    }
+    return OK;
+}
+
+SyncProcess RelationalStoreDelegateImpl::GetCloudTaskStatus(uint64_t taskId)
+{
+    SyncProcess syncProcess;
+    if (conn_ == nullptr) {
+        LOGE("[RelationalStore Delegate] Invalid connection for getting cloud task status!");
+        syncProcess.errCode = DB_ERROR;
+        return syncProcess;
+    }
+    return conn_->GetCloudTaskStatus(taskId);
+}
 } // namespace DistributedDB
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.h b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.h
index 173defd3d5578c920ade050adb16d22518a10665..00d648dfceaac9f886466110f047a17a9f588b8d 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_delegate_impl.h
@@ -81,6 +81,10 @@ public:
         RecordStatus status) override;
 
     DBStatus SetCloudSyncConfig(const CloudSyncConfig &config) override;
+
+    DBStatus Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess, uint64_t taskId) override;
+
+    SyncProcess GetCloudTaskStatus(uint64_t taskId) override;
 private:
     static void OnSyncComplete(const std::map<std::string, std::vector<TableStatus>> &devicesStatus,
         const SyncStatusCallback &onComplete);
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_instance.h b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_instance.h
index ac94a227a231a0c121fcba750471213d08e1c8d8..34b171b72b7de16ef13dbecbdf744152d35581a3 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_instance.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_instance.h
@@ -28,13 +28,15 @@ public:
     RelationalStoreInstance();
     ~RelationalStoreInstance() = default;
 
-    static RelationalStoreConnection *GetDatabaseConnection(const RelationalDBProperties &properties, int &errCode);
+    static RelationalStoreConnection *GetDatabaseConnection(const RelationalDBProperties &properties, int &errCode,
+        bool isNeedIfOpened = true);
     static RelationalStoreInstance *GetInstance();
 
     static int ReleaseDataBaseConnection(RelationalStoreConnection *connection);
 
     // public for test mock
-    static IRelationalStore *GetDataBase(const RelationalDBProperties &properties, int &errCode);
+    static IRelationalStore *GetDataBase(const RelationalDBProperties &properties, int &errCode,
+        bool isNeedIfOpened = true);
 
     void Dump(int fd);
 private:
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
index c44882b43fa4c83ce8c1b2d60d9931e22b60fe94..30703ce8ec0c498006c6409b3c6ddda4c8eceb3e 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_manager.cpp
@@ -82,7 +82,7 @@ bool RelationalStoreManager::PreCheckOpenStore(const std::string &path, const st
         return false;
     }
 
-    if (!ParamCheckUtils::CheckStoreParameter(storeId, appId_, userId_, false, subUser_) || path.empty()) {
+    if (!ParamCheckUtils::CheckStoreParameter({userId_, appId_, storeId}, false, subUser_, true) || path.empty()) {
         return false;
     }
 
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_sqlite_ext.cpp b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_sqlite_ext.cpp
index 6439f897eefb068aa1dff5d060b328cfb189a689..dd965239ad9ee0bc0f375806858d939007623fe3 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_sqlite_ext.cpp
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_store_sqlite_ext.cpp
@@ -58,7 +58,6 @@
 
 #ifdef DB_DEBUG_ENV
 #include "system_time.h"
-#include "cloud/cloud_db_constant.h"
 
 using namespace DistributedDB::OS;
 #endif
@@ -148,11 +147,23 @@ public:
 
     static int GetSysCurrentRawTime(uint64_t &curTime)
     {
+        static uint64_t lastCurTime = 0u;
         int errCode = GetCurrentSysTimeInMicrosecond(curTime);
         if (errCode != E_OK) {
             return errCode;
         }
         curTime *= TO_100_NS;
+
+        std::lock_guard<std::mutex> lock(systemTimeLock_);
+        int64_t timeDiff = static_cast<int64_t>(curTime) - static_cast<int64_t>(lastCurTime);
+        if (std::abs(timeDiff) > 1000u) { // 1000 is us
+            lastCurTime = curTime;
+            return E_OK;
+        }
+        if (curTime <= lastCurTime) {
+            curTime = lastCurTime + 1;
+        }
+        lastCurTime = curTime;
         return E_OK;
     }
 
@@ -222,7 +233,7 @@ public:
             Timestamp currentLocalTime = currentSysTime + timeOffset + localTimeOffset;
             auto virtualTimeOffset = static_cast<int64_t>(currentLocalTime - lastLocalTime_);
             auto changedOffset = static_cast<int64_t>(virtualTimeOffset - monotonicTimeOffset * TO_100_NS);
-            if (std::abs(changedOffset) > static_cast<int64_t>(MAX_NOISE * TO_100_NS)) {
+            if (std::abs(changedOffset) > static_cast<int64_t>(MAX_NOISE * TO_100_NS)) { // LCOV_EXCL_BR_LINE
                 // localTimeOffset was not flushed, use temporary calculated value
                 localTimeOffset_ = static_cast<Timestamp>(static_cast<int64_t>(localTimeOffset_) -
                     (systemTimeOffset - monotonicTimeOffset) * static_cast<int64_t>(TO_100_NS));
@@ -256,7 +267,7 @@ public:
         // If GetSysCurrentTime in 1us, we need increase the currentIncCount_
         if (curTime == lastSystemTimeUs_) {
             // if the currentIncCount_ has been increased MAX_INC_COUNT, keep the currentIncCount_
-            if (currentIncCount_ < MAX_INC_COUNT) {
+            if (currentIncCount_ < MAX_INC_COUNT) { // LCOV_EXCL_BR_LINE
                 currentIncCount_++;
             }
         } else {
@@ -469,7 +480,7 @@ void CalcHashKey(sqlite3_context *ctx, int argc, sqlite3_value **argv)
             errCode = CalcValueHash(value, hashValue);
     }
 
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != E_OK) {
         sqlite3_result_error(ctx, "Get hash value error.", -1);
         return;
     }
@@ -571,7 +582,7 @@ void GetRawSysTime(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 
     uint64_t curTime = 0;
     int errCode = TimeHelper::GetSysCurrentRawTime(curTime);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != E_OK) {
         sqlite3_result_error(ctx, "get raw sys time failed.", errCode);
         return;
     }
@@ -627,9 +638,10 @@ static bool GetDbHashString(sqlite3 *db, std::string &hashFileName)
 {
     std::string fileName;
     if (!GetDbFileName(db, fileName)) {
+        LOGE("Get db fileName failed.");
         return false;
     }
-    return GetHashString(fileName, hashFileName) == DistributedDB::DBStatus::OK;
+    return GetHashString(fileName, hashFileName) == E_OK;
 }
 
 void CloudDataChangedObserver(sqlite3_context *ctx, int argc, sqlite3_value **argv)
@@ -782,7 +794,7 @@ std::string GetInsertTrigger(const std::string &tableName, bool isRowid, const s
     insertTrigger += "naturalbase_rdb_" + tableName + "_local_ON_INSERT AFTER INSERT\n";
     insertTrigger += "ON '" + tableName + "'\n";
     insertTrigger += "BEGIN\n";
-    if (isRowid || primaryKey.empty()) {
+    if (isRowid || primaryKey.empty()) { // LCOV_EXCL_BR_LINE
         insertTrigger += "SELECT data_change('" + tableName + "', 'rowid', NEW._rowid_, 0);\n";
     } else {
         insertTrigger += "SELECT data_change('" + tableName + "', ";
@@ -799,8 +811,8 @@ std::string GetUpdateTrigger(const std::string &tableName, bool isRowid, const s
     updateTrigger += "naturalbase_rdb_" + tableName + "_local_ON_UPDATE AFTER UPDATE\n";
     updateTrigger += "ON '" + tableName + "'\n";
     updateTrigger += "BEGIN\n";
-    if (isRowid || primaryKey.empty()) {
-        updateTrigger += "SELECT data_change('" + tableName + "', 'rowid', NEW._rowid_, 2);\n";
+    if (isRowid || primaryKey.empty()) { // LCOV_EXCL_BR_LINE
+        updateTrigger += "SELECT data_change('" + tableName + "', 'rowid', NEW._rowid_, 1);\n";
     } else {
         updateTrigger += "SELECT data_change('" + tableName + "', ";
         updateTrigger += "(SELECT name as a FROM pragma_table_info('" + tableName + "') WHERE pk=1), ";
@@ -816,7 +828,7 @@ std::string GetDeleteTrigger(const std::string &tableName, bool isRowid, const s
     deleteTrigger += "naturalbase_rdb_" + tableName + "_local_ON_DELETE AFTER DELETE\n";
     deleteTrigger += "ON '" + tableName + "'\n";
     deleteTrigger += "BEGIN\n";
-    if (isRowid || primaryKey.empty()) {
+    if (isRowid || primaryKey.empty()) { // LCOV_EXCL_BR_LINE
         deleteTrigger += "SELECT data_change('" + tableName + "', 'rowid', OLD._rowid_, 2);\n";
     } else {
         deleteTrigger += "SELECT data_change('" + tableName + "', ";
@@ -843,6 +855,7 @@ int GetPrimaryKeyName(sqlite3 *db, const std::string &tableName, std::string &pr
     while ((errCode = StepWithRetry(stmt)) != SQLITE_DONE) {
         if (errCode != SQLITE_ROW) {
             ResetStatement(stmt);
+            LOGE("Get primary key name step statement failed.");
             return -E_ERROR;
         }
         GetColumnTextValue(stmt, 0, primaryKey);
@@ -909,7 +922,7 @@ void ClientObserverCallback(const std::string &hashFileName)
     }
 }
 
-void TriggerObserver(std::vector<std::shared_ptr<StoreObserver>> &storeObservers, const std::string &hashFileName)
+void TriggerObserver(const std::vector<std::shared_ptr<StoreObserver>> &storeObservers, const std::string &hashFileName)
 {
     std::lock_guard<std::mutex> storeChangedDataLock(g_storeChangedDataMutex);
     for (const auto &storeObserver : storeObservers) {
@@ -952,6 +965,7 @@ void StoreObserverCallback(sqlite3 *db, const std::string &hashFileName)
     std::vector<std::string> triggerSqls;
     int errCode = GetTriggerSqls(db, tableInfos, triggerSqls);
     if (errCode != E_OK) {
+        LOGE("Get data change trigger sql failed %d", errCode);
         return;
     }
     for (const auto &sql : triggerSqls) {
@@ -972,7 +986,7 @@ int LogCommitHookCallback(void *data, sqlite3 *db, const char *zDb, int size)
     }
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != E_OK) {
         return 0;
     }
     ClientObserverCallback(hashFileName);
@@ -989,7 +1003,7 @@ void RollbackHookCallback(void* data)
     }
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != E_OK) {
         return;
     }
     std::lock_guard<std::mutex> clientChangedDataLock(g_clientChangedDataMutex);
@@ -1043,7 +1057,7 @@ void RegisterCommitAndRollbackHook(sqlite3 *db)
 
 int ResetStatement(sqlite3_stmt *&stmt)
 {
-    if (stmt == nullptr || sqlite3_finalize(stmt) != SQLITE_OK) {
+    if (stmt == nullptr || sqlite3_finalize(stmt) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         return -E_ERROR;
     }
     stmt = nullptr;
@@ -1093,7 +1107,7 @@ int StepWithRetry(sqlite3_stmt *stmt)
 
 int BindBlobToStatement(sqlite3_stmt *stmt, int index, const std::vector<uint8_t> &value, bool permEmpty)
 {
-    if (stmt == nullptr || (value.empty() && !permEmpty)) {
+    if (stmt == nullptr || (value.empty() && !permEmpty)) { // LCOV_EXCL_BR_LINE
         return -E_ERROR;
     }
     int errCode;
@@ -1187,13 +1201,13 @@ bool CheckTableExists(sqlite3 *db, const std::string &tableName)
 {
     sqlite3_stmt *stmt = nullptr;
     std::string sql = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='" + tableName + "';";
-    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
+    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_finalize(stmt);
         return false;
     }
 
     bool isLogTblExists = false;
-    if (sqlite3_step(stmt) == SQLITE_ROW && static_cast<bool>(sqlite3_column_int(stmt, 0))) {
+    if (sqlite3_step(stmt) == SQLITE_ROW && static_cast<bool>(sqlite3_column_int(stmt, 0))) { // LCOV_EXCL_BR_LINE
         isLogTblExists = true;
     }
     (void)sqlite3_finalize(stmt);
@@ -1207,19 +1221,19 @@ int GetTableSyncType(sqlite3 *db, const std::string &tableName, std::string &tab
     int errCode = sqlite3_prepare_v2(db, selectSql, -1, &statement, nullptr);
     if (errCode != SQLITE_OK) {
         (void)sqlite3_finalize(statement);
-        return DistributedDB::DBStatus::DB_ERROR;
+        return -E_ERROR;
     }
 
     std::string keyStr = SYNC_TABLE_TYPE + tableName;
     std::vector<uint8_t> key(keyStr.begin(), keyStr.end());
     if (sqlite3_bind_blob(statement, 1, static_cast<const void *>(key.data()), key.size(),
-        SQLITE_TRANSIENT) != SQLITE_OK) {
+        SQLITE_TRANSIENT) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         return -E_ERROR;
     }
 
     if (sqlite3_step(statement) == SQLITE_ROW) {
         std::vector<uint8_t> value;
-        if (GetColumnBlobValue(statement, 0, value) == DistributedDB::DBStatus::OK) {
+        if (GetColumnBlobValue(statement, 0, value) == E_OK) {
             tableType.assign(value.begin(), value.end());
             (void)sqlite3_finalize(statement);
             return E_OK;
@@ -1252,7 +1266,7 @@ void HandleDropCloudSyncTable(sqlite3 *db, const std::string &tableName)
     }
 
     if (sqlite3_bind_blob(statement, 1, static_cast<const void *>(key.data()), key.size(),
-        SQLITE_TRANSIENT) != SQLITE_OK) {
+        SQLITE_TRANSIENT) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_finalize(statement);
         return;
     }
@@ -1284,6 +1298,7 @@ int HandleDropLogicDeleteData(sqlite3 *db, const std::string &tableName, uint64_
         return errCode;
     }
     sql = "UPDATE " + logTblName + " SET data_key = -1, flag = (flag & ~0x08) | 0x01";
+    // sharing_resource is added after VERSION_5_3, this one is for compatibility
     if (logTableVersion >= DBConstant::LOG_TABLE_VERSION_5_3) {
         sql += ", sharing_resource = ''";
     }
@@ -1318,13 +1333,13 @@ int SaveDeleteFlagToDB(sqlite3 *db, const std::string &tableName)
     }
 
     if (sqlite3_bind_blob(statement, 1, static_cast<const void *>(key.data()), key.size(),
-        SQLITE_TRANSIENT) != SQLITE_OK) {
+        SQLITE_TRANSIENT) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_finalize(statement);
         LOGE("[SaveDeleteFlagToDB] bind key failed, %d", errCode);
         return -E_ERROR;
     }
     if (sqlite3_bind_blob(statement, 2, static_cast<const void *>(value.data()), value.size(), // 2 is column index
-        SQLITE_TRANSIENT) != SQLITE_OK) {
+        SQLITE_TRANSIENT) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_finalize(statement);
         LOGE("[SaveDeleteFlagToDB] bind value failed, %d", errCode);
         return -E_ERROR;
@@ -1358,7 +1373,7 @@ void ClearTheLogAfterDropTable(sqlite3 *db, const char *tableName, const char *s
             LOGW("[ClearTheLogAfterDropTable] save delete flag failed.");
         }
         std::string tableType = DEVICE_TYPE;
-        if (GetTableSyncType(db, tableStr, tableType) != DistributedDB::DBStatus::OK) {
+        if (GetTableSyncType(db, tableStr, tableType) != E_OK) {
             return;
         }
         if (tableType == DEVICE_TYPE) {
@@ -1377,13 +1392,12 @@ bool CheckUnLockingDataExists(sqlite3 *db, const std::string &tableName)
 {
     sqlite3_stmt *stmt = nullptr;
     std::string sql = "SELECT count(1) FROM " + tableName + " WHERE status=1";
-    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
-        (void)sqlite3_finalize(stmt);
+    if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         return false;
     }
 
     bool isExists = false;
-    if ((sqlite3_step(stmt) == SQLITE_ROW) && (sqlite3_column_int(stmt, 0) > 0)) {
+    if ((sqlite3_step(stmt) == SQLITE_ROW) && (sqlite3_column_int(stmt, 0) > 0)) { // LCOV_EXCL_BR_LINE
         isExists = true;
     }
     (void)sqlite3_finalize(stmt);
@@ -1501,7 +1515,7 @@ int GetTableInfos(sqlite3 *db, std::map<std::string, bool> &tableInfos)
     if (db == nullptr) {
         return -E_ERROR;
     }
-    std::string sql = "SELECT name FROM main.sqlite_master where type = 'table'";
+    std::string sql = "SELECT name FROM main.sqlite_master WHERE type = 'table'";
     sqlite3_stmt *stmt = nullptr;
     int errCode = GetStatement(db, sql, stmt);
     if (errCode != E_OK) {
@@ -1567,7 +1581,7 @@ SQLITE_API int sqlite3_open16_relational(const void *filename, sqlite3 **ppDb)
 {
     bool isExists = (access(static_cast<const char *>(filename), 0) == 0);
     int err = sqlite3_open16(filename, ppDb);
-    if (err != SQLITE_OK) {
+    if (err != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         return err;
     }
     PostHandle(isExists, *ppDb);
@@ -1594,7 +1608,7 @@ DB_API DistributedDB::DBStatus RegisterClientObserver(sqlite3 *db, const ClientO
 
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         return DistributedDB::DB_ERROR;
     }
 
@@ -1612,7 +1626,7 @@ DB_API DistributedDB::DBStatus UnRegisterClientObserver(sqlite3 *db)
 
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         return DistributedDB::DB_ERROR;
     }
 
@@ -1639,13 +1653,13 @@ DB_API DistributedDB::DBStatus RegisterStoreObserver(sqlite3 *db, const std::sha
 
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         LOGE("[RegisterStoreObserver] Get db filename hash string failed.");
         return DistributedDB::DB_ERROR;
     }
 
     errCode = CreateTempTrigger(db);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         LOGE("[RegisterStoreObserver] Create trigger failed.");
         return DistributedDB::DB_ERROR;
     }
@@ -1675,7 +1689,7 @@ DB_API DistributedDB::DBStatus UnregisterStoreObserver(sqlite3 *db, const std::s
 
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         LOGE("[UnregisterStoreObserver] Get db filename hash string failed.");
         return DistributedDB::DB_ERROR;
     }
@@ -1702,7 +1716,7 @@ DB_API DistributedDB::DBStatus UnregisterStoreObserver(sqlite3 *db)
 
     std::string hashFileName;
     int errCode = GetHashString(fileName, hashFileName);
-    if (errCode != DistributedDB::DBStatus::OK) {
+    if (errCode != DistributedDB::E_OK) {
         LOGE("[UnregisterAllStoreObserver] Get db filename hash string failed.");
         return DistributedDB::DB_ERROR;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
index 154a9cb9a1cf1288533b7d9a72ee0d2bac13339c..5f95ec4bf431f9d065eb2090ff0587bf37b80cc7 100644
--- a/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
+++ b/kv_store/frameworks/libs/distributeddb/interfaces/src/relational/relational_sync_able_storage.h
@@ -16,11 +16,12 @@
 #define RELATIONAL_SYNC_ABLE_STORAGE_H
 #ifdef RELATIONAL_STORE
 
-#include "lru_map.h"
+#include "cloud/cloud_upload_recorder.h"
+#include "cloud/schema_mgr.h"
 #include "icloud_sync_storage_interface.h"
+#include "lru_map.h"
 #include "relational_db_sync_interface.h"
 #include "relationaldb_properties.h"
-#include "cloud/schema_mgr.h"
 #include "sqlite_single_relational_storage_engine.h"
 #include "sqlite_single_ver_relational_continue_token.h"
 #include "sync_able_engine.h"
@@ -155,6 +156,8 @@ public:
 
     int ReleaseCloudDataToken(ContinueToken &continueStmtToken) override;
 
+    int GetSchemaFromDB(RelationalSchemaObject &schema) override;
+
     int ChkSchema(const TableName &tableName) override;
 
     int SetCloudDbSchema(const DataBaseSchema &schema) override;
@@ -212,19 +215,17 @@ public:
     int MarkFlagAsConsistent(const std::string &tableName, const DownloadData &downloadData,
         const std::set<std::string> &gidFilters) override;
 
-    void SyncFinishHook() override;
-
-    void SetSyncFinishHook(const std::function<void (void)> &func) override;
-
-    void SetDoUploadHook(const std::function<void (void)> &) override;
-
-    void DoUploadHook() override;
-
     CloudSyncConfig GetCloudSyncConfig() const override;
 
     void SetCloudSyncConfig(const CloudSyncConfig &config);
 
     bool IsTableExistReference(const std::string &table) override;
+
+    bool IsTableExistReferenceOrReferenceBy(const std::string &table) override;
+
+    void ReleaseUploadRecord(const std::string &tableName, const CloudWaterType &type, Timestamp localMark) override;
+
+    bool IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo) override;
 protected:
     int FillReferenceData(CloudSyncData &syncData);
 
@@ -241,7 +242,7 @@ protected:
         const CloudSyncData &data, bool fillAsset, bool ignoreEmptyGid);
 
     int UpdateRecordFlagAfterUpload(SQLiteSingleVerRelationalStorageExecutor *handle, const std::string &tableName,
-        const CloudSyncBatch &updateData, bool isLock = false);
+        const CloudSyncBatch &updateData, const CloudWaterType &type, bool isLock = false);
 
     static int FillReferenceDataIntoExtend(const std::vector<int64_t> &rowid,
         const std::map<int64_t, Entries> &referenceGid, std::vector<VBucket> &extend);
@@ -284,9 +285,6 @@ private:
     int GetCompensatedSyncQueryInner(SQLiteSingleVerRelationalStorageExecutor *handle,
         const std::vector<TableSchema> &tables, std::vector<QuerySyncObject> &syncQuery);
 
-    int GetSyncQueryByPk(const std::string &tableName, const std::vector<VBucket> &data,
-        QuerySyncObject &querySyncObject);
-
     int CreateTempSyncTriggerInner(SQLiteSingleVerRelationalStorageExecutor *handle, const std::string &tableName);
 
     bool CheckTableSupportCompensatedSync(const TableSchema &table);
@@ -327,6 +325,8 @@ private:
 
     mutable std::mutex configMutex_;
     CloudSyncConfig cloudSyncConfig_;
+
+    CloudUploadRecorder uploadRecorder_;
 };
 }  // namespace DistributedDB
 #endif
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h b/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h
index abf5d1683f35f6fa91a542fd6c170dfbe1a3377f..c84a8b9b481e9905b34edfd96cdfe65122d01dc9 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_storage_utils.h
@@ -18,6 +18,7 @@
 
 #include "cloud/asset_operation_utils.h"
 #include "cloud/cloud_store_types.h"
+#include "cloud/cloud_upload_recorder.h"
 #include "icloud_sync_storage_interface.h"
 #include "sqlite_utils.h"
 
@@ -101,6 +102,10 @@ public:
     static std::string GetDeleteLockChangedSql();
     static void AddUpdateColForShare(const TableSchema &tableSchema, std::string &updateLogSql,
         std::vector<std::string> &updateColName);
+    static std::string GetSelectIncCursorSql(const std::string &tableName);
+    static std::string GetCursorIncSql(const std::string &tableName);
+    static std::string GetCursorUpgradeSql(const std::string &tableName);
+    static std::string GetUpdateUploadFinishedSql(const std::string &tableName);
 
     static bool IsSharedTable(const TableSchema &tableSchema);
     static bool ChkFillCloudAssetParam(const CloudSyncBatch &data, int errCode);
@@ -110,7 +115,7 @@ public:
         const TableSchema &tableSchema, const TableInfo &localTable, const std::map<std::string, Field> &pkMap,
         bool allowEmpty);
     static std::string GetUpdateRecordFlagSql(const std::string &tableName, bool recordConflict,
-        const LogInfo &logInfo);
+        const LogInfo &logInfo, const VBucket &uploadExtend = {}, const CloudWaterType &type = CloudWaterType::BUTT);
     static int BindStepConsistentFlagStmt(sqlite3_stmt *stmt, const VBucket &data,
         const std::set<std::string> &gidFilters);
     static bool IsCloudGidMismatch(const std::string &downloadGid, const std::string &curGid);
@@ -163,7 +168,8 @@ public:
 
     static bool IsGetCloudDataContinue(uint32_t curNum, uint32_t curSize, uint32_t maxSize, uint32_t maxCount);
 
-    static int IdentifyCloudType(CloudSyncData &cloudSyncData, VBucket &data, VBucket &log, VBucket &flags);
+    static int IdentifyCloudType(const CloudUploadRecorder &recorder, CloudSyncData &cloudSyncData, VBucket &data,
+        VBucket &log, VBucket &flags);
 
     static bool IsAbnormalData(const VBucket &data);
 
@@ -182,6 +188,11 @@ public:
     static std::pair<int, DataItem> GetSystemRecordFromCloudData(VBucket &data);
 
     static bool IsSystemRecord(const Key &key);
+
+    static int GetSyncQueryByPk(const std::string &tableName, const std::vector<VBucket> &data, bool isKv,
+        QuerySyncObject &querySyncObject);
+private:
+    static int IdentifyCloudTypeInner(CloudSyncData &cloudSyncData, VBucket &data, VBucket &log, VBucket &flags);
 };
 }
 #endif // CLOUD_STORAGE_UTILS_H
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_upload_recorder.h b/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_upload_recorder.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3348b410023701b15f9c38fd419d7032aa79e0a
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/cloud/cloud_upload_recorder.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CLOUD_UPLOAD_RECORDER_H
+#define CLOUD_UPLOAD_RECORDER_H
+
+#include <map>
+#include <mutex>
+
+#include "cloud/cloud_db_types.h"
+#include "db_types.h"
+
+namespace DistributedDB {
+class CloudUploadRecorder {
+public:
+    void RecordUploadRecord(const std::string &table, const Bytes &hashKey, const CloudWaterType &type,
+        int64_t modifyTime);
+    bool IsIgnoreUploadRecord(const std::string &table, const Bytes &hashKey, const CloudWaterType &type,
+        int64_t modifyTime) const;
+    void ReleaseUploadRecord(const std::string &table, const CloudWaterType &type, Timestamp localWaterMark);
+    void SetUser(const std::string &user);
+
+    CloudUploadRecorder() = default;
+    ~CloudUploadRecorder() = default;
+private:
+    mutable std::mutex recordMutex_;
+    using TableUploadRecord = std::map<CloudWaterType, std::map<Bytes, int64_t>>;
+    using UserRecord = std::map<std::string, TableUploadRecord>;
+    std::map<std::string, UserRecord> uploadRecord_;
+    std::string currentUser_;
+};
+}
+
+#endif // CLOUD_UPLOAD_RECORDER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/db_properties.h b/kv_store/frameworks/libs/distributeddb/storage/include/db_properties.h
index 716343cbe9a1c74e3f4fcf8d9bde815699b1661b..aaf08ced60878610dfb14388f8c0c0b9e824e715 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/db_properties.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/db_properties.h
@@ -52,19 +52,20 @@ public:
     void SetIdentifier(const std::string &userId, const std::string &appId, const std::string &storeId,
         const std::string &subUser = "", int32_t instanceId = 0);
 
-    static const std::string CREATE_IF_NECESSARY;
-    static const std::string DATABASE_TYPE;
-    static const std::string DATA_DIR;
-    static const std::string USER_ID;
-    static const std::string APP_ID;
-    static const std::string STORE_ID;
-    static const std::string INSTANCE_ID;
-    static const std::string SUB_USER;
-    static const std::string IDENTIFIER_DATA;
-    static const std::string IDENTIFIER_DIR;
-    static const std::string DUAL_TUPLE_IDENTIFIER_DATA;
-    static const std::string SYNC_DUAL_TUPLE_MODE;
-    static const std::string AUTO_LAUNCH_ID;
+    static constexpr const char *CREATE_IF_NECESSARY = "createIfNecessary";
+    static constexpr const char *DATA_DIR = "dataDir";
+    static constexpr const char *USER_ID = "userId";
+    static constexpr const char *APP_ID = "appId";
+    static constexpr const char *STORE_ID = "storeId";
+    static constexpr const char *INSTANCE_ID = "instanceId";
+    static constexpr const char *SUB_USER = "subUser";
+    static constexpr const char *IDENTIFIER_DATA = "identifier";
+    static constexpr const char *IDENTIFIER_DIR = "identifierDir";
+    static constexpr const char *DUAL_TUPLE_IDENTIFIER_DATA = "dualTupleIdentifier";
+    static constexpr const char *SYNC_DUAL_TUPLE_MODE = "syncDualTuple";
+    static constexpr const char *AUTO_LAUNCH_ID = "autoLaunchID";
+
+    static constexpr const char *DATABASE_TYPE = "databaseType";
 
 protected:
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h b/kv_store/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h
index 3cfb71396d9a7d18a1d7e49f329886fd5e3e7375..72624574cabd59b259379fe19995d2dfd4294cae 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/icloud_sync_storage_interface.h
@@ -21,6 +21,7 @@
 #include "cloud/iAssetLoader.h"
 #include "data_transformer.h"
 #include "query_sync_object.h"
+#include "query_utils.h"
 #include "sqlite_utils.h"
 #include "store_observer.h"
 
@@ -57,21 +58,32 @@ public:
     ICloudSyncStorageHook() = default;
     virtual ~ICloudSyncStorageHook() = default;
 
-    virtual void SetSyncFinishHook(const std::function<void (void)> &)
+    virtual void SetSyncFinishHook(const std::function<void (void)> &func)
     {
+        syncFinishFunc_ = func;
     }
 
     virtual void SyncFinishHook()
     {
+        if (syncFinishFunc_) {
+            syncFinishFunc_();
+        }
     }
 
-    virtual void SetDoUploadHook(const std::function<void (void)> &)
+    virtual void SetDoUploadHook(const std::function<void (void)> &func)
     {
+        uploadStartFunc_ = func;
     }
 
     virtual void DoUploadHook()
     {
+        if (uploadStartFunc_) {
+            uploadStartFunc_();
+        }
     }
+protected:
+    std::function<void (void)> syncFinishFunc_;
+    std::function<void (void)> uploadStartFunc_;
 };
 
 class ICloudSyncStorageInterface : public ICloudSyncStorageHook {
@@ -201,6 +213,21 @@ public:
     {
         return false;
     }
+
+    virtual bool IsTableExistReferenceOrReferenceBy(const std::string &table)
+    {
+        return false;
+    }
+
+    virtual void ReleaseUploadRecord([[gnu::unused]] const std::string &tableName,
+        [[gnu::unused]] const CloudWaterType &type, Timestamp localMark)
+    {
+    }
+
+    virtual bool IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo)
+    {
+        return false;
+    }
 };
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/kvdb_pragma.h b/kv_store/frameworks/libs/distributeddb/storage/include/kvdb_pragma.h
index 649ae2c15a216ac2a6416dbf80c4629c14b1b482..922d819f24adf0d2ee46030878e348303ed4194f 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/kvdb_pragma.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/kvdb_pragma.h
@@ -51,6 +51,7 @@ enum : int {
     PRAGMA_SUBSCRIBE_QUERY,
     PRAGMA_SET_MAX_LOG_LIMIT,
     PRAGMA_EXEC_CHECKPOINT,
+    PRAGMA_CANCEL_SYNC_DEVICES,
 };
 
 struct PragmaSync {
@@ -78,12 +79,36 @@ struct PragmaSync {
     {
     }
 
+    PragmaSync(const DeviceSyncOption &option, const QuerySyncObject &query, const DeviceSyncProcessCallback &onProcess)
+        : devices_(option.devices),
+        mode_(option.mode),
+        wait_(option.isWait),
+        isQuerySync_(option.isQuery),
+        onSyncProcess_(onProcess)
+    {
+        if (!isQuerySync_) {
+            return;
+        }
+        query_ = query;
+    }
+
+    PragmaSync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess)
+        :devices_(option.devices),
+        mode_(option.mode),
+        wait_(option.isWait),
+        isQuerySync_(false),
+        query_(Query::Select()),
+        onSyncProcess_(onProcess)
+    {
+    }
+
     std::vector<std::string> devices_;
     int mode_;
     std::function<void(const std::map<std::string, int> &devicesMap)> onComplete_;
     bool wait_;
     bool isQuerySync_;
     QuerySyncObject query_;
+    DeviceSyncProcessCallback onSyncProcess_;
 };
 
 struct PragmaRemotePushNotify {
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/relational_db_sync_interface.h b/kv_store/frameworks/libs/distributeddb/storage/include/relational_db_sync_interface.h
index 8899fd281ddca8d2229051b390e36e7b91884f15..d135dbcb25d23bba7e21a3a87aa45239e0261483 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/relational_db_sync_interface.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/relational_db_sync_interface.h
@@ -51,6 +51,8 @@ public:
 
     virtual int SaveRemoteDeviceSchema(const std::string &deviceId, const std::string &remoteSchema, uint8_t type) = 0;
 
+    virtual int GetSchemaFromDB(RelationalSchemaObject &schema) = 0;
+
     virtual int GetRemoteDeviceSchema(const std::string &deviceId, RelationalSchemaObject &schemaObj) = 0;
 
     virtual void ReleaseRemoteQueryContinueToken(ContinueToken &token) const = 0;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/relational_store_connection.h b/kv_store/frameworks/libs/distributeddb/storage/include/relational_store_connection.h
index b7017feb2fd0d4dba240eed5a0c2f485076bc1ed..2db86c10453603da407d171a730a56a16b051635 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/relational_store_connection.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/relational_store_connection.h
@@ -67,8 +67,6 @@ public:
     virtual int PrepareAndSetCloudDbSchema(const DataBaseSchema &schema) = 0;
     virtual int SetIAssetLoader(const std::shared_ptr<IAssetLoader> &loader) = 0;
 
-    virtual int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess) = 0;
-
     virtual int GetStoreInfo(std::string &userId, std::string &appId, std::string &storeId) = 0;
 
     virtual int SetTrackerTable(const TrackerSchema &schema) = 0;
@@ -82,6 +80,10 @@ public:
     virtual int UpsertData(RecordStatus status, const std::string &tableName, const std::vector<VBucket> &records) = 0;
 
     virtual int SetCloudSyncConfig(const CloudSyncConfig &config) = 0;
+
+    virtual int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess, uint64_t taskId) = 0;
+
+    virtual SyncProcess GetCloudTaskStatus(uint64_t taskId) = 0;
 protected:
     // Get the stashed 'RelationalDB_ pointer' without ref.
     template<typename DerivedDBType>
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/storage_proxy.h b/kv_store/frameworks/libs/distributeddb/storage/include/storage_proxy.h
index 761422db2b14ca15ed3c541f3c4415d9c126f916..4238cbe160bb058bf96b75c09e6278a8e9fd5dbe 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/storage_proxy.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/storage_proxy.h
@@ -41,11 +41,11 @@ public:
 
     int GetLocalWaterMark(const std::string &tableName, Timestamp &localMark);
 
-    int GetLocalWaterMarkByMode(const std::string &tableName, Timestamp &localMark, CloudWaterType mode);
+    int GetLocalWaterMarkByMode(const std::string &tableName, CloudWaterType mode, Timestamp &localMark);
 
     int PutLocalWaterMark(const std::string &tableName, Timestamp &localMark);
 
-    int PutWaterMarkByMode(const std::string &tableName, Timestamp &localMark, CloudWaterType mode);
+    int PutWaterMarkByMode(const std::string &tableName, CloudWaterType mode, Timestamp &localMark);
 
     int GetCloudWaterMark(const std::string &tableName, std::string &cloudMark);
 
@@ -147,6 +147,12 @@ public:
     CloudSyncConfig GetCloudSyncConfig() const;
 
     bool IsTableExistReference(const std::string &table);
+
+    bool IsTableExistReferenceOrReferenceBy(const std::string &table);
+
+    void ReleaseUploadRecord(const std::string &table, const CloudWaterType &type, Timestamp localWaterMark);
+
+    bool IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo);
 protected:
     void Init();
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h b/kv_store/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
index 4e908a4e6c743d82199b752ec8bfc450d36e2665..f8f6fb5759dd9a112dfcb38d9fc3f1ff174a8292 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/include/sync_generic_interface.h
@@ -64,6 +64,16 @@ public:
         return -E_NOT_SUPPORT;
     }
 
+    virtual int GetUnSyncTotal(Timestamp begin, Timestamp end, uint32_t &total) const
+    {
+        return -E_NOT_SUPPORT;
+    }
+
+    virtual int GetUnSyncTotal(QueryObject &query, const SyncTimeRange &timeRange, uint32_t &total) const
+    {
+        return -E_NOT_SUPPORT;
+    }
+
     virtual int GetCompressionOption(bool &needCompressOnSync, uint8_t &compressionRate) const
     {
         return -E_NOT_SUPPORT;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_meta_data.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_meta_data.cpp
index 46416b98435177886a5087fd7d2ba7ece051aaed..b828c85dc89427ed270f54ac80b059699a75a323 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_meta_data.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_meta_data.cpp
@@ -32,6 +32,7 @@ int CloudMetaData::GetLocalWaterMark(const TableName &tableName, Timestamp &loca
     if (cloudMetaVals_.count(tableName) == 0) {
         int ret = ReadMarkFromMeta(tableName);
         if (ret != E_OK) {
+            LOGE("[Meta][GetLocalWaterMark] read mark from meta failed.");
             return ret;
         }
     }
@@ -45,6 +46,7 @@ int CloudMetaData::GetLocalWaterMarkByType(const TableName &tableName, CloudWate
     if (cloudMetaVals_.count(tableName) == 0) {
         int ret = ReadMarkFromMeta(tableName);
         if (ret != E_OK) {
+            LOGE("[Meta][GetLocalWaterMarkByType] read mark from meta failed.");
             return ret;
         }
     }
@@ -237,15 +239,15 @@ int CloudMetaData::DeserializeMark(Value &blobMark, CloudMetaValue &cloudMetaVal
         parcel.ReadUInt64(cloudMetaValue.updateLocalMark);
         parcel.ReadUInt64(cloudMetaValue.deleteLocalMark);
     }
+    if (parcel.IsError()) {
+        LOGE("[Meta] Parcel error while deserializing cloud meta data.");
+        return -E_PARSE_FAIL;
+    }
     if (blobMark.size() < GetParcelCurrentLength(cloudMetaValue)) {
         cloudMetaValue.insertLocalMark = cloudMetaValue.localMark;
         cloudMetaValue.updateLocalMark = cloudMetaValue.localMark;
         cloudMetaValue.deleteLocalMark = cloudMetaValue.localMark;
     }
-    if (parcel.IsError()) {
-        LOGE("[Meta] Parcel error while deserializing cloud meta data.");
-        return -E_PARSE_FAIL;
-    }
     return E_OK;
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp
index 129b701cd33a50f1f20a7882a5c4a468826911c2..fa0e7cd6b1ac9795cb49b9fc6f4a55eb541cce86 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_storage_utils.cpp
@@ -17,10 +17,10 @@
 #include <set>
 
 #include "cloud/asset_operation_utils.h"
+#include "cloud/cloud_db_constant.h"
 #include "cloud/cloud_db_types.h"
 #include "db_common.h"
 #include "runtime_context.h"
-#include "cloud/cloud_db_constant.h"
 
 namespace DistributedDB {
 int CloudStorageUtils::BindInt64(int index, const VBucket &vBucket, const Field &field,
@@ -217,7 +217,7 @@ int CloudStorageUtils::BoolToVector(const VBucket &vBucket, const Field &field,
 {
     (void)collateType;
     bool val = false;
-    if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) {
+    if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) { // LCOV_EXCL_BR_LINE
         return -E_CLOUD_ERROR;
     }
     DBCommon::StringToVector(std::to_string(val ? 1 : 0), value);
@@ -229,7 +229,7 @@ int CloudStorageUtils::DoubleToVector(const VBucket &vBucket, const Field &field
 {
     (void)collateType;
     double val = 0.0;
-    if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) {
+    if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) { // LCOV_EXCL_BR_LINE
         return -E_CLOUD_ERROR;
     }
     std::ostringstream s;
@@ -259,25 +259,25 @@ int CloudStorageUtils::BlobToVector(const VBucket &vBucket, const Field &field,
     std::vector<uint8_t> &value)
 {
     (void)collateType;
-    if (field.type == TYPE_INDEX<Bytes>) {
+    if (field.type == TYPE_INDEX<Bytes>) { // LCOV_EXCL_BR_LINE
         return CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, value);
     } else if (field.type == TYPE_INDEX<Asset>) {
         Asset val;
-        if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) {
+        if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) { // LCOV_EXCL_BR_LINE
             return -E_CLOUD_ERROR;
         }
         int errCode = RuntimeContext::GetInstance()->AssetToBlob(val, value);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("asset to blob fail, %d", errCode);
         }
         return errCode;
     } else {
         Assets val;
-        if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) {
+        if (CloudStorageUtils::GetValueFromVBucket(field.colName, vBucket, val) != E_OK) { // LCOV_EXCL_BR_LINE
             return -E_CLOUD_ERROR;
         }
         int errCode = RuntimeContext::GetInstance()->AssetsToBlob(val, value);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("assets to blob fail, %d", errCode);
         }
         return errCode;
@@ -501,7 +501,10 @@ int CloudStorageUtils::FillAssetForUpload(Asset &asset, Asset &dbAsset, AssetOpe
 {
     if (assetOpType == AssetOperationUtils::AssetOpType::NOT_HANDLE) {
         // db assetId may be empty, need to be based on cache
-        dbAsset.assetId = asset.assetId;
+        // Notes: Assign happened when dbAsset.assetId is empty because of asset.assetId may be empty.
+        if (dbAsset.assetId.empty()) {
+            dbAsset.assetId = asset.assetId;
+        }
         return E_OK;
     }
     AssetStatus status = static_cast<AssetStatus>(dbAsset.status);
@@ -698,13 +701,13 @@ void CloudStorageUtils::MergeDownloadAsset(std::map<std::string, Assets> &downlo
 {
     for (auto &items: mergeAssets) {
         auto downloadItem = downloadAssets.find(items.first);
-        if (downloadItem == downloadAssets.end()) {
+        if (downloadItem == downloadAssets.end()) { // LCOV_EXCL_BR_LINE
             continue;
         }
         std::map<std::string, size_t> beCoveredAssetsMap = GenAssetsIndexMap(items.second);
         for (const Asset &asset: downloadItem->second) {
             auto it = beCoveredAssetsMap.find(asset.name);
-            if (it == beCoveredAssetsMap.end()) {
+            if (it == beCoveredAssetsMap.end()) { // LCOV_EXCL_BR_LINE
                 continue;
             }
             items.second[it->second] = asset;
@@ -895,7 +898,8 @@ void CloudStorageUtils::GetToBeRemoveAssets(const VBucket &vBucket,
             Asset delAsset;
             GetValueFromType(itItem, delAsset);
             auto itOp = col.second.find(delAsset.name);
-            if (itOp != col.second.end() && itOp->second == AssetOperationUtils::AssetOpType::NOT_HANDLE) {
+            if (itOp != col.second.end() && itOp->second == AssetOperationUtils::AssetOpType::NOT_HANDLE
+                && delAsset.flag != static_cast<uint32_t>(AssetOpType::DELETE)) {
                 removeAssets.push_back(delAsset);
             }
             continue;
@@ -904,7 +908,8 @@ void CloudStorageUtils::GetToBeRemoveAssets(const VBucket &vBucket,
         GetValueFromType(itItem, assets);
         for (const auto &asset: assets) {
             auto itOp = col.second.find(asset.name);
-            if (itOp == col.second.end() || itOp->second == AssetOperationUtils::AssetOpType::HANDLE) {
+            if (itOp == col.second.end() || itOp->second == AssetOperationUtils::AssetOpType::HANDLE ||
+                asset.flag == static_cast<uint32_t>(AssetOpType::DELETE)) {
                 continue;
             }
             removeAssets.push_back(asset);
@@ -1091,7 +1096,6 @@ int CloudStorageUtils::BindUpdateLogStmtFromVBucket(const VBucket &vBucket, cons
             errCode = SQLiteUtils::BindInt64ToStatement(updateLogStmt, index, std::get<int64_t>(vBucket.at(colName)));
         } else if (colName == CloudDbConstant::VERSION_FIELD) {
             if (vBucket.find(colName) == vBucket.end()) {
-                LOGW("cloud data doesn't contain version field when bind update log stmt.");
                 errCode = SQLiteUtils::BindTextToStatement(updateLogStmt, index, std::string(""));
             } else {
                 errCode = SQLiteUtils::BindTextToStatement(updateLogStmt, index,
@@ -1117,20 +1121,24 @@ int CloudStorageUtils::BindUpdateLogStmtFromVBucket(const VBucket &vBucket, cons
 }
 
 std::string CloudStorageUtils::GetUpdateRecordFlagSql(const std::string &tableName, bool recordConflict,
-    const LogInfo &logInfo)
+    const LogInfo &logInfo, const VBucket &uploadExtend, const CloudWaterType &type)
 {
     std::string compensatedBit = std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_WAIT_COMPENSATED_SYNC));
     std::string consistentBit = std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_DEVICE_CLOUD_CONSISTENCY));
     bool gidEmpty = logInfo.cloudGid.empty();
     bool isDeleted = logInfo.dataKey == DBConstant::DEFAULT_ROW_ID;
-    std::string sql = "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET flag = (case when timestamp = ? then ";
-
-    if (recordConflict && !(isDeleted && gidEmpty)) {
+    std::string sql = "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET flag = (CASE WHEN timestamp = ? THEN ";
+    bool isNeedCompensated = recordConflict || DBCommon::IsNeedCompensatedForUpload(uploadExtend, type);
+    if (isNeedCompensated && !(isDeleted && gidEmpty)) {
         sql += "flag | " + compensatedBit + " ELSE flag | " + compensatedBit;
     } else {
         sql += "flag & ~" + compensatedBit + " & ~" + consistentBit + " ELSE flag & ~" + compensatedBit;
     }
-    sql += " end), status = (case when status == 2 then 3 when (status == 1 and timestamp = ?) then 0 else status end)";
+    sql += " END), status = (CASE WHEN status == 2 THEN 3 WHEN (status == 1 AND timestamp = ?) THEN 0 ELSE status END)";
+    if (DBCommon::IsCloudRecordNotFound(uploadExtend) &&
+        (type == CloudWaterType::UPDATE || type == CloudWaterType::DELETE)) {
+        sql += ", cloud_gid = '', version = '' ";
+    }
     sql += " WHERE ";
     if (!gidEmpty) {
         sql += " cloud_gid = '" + logInfo.cloudGid + "'";
@@ -1148,6 +1156,15 @@ std::string CloudStorageUtils::GetUpdateRecordFlagSql(const std::string &tableNa
     return sql;
 }
 
+std::string CloudStorageUtils::GetUpdateUploadFinishedSql(const std::string &tableName)
+{
+    std::string finishedBit = std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_UPLOAD_FINISHED));
+    std::string compensatedBit = std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_WAIT_COMPENSATED_SYNC));
+    // When the data flag is not in the compensation state and the local data does not change, the upload is finished.
+    return "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET flag = (CASE WHEN timestamp = ? AND flag & " +
+        compensatedBit + " != " + compensatedBit + " THEN flag | " + finishedBit + " ELSE flag END) WHERE hash_key=?";
+}
+
 int CloudStorageUtils::BindStepConsistentFlagStmt(sqlite3_stmt *stmt, const VBucket &data,
     const std::set<std::string> &gidFilters)
 {
@@ -1206,7 +1223,22 @@ bool CloudStorageUtils::IsGetCloudDataContinue(uint32_t curNum, uint32_t curSize
     return false;
 }
 
-int CloudStorageUtils::IdentifyCloudType(CloudSyncData &cloudSyncData, VBucket &data, VBucket &log, VBucket &flags)
+int CloudStorageUtils::IdentifyCloudType(const CloudUploadRecorder &recorder, CloudSyncData &cloudSyncData,
+    VBucket &data, VBucket &log, VBucket &flags)
+{
+    Bytes *hashKey = std::get_if<Bytes>(&flags[CloudDbConstant::HASH_KEY]);
+    int64_t *timeStamp = std::get_if<int64_t>(&flags[CloudDbConstant::TIMESTAMP]);
+    if (timeStamp == nullptr || hashKey == nullptr) {
+        return -E_INVALID_DATA;
+    }
+    if (recorder.IsIgnoreUploadRecord(cloudSyncData.tableName, *hashKey, cloudSyncData.mode, *timeStamp)) {
+        cloudSyncData.ignoredCount++;
+        return -E_IGNORE_DATA;
+    }
+    return IdentifyCloudTypeInner(cloudSyncData, data, log, flags);
+}
+
+int CloudStorageUtils::IdentifyCloudTypeInner(CloudSyncData &cloudSyncData, VBucket &data, VBucket &log, VBucket &flags)
 {
     int64_t *rowid = std::get_if<int64_t>(&flags[CloudDbConstant::ROWID]);
     int64_t *flag = std::get_if<int64_t>(&flags[CloudDbConstant::FLAG]);
@@ -1388,4 +1420,69 @@ bool CloudStorageUtils::IsSystemRecord(const Key &key)
     std::string keyStr(key.begin(), key.end());
     return keyStr.find(prefixKey) == 0;
 }
+
+std::string CloudStorageUtils::GetSelectIncCursorSql(const std::string &tableName)
+{
+    return "(SELECT value FROM " + DBCommon::GetMetaTableName() + " WHERE key=x'" +
+        DBCommon::TransferStringToHex(DBCommon::GetCursorKey(tableName)) + "')";
+}
+
+std::string CloudStorageUtils::GetCursorIncSql(const std::string &tableName)
+{
+    return "UPDATE " + DBCommon::GetMetaTableName() + " SET value=value+1 WHERE key=x'" +
+        DBCommon::TransferStringToHex(DBCommon::GetCursorKey(tableName)) + "';";
+}
+
+std::string CloudStorageUtils::GetCursorUpgradeSql(const std::string &tableName)
+{
+    return "INSERT OR REPLACE INTO " + DBCommon::GetMetaTableName() + "(key,value) VALUES (x'" +
+        DBCommon::TransferStringToHex(DBCommon::GetCursorKey(tableName)) + "', (SELECT CASE WHEN MAX(cursor) IS" +
+        " NULL THEN 0 ELSE MAX(cursor) END FROM " + DBCommon::GetLogTableName(tableName) + "));";
+}
+
+int CloudStorageUtils::GetSyncQueryByPk(const std::string &tableName, const std::vector<VBucket> &data, bool isKv,
+    QuerySyncObject &querySyncObject)
+{
+    std::map<std::string, size_t> dataIndex;
+    std::map<std::string, std::vector<Type>> syncPk;
+    int ignoreCount = 0;
+    for (const auto &oneRow : data) {
+        if (oneRow.size() >= 2u) { // mean this data has more than 2 pk
+            LOGW("Not support compensated sync with composite primary key now");
+            return -E_NOT_SUPPORT;
+        }
+        for (const auto &[col, value] : oneRow) {
+            bool isFind = dataIndex.find(col) != dataIndex.end();
+            if (!isFind && value.index() == TYPE_INDEX<Nil>) {
+                ignoreCount++;
+                continue;
+            }
+            if (!isFind && value.index() != TYPE_INDEX<Nil>) {
+                dataIndex[col] = value.index();
+                syncPk[col].push_back(value);
+                continue;
+            }
+            if (isFind && dataIndex[col] != value.index()) {
+                ignoreCount++;
+                continue;
+            }
+            syncPk[col].push_back(value);
+        }
+    }
+    LOGI("match %zu data for compensated sync, ignore %d", data.size(), ignoreCount);
+    Query query = Query::Select().From(tableName);
+    if (isKv) {
+        QueryUtils::FillQueryInKeys(syncPk, dataIndex, query);
+    } else {
+        for (const auto &[col, pkList] : syncPk) {
+            QueryUtils::FillQueryIn(col, pkList, dataIndex[col], query);
+        }
+    }
+    auto objectList = QuerySyncObject::GetQuerySyncObject(query);
+    if (objectList.size() != 1u) { // only support one QueryExpression
+        return -E_INTERNAL_ERROR;
+    }
+    querySyncObject = objectList[0];
+    return E_OK;
+}
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_upload_recorder.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_upload_recorder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac8296e0c938b5bc55bf02b333c0fe1660244fc1
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/cloud_upload_recorder.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cloud/cloud_upload_recorder.h"
+
+namespace DistributedDB {
+void CloudUploadRecorder::RecordUploadRecord(const std::string &table, const Bytes &hashKey, const CloudWaterType &type,
+    int64_t modifyTime)
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    uploadRecord_[currentUser_][table][type][hashKey] = modifyTime;
+}
+
+bool CloudUploadRecorder::IsIgnoreUploadRecord(const std::string &table, const Bytes &hashKey,
+    const CloudWaterType &type, int64_t modifyTime) const
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    auto userRecord = uploadRecord_.find(currentUser_);
+    if (userRecord == uploadRecord_.end()) {
+        return false;
+    }
+    auto tableRecord = userRecord->second.find(table);
+    if (tableRecord == userRecord->second.end()) {
+        return false;
+    }
+    auto typeRecord = tableRecord->second.find(type);
+    if (typeRecord == tableRecord->second.end()) {
+        return false;
+    }
+    auto it = typeRecord->second.find(hashKey);
+    return it != typeRecord->second.end() && it->second == modifyTime;
+}
+
+void CloudUploadRecorder::ReleaseUploadRecord(const std::string &table, const CloudWaterType &type,
+    Timestamp localWaterMark)
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    auto &records = uploadRecord_[currentUser_][table][type];
+    for (auto it = records.begin(); it != records.end();) {
+        if (it->second <= static_cast<int64_t>(localWaterMark)) {
+            it = records.erase(it);
+        } else {
+            it++;
+        }
+    }
+}
+
+void CloudUploadRecorder::SetUser(const std::string &user)
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    currentUser_ = user;
+}
+}
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/schema_mgr.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/schema_mgr.cpp
index a912637bd0f0a4336b05aa763e90608a63d2b6c5..ae8b452e0cdf843c79d6aabced331adddec4335c 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/cloud/schema_mgr.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/cloud/schema_mgr.cpp
@@ -20,7 +20,6 @@
 #include "cloud/cloud_db_constant.h"
 #include "cloud/cloud_storage_utils.h"
 #include "cloud/cloud_store_types.h"
-#include "cloud/cloud_storage_utils.h"
 #include "db_common.h"
 #include "db_errno.h"
 namespace DistributedDB {
@@ -36,17 +35,20 @@ int SchemaMgr::ChkSchema(const TableName &tableName, RelationalSchemaObject &loc
     }
     TableInfo tableInfo = localSchema.GetTable(tableName);
     if (tableInfo.Empty()) {
-        LOGE("Local schema does not contain certain table");
+        LOGE("Local schema does not contain certain table [ %s size = %d ]",
+            DBCommon::StringMiddleMasking(tableName).c_str(), tableName.size());
         return -E_SCHEMA_MISMATCH;
     }
     if (tableInfo.GetTableSyncType() != TableSyncType::CLOUD_COOPERATION) {
-        LOGE("Sync type of local table is not CLOUD_COOPERATION");
+        LOGE("Sync type of local table [ %s size = %d ] is not CLOUD_COOPERATION",
+            DBCommon::StringMiddleMasking(tableName).c_str(), tableName.size());
         return -E_NOT_SUPPORT;
     }
     TableSchema cloudTableSchema;
     int ret = GetCloudTableSchema(tableName, cloudTableSchema);
     if (ret != E_OK) {
-        LOGE("Cloud schema does not contain certain table:%d", ret);
+        LOGE("Cloud schema does not contain certain table [ %s size = %d ]:%d",
+            DBCommon::StringMiddleMasking(tableName).c_str(), tableName.size(), ret);
         return -E_SCHEMA_MISMATCH;
     }
     std::map<int, FieldName> primaryKeys = tableInfo.GetPrimaryKey();
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/data_transformer.h b/kv_store/frameworks/libs/distributeddb/storage/src/data_transformer.h
index 8766c8c3997ddc794a2091404bbad0e851942a7e..042786c023382e28d68a6b4162e1eb7166fa7082 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/data_transformer.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/data_transformer.h
@@ -39,6 +39,8 @@ struct LogInfo {
     std::string sharingResource; // use for cloud share data
     std::string version; // use for conflict check
     uint32_t status = static_cast<uint32_t>(LockStatus::UNLOCK); // record lock status
+    bool isNeedUpdateAsset = false;
+    uint64_t cloud_flag = 0; // use for kv cloud log table
 };
 
 enum class LogInfoFlag : uint32_t {
@@ -53,6 +55,8 @@ enum class LogInfoFlag : uint32_t {
     FLAG_KV_LOGIC_DELETE = 0x80,
     FLAG_CLOUD_WRITE = 0x100,
     FLAG_SYSTEM_RECORD = 0x200,
+    FLAG_UPLOAD_FINISHED = 0x400,
+    FLAG_LOGIC_DELETE_FOR_LOGOUT = 0x800,
 };
 
 struct RowDataWithLog {
@@ -105,4 +109,4 @@ private:
 }
 
 #endif
-#endif // DATA_TRANSFORMER_H
\ No newline at end of file
+#endif // DATA_TRANSFORMER_H
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/db_properties.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/db_properties.cpp
index c86aa900294b172cc8191eeb64a6843e16842c26..28ae4485b4b439acc9f1d8760cd04638c9476afe 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/db_properties.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/db_properties.cpp
@@ -17,21 +17,6 @@
 #include "db_properties.h"
 
 namespace DistributedDB {
-const std::string DBProperties::CREATE_IF_NECESSARY = "createIfNecessary";
-const std::string DBProperties::DATA_DIR = "dataDir";
-const std::string DBProperties::USER_ID = "userId";
-const std::string DBProperties::APP_ID = "appId";
-const std::string DBProperties::STORE_ID = "storeId";
-const std::string DBProperties::INSTANCE_ID = "instanceId";
-const std::string DBProperties::SUB_USER = "subUser";
-const std::string DBProperties::IDENTIFIER_DATA = "identifier";
-const std::string DBProperties::IDENTIFIER_DIR = "identifierDir";
-const std::string DBProperties::DUAL_TUPLE_IDENTIFIER_DATA = "dualTupleIdentifier";
-const std::string DBProperties::SYNC_DUAL_TUPLE_MODE = "syncDualTuple";
-const std::string DBProperties::AUTO_LAUNCH_ID = "autoLaunchID";
-
-const std::string DBProperties::DATABASE_TYPE = "databaseType";
-
 std::string DBProperties::GetStringProp(const std::string &name, const std::string &defaultValue) const
 {
     auto iter = stringProperties_.find(name);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.cpp
index 3c0b905c80dc00c915d881b9a04a5b7526ca483b..3645b6996e6f6ef388e7af42671bfb59cee44a39 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.cpp
@@ -237,12 +237,137 @@ int RdSingleVerNaturalStore::Rekey(const CipherPassword &passwd)
 
 int RdSingleVerNaturalStore::Export(const std::string &filePath, const CipherPassword &passwd)
 {
-    return -E_NOT_SUPPORT;
+    if (storageEngine_ == nullptr) {
+        return -E_INVALID_DB;
+    }
+
+    // MEMORY_MODE is false, not E_NOT_SUPPORT
+    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) {
+        return -E_NOT_SUPPORT;
+    }
+
+    // MEMORY_MODE is READ_ONLY_MODE is true, not E_NOT_SUPPORT
+    if (MyProp().GetBoolProp(KvDBProperties::READ_ONLY_MODE, true)) {
+        return -E_READ_ONLY;
+    }
+
+    int errCode = E_OK;
+    RdSingleVerStorageExecutor *handle = GetHandle(true, errCode);
+    if (handle == nullptr) {
+        return errCode;
+    }
+
+    // forbid migrate by hold write handle not release
+    if (storageEngine_->GetEngineState() != EngineState::MAINDB) {
+        errCode = (storageEngine_->GetEngineState() == EngineState::CACHEDB) ? -E_NOT_SUPPORT : -E_BUSY;
+        ReleaseHandle(handle);
+        return errCode;
+    }
+
+    errCode = TryToDisableConnection(OperatePerm::NORMAL_WRITE);
+    if (errCode != E_OK) {
+        ReleaseHandle(handle);
+        return errCode;
+    }
+
+    uint8_t *encryptedKey = const_cast<uint8_t*>(passwd.GetData());
+    uint32_t encryptedKeyLen = (uint32_t)passwd.GetSize();
+    errCode = handle->Backup(filePath, encryptedKey, encryptedKeyLen);
+    if (errCode != E_OK) {
+        LOGE("[RdSingleVerNaturalStore][Backup] can not backup the data %d", errCode);
+    }
+
+    ReEnableConnection(OperatePerm::NORMAL_WRITE);
+    ReleaseHandle(handle);
+    return errCode;
+}
+
+int RdSingleVerNaturalStore::PreCheckRdImport(std::string &storePath)
+{
+    if (storageEngine_ == nullptr) {
+        LOGE("storageEngine_ is nullptr!");
+        return -E_INVALID_DB;
+    }
+
+    // MEMORY_MODE is false, not E_NOT_SUPPORT
+    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) {
+        LOGE("[RdSingleVerNaturalStore][Export] errCode is E_NOT_SUPPORT");
+        return -E_NOT_SUPPORT;
+    }
+
+    // MEMORY_MODE is READ_ONLY_MODE is true, not E_NOT_SUPPORT
+    if (MyProp().GetBoolProp(KvDBProperties::READ_ONLY_MODE, true)) {
+        LOGE("Not support export when cacheDB existed! state = [%d]", storageEngine_->GetEngineState());
+        return -E_READ_ONLY;
+    }
+
+    // get store path
+    OpenDbProperties optionTemp = storageEngine_->GetOption();
+    storePath = optionTemp.uri;
+    if (storePath.empty()) {
+        return -E_INVALID_ARGS;
+    }
+
+    return E_OK;
 }
 
 int RdSingleVerNaturalStore::Import(const std::string &filePath, const CipherPassword &passwd)
 {
-    return -E_NOT_SUPPORT;
+    int errCode = E_OK;
+    std::string storePath;
+
+    errCode = PreCheckRdImport(storePath);
+    if (errCode != E_OK) {
+        LOGE("[RdSingleVerNaturalStore][PreCheckRdImport] is failed: %d", errCode);
+        return errCode;
+    }
+
+    uint8_t *decryptedKey = const_cast<uint8_t*>(passwd.GetData());
+    uint32_t decryptedKeyLen = (uint32_t)passwd.GetSize();
+
+    // try to disable
+    errCode = storageEngine_->TryToDisable(false, OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    if (errCode != E_OK) {
+        LOGE("TryToDisable is not %d", errCode);
+        return errCode;
+    }
+
+    errCode = storageEngine_->TryToDisable(true, OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    if (errCode != E_OK) {
+        LOGE("[Import] Failed to disable the database: %d", errCode);
+        AbortHandleAndWaitWriteHandle();
+        return errCode;
+    }
+
+    if (storageEngine_->GetEngineState() != EngineState::MAINDB) {
+        LOGE("Not support import when cacheDB existed! state = [%d]", storageEngine_->GetEngineState());
+        errCode = (storageEngine_->GetEngineState() == EngineState::CACHEDB) ? -E_NOT_SUPPORT : -E_BUSY;
+        AbortHandleAndWaitWriteHandle();
+        return errCode;
+    }
+
+    // close all grd handle
+    storageEngine_->CloseAllExecutor();
+
+    errCode = RdRestore(storePath.c_str(), filePath.c_str(), decryptedKey, decryptedKeyLen);
+    if (errCode != E_OK) {
+        AbortHandleAndWaitWriteHandle();
+        return errCode;
+    }
+
+    errCode = storageEngine_->InitAllReadWriteExecutor();
+    if (errCode != E_OK) {
+        LOGD("InitAllReadWriteExecutor is failed! errCode = [%d]", errCode);
+        return errCode;
+    }
+    storageEngine_->Enable(OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    return errCode;
+}
+
+void RdSingleVerNaturalStore::AbortHandleAndWaitWriteHandle() const
+{
+    storageEngine_->Enable(OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    storageEngine_->WaitWriteHandleIdle();
 }
 
 RdSingleVerStorageExecutor *RdSingleVerNaturalStore::GetHandle(bool isWrite, int &errCode,
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.h b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.h
index 61c62fc21f0c0f525475c8c22fd109d7846acd6a..5dbc25baf6da472961d66ed1cb4b339c3a1f013c 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store.h
@@ -83,6 +83,8 @@ public:
     RdSingleVerStorageExecutor *GetHandle(bool isWrite, int &errCode,
         OperatePerm perm = OperatePerm::NORMAL_PERM) const;
 
+    void AbortHandleAndWaitWriteHandle() const;
+
     void ReleaseHandle(RdSingleVerStorageExecutor *&handle) const;
 
     int TransObserverTypeToRegisterFunctionType(int observerType, RegisterFuncType &type) const override;
@@ -144,6 +146,7 @@ public:
     void SetReceiveDataInterceptor(const DataInterceptor &interceptor) override;
 
 private:
+    int PreCheckRdImport(std::string &storePath);
 
     int GetAndInitStorageEngine(const KvDBProperties &kvDBProp);
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.cpp
index d9fc964d2ebb355280c2037fd0266b01317c635f..b0229b50ae60c162ac03d235046dedeccfbfa81b 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.cpp
@@ -402,12 +402,81 @@ int RdSingleVerNaturalStoreConnection::Rekey(const CipherPassword &passwd)
 
 int RdSingleVerNaturalStoreConnection::Export(const std::string &filePath, const CipherPassword &passwd)
 {
-    return -E_NOT_SUPPORT;
+    if (kvDB_ == nullptr) {
+        return -E_INVALID_DB;
+    }
+
+    // not support passwd
+    if (passwd.GetSize() != 0) {
+        LOGE("[RdSingleVerNaturalStoreConnection][Export]unsupport passwd.");
+        return -E_NOT_SUPPORT;
+    }
+
+    return kvDB_->Export(filePath, passwd);
 }
 
 int RdSingleVerNaturalStoreConnection::Import(const std::string &filePath, const CipherPassword &passwd)
 {
-    return -E_NOT_SUPPORT;
+    // not support passwd
+    if (passwd.GetSize() != 0) {
+        LOGE("[RdSingleVerNaturalStoreConnection][Export]unsupport passwd.");
+        return -E_NOT_SUPPORT;
+    }
+
+    std::lock_guard<std::mutex> lock(importMutex_);
+    int errCode = CheckRdMonoStatus(OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    errCode = kvDB_->Import(filePath, passwd);
+    if ((errCode == -E_INVALID_PASSWD_OR_CORRUPTED_DB) || (errCode == -E_UNEXPECTED_DATA)) {
+        errCode = -E_INVALID_FILE; // import damaged file or txt file, return -E_INVALID_FILE
+    }
+    GenericKvDBConnection::ResetExclusiveStatus();
+    kvDB_->ReEnableConnection(OperatePerm::IMPORT_MONOPOLIZE_PERM);
+    if (errCode == E_OK) {
+        kvDB_->ResetSyncStatus();
+    }
+    return errCode;
+}
+
+int RdSingleVerNaturalStoreConnection::CheckRdMonoStatus(OperatePerm perm)
+{
+    if (kvDB_ == nullptr) {
+        return -E_INVALID_DB;
+    }
+
+    // check if result set closed
+    {
+        std::lock_guard<std::mutex> kvDbResultLock(kvDbResultSetsMutex_);
+        if (kvDbResultSets_.size() > 0) {
+            LOGE("Active result set exist.");
+            return -E_BUSY;
+        }
+    }
+    // 1. Get the connection number, and get the right to do the rekey operation.
+    int errCode = kvDB_->TryToDisableConnection(perm);
+    if (errCode != E_OK) {
+        // If precheck failed, it means that there are more than one connection.
+        // No need reset the condition for the scene.
+        LOGE("More than one connection");
+        return errCode;
+    }
+    // 2. Check the observer list.
+    errCode = GenericKvDBConnection::PreCheckExclusiveStatus();
+    if (errCode != E_OK) {
+        kvDB_->ReEnableConnection(perm);
+        LOGE("Observer prevents.");
+        return errCode;
+    }
+
+    // 3. Check the conflict notifier.
+    {
+        GenericKvDBConnection::ResetExclusiveStatus();
+        kvDB_->ReEnableConnection(perm);
+        EnableManualSync();
+    }
+    return E_OK;
 }
 
 int RdSingleVerNaturalStoreConnection::RegisterLifeCycleCallback(const DatabaseLifeCycleNotifier &notifier)
@@ -723,5 +792,19 @@ int RdSingleVerNaturalStoreConnection::GetSyncDataSize(const std::string &device
 {
     return -E_NOT_SUPPORT;
 }
+
+int RdSingleVerNaturalStoreConnection::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess)
+{
+    return -E_NOT_SUPPORT;
+}
+
+int RdSingleVerNaturalStoreConnection::SetCloudDB(const std::map<std::string, std::shared_ptr<ICloudDb>> &cloudDBs)
+{
+    return -E_NOT_SUPPORT;
+}
+
+void RdSingleVerNaturalStoreConnection::SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback)
+{
+}
 }
 // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.h b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.h
index 18245b0c0e7cc82b4ad9bd2d135056d97bde098f..33a0f48a9fb0e6d555777b409c1e89da2efb4293 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_natural_store_connection.h
@@ -100,7 +100,15 @@ public:
 
     int GetSyncDataSize(const std::string &device, size_t &size) const override;
 
+    int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess) override;
+
+    int SetCloudDB(const std::map<std::string, std::shared_ptr<ICloudDb>> &cloudDBs) override;
+
+    void SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback) override;
+
 private:
+    int CheckRdMonoStatus(OperatePerm perm);
+
     int GetEntriesInner(bool isGetValue, const IOption &option,
         const Key &keyPrefix, std::vector<Entry> &entries) const;
 
@@ -161,6 +169,7 @@ private:
     SingleVerNaturalStoreCommitNotifyData *committedData_; // used for transaction
 
     mutable std::mutex transactionMutex_;
+    std::mutex importMutex_;
     RdSingleVerStorageExecutor *writeHandle_; // only existed while in transaction.
 };
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_engine.cpp
index bacfce3d9311c8f9091be6e465d0992215dce8f5..598471086b5788c0153cbcb721b1b10baaaaabb6 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_engine.cpp
@@ -39,9 +39,6 @@ inline std::string GetTableMode(bool isHash)
 
 int RdSingleVerStorageEngine::CreateNewExecutor(bool isWrite, StorageExecutor *&handle)
 {
-    if (option_.isHashTable) {
-        GRD_SetLibType(option_.isHashTable);
-    }
     int ret = PreCreateExecutor(isWrite);
     if (ret != E_OK) {
         LOGE("[RdSingleVerStorageEngine][CreateNewExecutor] PreCreateExecutor unscuccess");
@@ -55,13 +52,13 @@ int RdSingleVerStorageEngine::CreateNewExecutor(bool isWrite, StorageExecutor *&
     }
     if (!option_.readOnly) {
         std::string tableMode = GetTableMode(option_.isHashTable);
-        ret = TransferGrdErrno(GRD_CreateCollection(db, SYNC_COLLECTION_NAME.c_str(), tableMode.c_str(), 0));
+        ret = TransferGrdErrno(GRD_CreateCollection(db, SYNC_COLLECTION_NAME, tableMode.c_str(), 0));
         if (ret != E_OK) {
             LOGE("[RdSingleVerStorageEngine] GRD_CreateCollection SYNC_COLLECTION_NAME FAILED %d", ret);
             return ret;
         }
     }
-    ret = TransferGrdErrno(IndexPreLoad(db, SYNC_COLLECTION_NAME.c_str()));
+    ret = TransferGrdErrno(IndexPreLoad(db, SYNC_COLLECTION_NAME));
     if (ret != E_OK) {
         LOGE("[RdSingleVerStorageEngine] GRD_IndexPreload FAILED %d", ret);
         return ret;
@@ -88,6 +85,7 @@ int RdSingleVerStorageEngine::InitRdStorageEngine(const StorageEngineAttr &poolS
     engineAttr_ = poolSize;
     option_ = option;
     identifier_ = identifier;
+    hashIdentifier_ = DBCommon::TransferStringToHex(identifier_);
     int errCode = Init();
     if (errCode != E_OK) {
         LOGI("Storage engine init fail! errCode = [%d]", errCode);
@@ -103,7 +101,7 @@ int RdSingleVerStorageEngine::GetExistedSecOption(SecurityOption &secOption) con
 
 int RdSingleVerStorageEngine::CheckDatabaseSecOpt(const SecurityOption &secOption) const
 {
-    if (!(secOption == option_.securityOpt) &&
+    if (!(secOption == option_.securityOpt) && (secOption.securityLabel > option_.securityOpt.securityLabel) &&
         secOption.securityLabel != SecurityLabel::NOT_SET &&
         option_.securityOpt.securityLabel != SecurityLabel::NOT_SET) {
         LOGE("[RdSingleVerStorageEngine] SecurityOption mismatch, existed:[%d-%d] vs input:[%d-%d]",
@@ -150,7 +148,7 @@ int RdSingleVerStorageEngine::GetDbHandle(bool isWrite, const SecurityOption &se
 {
     int errCode = TryToOpenMainDatabase(isWrite, dbHandle);
     LOGD("Finish to open the main database, write[%d], label[%d], flag[%d], id[%.6s], errCode[%d]",  isWrite,
-        secOpt.securityLabel, secOpt.securityFlag, DBCommon::TransferStringToHex(identifier_).c_str(), errCode);
+        secOpt.securityLabel, secOpt.securityFlag, hashIdentifier_.c_str(), errCode);
     if (!(ParamCheckUtils::IsS3SECEOpt(secOpt) && errCode == -E_EKEYREVOKED)) {
         return errCode;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.cpp
index 957b431a4ab3f7dfd9b5b9e6151149d4104dc5e9..610e7e6b2edeec8b710d22cc4dac60bd805117d6 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.cpp
@@ -68,7 +68,7 @@ RdSingleVerStorageExecutor::~RdSingleVerStorageExecutor()
 
 int RdSingleVerStorageExecutor::OpenResultSet(const Key &key, GRD_KvScanModeE mode, GRD_ResultSet **resultSet)
 {
-    int errCode = RdKVScan(db_, SYNC_COLLECTION_NAME.c_str(), key, mode, resultSet);
+    int errCode = RdKVScan(db_, SYNC_COLLECTION_NAME, key, mode, resultSet);
     if (errCode != E_OK) {
         LOGE("Can not open rd result set.");
     }
@@ -77,7 +77,7 @@ int RdSingleVerStorageExecutor::OpenResultSet(const Key &key, GRD_KvScanModeE mo
 
 int RdSingleVerStorageExecutor::OpenResultSet(const Key &beginKey, const Key &endKey, GRD_ResultSet **resultSet)
 {
-    int errCode = RdKVRangeScan(db_, SYNC_COLLECTION_NAME.c_str(), beginKey, endKey, resultSet);
+    int errCode = RdKVRangeScan(db_, SYNC_COLLECTION_NAME, beginKey, endKey, resultSet);
     if (errCode != E_OK) {
         LOGE("[RdSingleVerStorageExecutor][OpenResultSet] Can not open rd result set.");
     }
@@ -96,18 +96,18 @@ int RdSingleVerStorageExecutor::CloseResultSet(GRD_ResultSet *resultSet)
 int RdSingleVerStorageExecutor::InnerMoveToHead(const int position, GRD_ResultSet *resultSet, int &currPosition)
 {
     int errCode = E_OK;
-    while (true) {
+    while (true) { // LCOV_EXCL_BR_LINE
         errCode = TransferGrdErrno(GRD_Prev(resultSet));
-        if (errCode == -E_NOT_FOUND) {
+        if (errCode == -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             currPosition = 0;
             int ret = TransferGrdErrno(GRD_Next(resultSet));
-            if (ret != E_OK) {
+            if (ret != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("[RdSingleVerStorageExecutor] failed to move next for result set.");
                 currPosition = position <= INIT_POSITION ? INIT_POSITION : currPosition;
                 return ret;
             }
             ret = TransferGrdErrno(GRD_Prev(resultSet));
-            if (ret != E_OK) {
+            if (ret != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("[RdSingleVerStorageExecutor] failed to move prev for result set.");
                 return ret;
             }
@@ -124,23 +124,23 @@ int RdSingleVerStorageExecutor::InnerMoveToHead(const int position, GRD_ResultSe
 int RdSingleVerStorageExecutor::MoveTo(const int position, GRD_ResultSet *resultSet, int &currPosition)
 {
     int errCode = E_OK; // incase it never been move before
-    if (currPosition == INIT_POSITION) {
+    if (currPosition == INIT_POSITION) { // LCOV_EXCL_BR_LINE
         errCode = TransferGrdErrno(GRD_Next(resultSet)); // but when we have only 1 element ?
-        if (errCode == -E_NOT_FOUND) {
+        if (errCode == -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             LOGE("[RdSingleVerStorageExecutor] result set is empty when move to");
             return -E_RESULT_SET_EMPTY;
         }
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RdSingleVerStorageExecutor] failed to move next for result set.");
             return errCode;
         }
         currPosition++;
     }
     errCode = InnerMoveToHead(position, resultSet, currPosition);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
-    if (position <= INIT_POSITION) {
+    if (position <= INIT_POSITION) { // LCOV_EXCL_BR_LINE
         LOGE("[RdSingleVerStorageExecutor] current position must > -1 when move to.");
         int ret = TransferGrdErrno(GRD_Prev(resultSet));
         if (ret != E_OK && ret != -E_NOT_FOUND) {
@@ -151,9 +151,9 @@ int RdSingleVerStorageExecutor::MoveTo(const int position, GRD_ResultSet *result
         return -E_INVALID_ARGS;
     }
     currPosition = 0;
-    while (currPosition < position) {
+    while (currPosition < position) { // LCOV_EXCL_BR_LINE
         errCode = TransferGrdErrno(GRD_Next(resultSet));
-        if (errCode == -E_NOT_FOUND) {
+        if (errCode == -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             LOGE("[RdSingleVerStorageExecutor] move to position: %d, out of bounds", position);
             currPosition++;
             return -E_INVALID_ARGS;
@@ -230,7 +230,7 @@ int RdSingleVerStorageExecutor::GetCount(const Key &key, int &count, GRD_KvScanM
 {
     count = 0;
     GRD_ResultSet *tmpResultSet = nullptr;
-    int errCode = RdKVScan(db_, SYNC_COLLECTION_NAME.c_str(), key, kvScanMode, &tmpResultSet);
+    int errCode = RdKVScan(db_, SYNC_COLLECTION_NAME, key, kvScanMode, &tmpResultSet);
     if (errCode != E_OK) {
         LOGE("[RdSingleVerStorageExecutor] failed to get count for current key.");
         return errCode;
@@ -242,7 +242,7 @@ int RdSingleVerStorageExecutor::GetCount(const Key &beginKey, const Key &endKey,
 {
     count = 0;
     GRD_ResultSet *tmpResultSet = nullptr;
-    int errCode = RdKVRangeScan(db_, SYNC_COLLECTION_NAME.c_str(), beginKey, endKey, &tmpResultSet);
+    int errCode = RdKVRangeScan(db_, SYNC_COLLECTION_NAME, beginKey, endKey, &tmpResultSet);
     if (errCode != E_OK) {
         LOGE("[RdSingleVerStorageExecutor] failed to get count for current key.");
         return errCode;
@@ -275,7 +275,12 @@ int RdSingleVerStorageExecutor::GetKvData(SingleVerDataType type, const Key &key
         return -E_INVALID_ARGS;
     }
 
-    return RdKVGet(db_, SYNC_COLLECTION_NAME.c_str(), key, value);
+    return RdKVGet(db_, SYNC_COLLECTION_NAME, key, value);
+}
+
+int RdSingleVerStorageExecutor::Backup(const std::string &filePath, uint8_t *encryptedKey, uint32_t encryptedKeyLen)
+{
+    return RdBackup(db_, filePath.c_str(), encryptedKey, encryptedKeyLen);
 }
 
 int RdSingleVerStorageExecutor::ClearEntriesAndFreeResultSet(std::vector<Entry> &entries, GRD_ResultSet *resultSet)
@@ -295,11 +300,11 @@ int RdSingleVerStorageExecutor::GetEntriesPrepare(GRD_DB *db, const GRD_KvScanMo
     int ret = E_OK;
     switch (mode) {
         case KV_SCAN_PREFIX: {
-            ret = RdKVScan(db, SYNC_COLLECTION_NAME.c_str(), pairKey.first, KV_SCAN_PREFIX, resultSet);
+            ret = RdKVScan(db, SYNC_COLLECTION_NAME, pairKey.first, KV_SCAN_PREFIX, resultSet);
             break;
         }
         case KV_SCAN_RANGE: {
-            ret = RdKVRangeScan(db, SYNC_COLLECTION_NAME.c_str(), pairKey.first, pairKey.second, resultSet);
+            ret = RdKVRangeScan(db, SYNC_COLLECTION_NAME, pairKey.first, pairKey.second, resultSet);
             break;
         }
         default:
@@ -381,7 +386,7 @@ int RdSingleVerStorageExecutor::SaveKvData(SingleVerDataType type, const Key &ke
 
 int RdSingleVerStorageExecutor::DelKvData(const Key &key)
 {
-    return RdKVDel(db_, SYNC_COLLECTION_NAME.c_str(), key);
+    return RdKVDel(db_, SYNC_COLLECTION_NAME, key);
 }
 
 int RdSingleVerStorageExecutor::BatchSaveEntries(const std::vector<Entry> &entries, bool isDelete,
@@ -408,9 +413,9 @@ int RdSingleVerStorageExecutor::BatchSaveEntries(const std::vector<Entry> &entri
         return ret;
     }
     if (isDelete) {
-        ret = RdKVBatchDel(db_, SYNC_COLLECTION_NAME.c_str(), batch);
+        ret = RdKVBatchDel(db_, SYNC_COLLECTION_NAME, batch);
     } else {
-        ret = RdKVBatchPut(db_, SYNC_COLLECTION_NAME.c_str(), batch);
+        ret = RdKVBatchPut(db_, SYNC_COLLECTION_NAME, batch);
     }
     if (ret != E_OK) {
         (void)RdKVBatchDestroy(batch);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.h b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.h
index b0dc861a5a20c8023a6d40e4dee112027a0ae978..e94664217152b05723598f2cc7fd758dd9eca1c0 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_single_ver_storage_executor.h
@@ -52,6 +52,8 @@ public:
     // Get the Kv data according the type(sync, meta, local data).
     int GetKvData(SingleVerDataType type, const Key &key, Value &value, Timestamp &timestamp) const;
 
+    int Backup(const std::string &filePath, uint8_t *encryptedKey, uint32_t encryptedKeyLen);
+
     // Get the sync data record by hash key.
     int GetKvDataByHashKey(const Key &hashKey, SingleVerRecord &result) const;
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.cpp
index aa79170b908bcb195f1dcb4105bdf20aa312db8d..5285f9ac4c766625058361134cffc5183843b7a6 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.cpp
@@ -50,7 +50,7 @@ namespace DistributedDB {
 
 std::string InitRdConfig()
 {
-    return R"("redoFlushByTrx": 1, "maxConnNum": 100, "crcCheckEnable": 0)";
+    return R"("redoFlushByTrx": 1, "maxConnNum": 100, "crcCheckEnable": 0, "metaInfoBak": 1)";
 }
 
 struct GrdErrnoPair {
@@ -79,7 +79,10 @@ const GrdErrnoPair GRD_ERRNO_MAP[] = {
     { GRD_DISK_SPACE_FULL, -E_INTERNAL_ERROR },
     { GRD_CRC_CHECK_DISABLED, -E_INVALID_ARGS },
     { GRD_PERMISSION_DENIED, -E_DENIED_SQL },
-    { GRD_REBUILD_DATABASE, -E_REBUILD_DATABASE}, // rebuild database means ok
+    { GRD_REBUILD_DATABASE, -E_REBUILD_DATABASE }, // rebuild database means ok
+    { GRD_DATA_CORRUPTED, -E_INVALID_PASSWD_OR_CORRUPTED_DB },
+    { GRD_DATA_EXCEPTION, -E_UNEXPECTED_DATA },
+    { GRD_DB_BUSY, -E_BUSY },
 };
 int TransferGrdErrno(int err)
 {
@@ -145,6 +148,16 @@ int RdKVGet(GRD_DB *db, const char *collectionName, const Key &key, Value &value
     return E_OK;
 }
 
+int RdBackup(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen)
+{
+    return TransferGrdErrno(GRD_DBBackup(db, backupDbFile, encryptedKey, encryptedKeyLen));
+}
+
+int RdRestore(const char *dbFile, const char *backupDbFile, uint8_t *decryptedKey, uint32_t decryptedKeyLen)
+{
+    return TransferGrdErrno(GRD_DBRestore(dbFile, backupDbFile, decryptedKey, decryptedKeyLen));
+}
+
 int RdKVDel(GRD_DB *db, const char *collectionName, const Key &key)
 {
     if (db == nullptr) {
@@ -202,7 +215,11 @@ int RdKvFetch(GRD_ResultSet *resultSet, Key &key, Value &value)
 
 int RdDBClose(GRD_DB *db, uint32_t flags)
 {
-    return TransferGrdErrno(GRD_DBClose(db, flags));
+    int ret = TransferGrdErrno(GRD_DBClose(db, flags));
+    if (ret != E_OK) {
+        LOGE("Can not close db %d", ret);
+    }
+    return ret;
 }
 
 int RdFreeResultSet(GRD_ResultSet *resultSet)
@@ -274,9 +291,30 @@ int RdIndexPreload(GRD_DB *&db, const char *collectionName)
     return TransferGrdErrno(GRD_IndexPreload(db, collectionName));
 }
 
-bool CheckRdOption(const KvStoreNbDelegate::Option &option,
+int RdCreateCollection(GRD_DB *db, const char *collectionName, const char *optionStr, uint32_t flags)
+{
+    return TransferGrdErrno(GRD_CreateCollection(db, collectionName, optionStr, flags));
+}
+
+bool CheckParaOption(const KvStoreNbDelegate::Option &option,
     const std::function<void(DBStatus, KvStoreNbDelegate *)> &callback)
 {
+    if (option.storageEngineType == SQLITE) {
+        if ((option.rdconfig.pageSize < SQLITE_PAGE_SIZE_MIN) ||
+           (option.rdconfig.pageSize > SQLITE_PAGE_SIZE_MAX)) {
+            callback(INVALID_ARGS, nullptr);
+            LOGE("Invalid config pageSize:%" PRIu32, option.rdconfig.pageSize);
+            return false;
+        }
+        if ((option.rdconfig.cacheSize % option.rdconfig.pageSize != 0) ||
+            ((option.rdconfig.pageSize & (option.rdconfig.pageSize - 1)) != 0) ||
+            (option.rdconfig.cacheSize / SQLITE_CACHE_SIZE_PAGE > option.rdconfig.pageSize)) {
+            callback(INVALID_ARGS, nullptr);
+            LOGE("Invalid config pageSize:%" PRIu32 "and cacheSize:%" PRIu32, option.rdconfig.pageSize,
+                option.rdconfig.cacheSize);
+            return false;
+        }
+    }
     if (option.storageEngineType != GAUSSDB_RD && option.storageEngineType != SQLITE) {
         callback(INVALID_ARGS, nullptr);
         return false;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.h b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.h
index 67c4e1162633680d06689c34817d28f56553cc41..703ae25c5d085e82061320d15e42236fc141f364 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/gaussdb_rd/rd_utils.h
@@ -27,7 +27,11 @@
 
 namespace DistributedDB {
 
-const std::string SYNC_COLLECTION_NAME = "naturalbase_kv_sync_data";
+const uint32_t SQLITE_PAGE_SIZE_MIN = 1; // KByte
+const uint32_t SQLITE_PAGE_SIZE_MAX = 64; // KByte
+const uint32_t SQLITE_CACHE_SIZE_PAGE = 2147483647; // Max page number of cache
+
+constexpr const char *SYNC_COLLECTION_NAME = "naturalbase_kv_sync_data";
 
 std::string InitRdConfig();
 
@@ -41,6 +45,11 @@ int RdKVPut(GRD_DB *db, const char *collectionName, const Key &key, const Value
 
 int RdKVGet(GRD_DB *db, const char *collectionName, const Key &key, Value &value);
 
+int RdBackup(GRD_DB *db, const char *backupDbFile, uint8_t *encryptedKey, uint32_t encryptedKeyLen);
+
+int RdRestore(const char *dbFile, const char *backupDbFile, uint8_t *decryptedKey, uint32_t decryptedKeyLen);
+
+// if delete key is not exist in db, return errCode is OK.
 int RdKVDel(GRD_DB *db, const char *collectionName, const Key &key);
 
 int RdKVScan(GRD_DB *db, const char *collectionName, const Key &key, GRD_KvScanModeE mode,
@@ -63,6 +72,7 @@ int RdKVBatchPut(GRD_DB *db, const char *kvTableName, GRD_KVBatchT *batch);
 
 int RdFlush(GRD_DB *db, uint32_t flags);
 
+// if delete key is not exist in db, return errCode is OK.
 int RdKVBatchDel(GRD_DB *db, const char *kvTableName, GRD_KVBatchT *batch);
 
 int RdKVBatchDestroy(GRD_KVBatchT *batch);
@@ -71,7 +81,9 @@ int RdDbOpen(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB *
 
 int RdIndexPreload(GRD_DB *&db, const char *collectionName);
 
-bool CheckRdOption(const KvStoreNbDelegate::Option &option,
+int RdCreateCollection(GRD_DB *db, const char *collectionName, const char *optionStr, uint32_t flags);
+
+bool CheckParaOption(const KvStoreNbDelegate::Option &option,
     const std::function<void(DBStatus, KvStoreNbDelegate *)> &callback);
 } // namespace DistributedDB
 #endif // RD_UTILS_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/generic_kvdb.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/kv/generic_kvdb.cpp
index 10a5946cde66c00d8df017dbfcb328d9aae44246..6ae5ae388e79c85498708d5582a711a57f3e21f2 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/generic_kvdb.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/generic_kvdb.cpp
@@ -123,7 +123,7 @@ void GenericKvDB::CommitNotify(int notifyEvent, KvDBCommitNotifyFilterAbleData *
         data->SetMyDb(this, eventNotifyCounter_);
         data->IncObjRef(data);
         int errCode = RuntimeContext::GetInstance()->ScheduleQueuedTask(GetStoreId(),
-            std::bind(&GenericKvDB::CommitNotifyAsync, this, notifyEvent, data));
+            [this, notifyEvent, data] { CommitNotifyAsync(notifyEvent, data); });
         if (errCode != E_OK) {
             LOGE("Failed to do commit notify, schedule task err:%d.", errCode);
             data->DecObjRef(data);
@@ -148,7 +148,7 @@ void GenericKvDB::CorruptNotify() const
 {
     IncObjRef(this);
     int errCode = RuntimeContext::GetInstance()->ScheduleQueuedTask(GetStoreId(),
-        std::bind(&GenericKvDB::CorruptNotifyAsync, this));
+        [this] { CorruptNotifyAsync(); });
     if (errCode != E_OK) {
         LOGE("Failed to do the corrupt notify, schedule task err:%d.", errCode);
         DecObjRef(this);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/kvdb_manager.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/kv/kvdb_manager.cpp
index c9246b9c936b184d47cc2e0c49120a4b3e190f0d..e4c4c6f922baffc44bef13eb5ce9b3e540b3e739 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/kvdb_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/kvdb_manager.cpp
@@ -865,7 +865,7 @@ void KvDBManager::DataBaseCorruptNotifyAsync(const std::string &appId, const std
     const std::string &storeId)
 {
     int errCode = RuntimeContext::GetInstance()->ScheduleTask(
-        std::bind(&KvDBManager::DataBaseCorruptNotify, this, appId, userId, storeId));
+        [this, appId, userId, storeId] { DataBaseCorruptNotify(appId, userId, storeId); });
     if (errCode != E_OK) {
         LOGE("[KvDBManager][CorruptNotify] ScheduleTask failed, errCode = %d.", errCode);
         return;
@@ -906,10 +906,10 @@ void KvDBManager::RestoreSyncerOfAllKvStore()
 
 bool KvDBManager::CompareSchemaObject(const SchemaObject &newSchema, const SchemaObject &oldSchema)
 {
-    if (!newSchema.IsSchemaValid() && !oldSchema.IsSchemaValid()) {
+    if (!newSchema.IsSchemaValid() && !oldSchema.IsSchemaValid()) { // LCOV_EXCL_BR_LINE
         return true;
     }
-    if (!newSchema.IsSchemaValid() || !oldSchema.IsSchemaValid()) {
+    if (!newSchema.IsSchemaValid() || !oldSchema.IsSchemaValid()) { // LCOV_EXCL_BR_LINE
         return false;
     }
     return (oldSchema.CompareAgainstSchemaObject(newSchema) == -E_SCHEMA_EQUAL_EXACTLY);
@@ -970,36 +970,36 @@ int KvDBManager::CheckKvDBProperties(const IKvDB *kvDB, const KvDBProperties &pr
 {
     // if get from cache is not memoryDb, do not support open or create memory DB
     bool isMemoryDb = properties.GetBoolProp(KvDBProperties::MEMORY_MODE, false);
-    if (isMemoryDb != kvDB->GetMyProperties().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) {
+    if (isMemoryDb != kvDB->GetMyProperties().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) { // LCOV_EXCL_BR_LINE
         LOGE("Already open same id physical DB, so do not support open or create memory DB");
         return -E_INVALID_ARGS;
     }
 
     if (kvDB->GetMyProperties().GetBoolProp(KvDBProperties::CREATE_DIR_BY_STORE_ID_ONLY, false) !=
-        properties.GetBoolProp(KvDBProperties::CREATE_DIR_BY_STORE_ID_ONLY, false)) {
+        properties.GetBoolProp(KvDBProperties::CREATE_DIR_BY_STORE_ID_ONLY, false)) { // LCOV_EXCL_BR_LINE
         LOGE("Different ways to create dir.");
         return -E_INVALID_ARGS;
     }
 
     if (kvDB->GetMyProperties().GetIntProp(KvDBProperties::CONFLICT_RESOLVE_POLICY, 0) !=
-        properties.GetIntProp(KvDBProperties::CONFLICT_RESOLVE_POLICY, 0)) {
+        properties.GetIntProp(KvDBProperties::CONFLICT_RESOLVE_POLICY, 0)) { // LCOV_EXCL_BR_LINE
         LOGE("Different conflict resolve policy.");
         return -E_INVALID_ARGS;
     }
 
     if (kvDB->GetMyProperties().GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE, false) !=
-        properties.GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE, false)) {
+        properties.GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE, false)) { // LCOV_EXCL_BR_LINE
             LOGE("Different dual tuple sync mode");
             return -E_MODE_MISMATCH;
     }
 
     if (kvDB->GetMyProperties().GetBoolProp(KvDBProperties::LOCAL_ONLY, false) !=
-        properties.GetBoolProp(KvDBProperties::LOCAL_ONLY, false)) {
+        properties.GetBoolProp(KvDBProperties::LOCAL_ONLY, false)) { // LCOV_EXCL_BR_LINE
         LOGE("Different local only mode");
         return -E_INVALID_ARGS;
     }
 
-    if (!CheckSecOptions(properties, kvDB->GetMyProperties())) {
+    if (!CheckSecOptions(properties, kvDB->GetMyProperties())) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
@@ -1009,7 +1009,8 @@ int KvDBManager::CheckKvDBProperties(const IKvDB *kvDB, const KvDBProperties &pr
     CipherPassword inputPasswd;
     kvDB->GetMyProperties().GetPassword(cacheType, cachePasswd);
     properties.GetPassword(inputType, inputPasswd);
-    if (isNeedCheckPasswd && (cachePasswd != inputPasswd || !DBCommon::IsSameCipher(cacheType, inputType))) {
+    if (isNeedCheckPasswd && (cachePasswd != inputPasswd ||
+        !DBCommon::IsSameCipher(cacheType, inputType))) { // LCOV_EXCL_BR_LINE
         LOGE("Identification not matched");
         return -E_INVALID_PASSWD_OR_CORRUPTED_DB;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.cpp
index 2a34e7ac44cf05c243da82c4cb06f47f4ad630c5..ac90c3392eee2aae7b844e3644fc77a36700957e 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.cpp
@@ -94,6 +94,15 @@ int SyncAbleKvDB::Sync(const ISyncer::SyncParma &parma, uint64_t connectionId)
     return syncer_.Sync(parma, connectionId);
 }
 
+// Cancel a sync action.
+int SyncAbleKvDB::CancelSync(uint32_t syncId)
+{
+    if (!started_) {
+        return -E_NOT_INIT;
+    }
+    return syncer_.CancelSync(syncId);
+}
+
 void SyncAbleKvDB::EnableAutoSync(bool enable)
 {
     if (NeedStartSyncer()) {
@@ -187,21 +196,33 @@ int SyncAbleKvDB::StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedActiv
     if (isSyncDualTupleMode && isCheckSyncActive && !isNeedActive && (userChangeListener_ == nullptr)) {
         // active to non_active
         userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-            std::bind(&SyncAbleKvDB::ChangeUserListener, this), UserChangeMonitor::USER_ACTIVE_TO_NON_ACTIVE_EVENT);
+            [this](void *) { ChangeUserListener(); }, UserChangeMonitor::USER_ACTIVE_TO_NON_ACTIVE_EVENT);
         LOGI("[KVDB] [StartSyncerWithNoLock] [%.3s] After RegisterUserChangedListener", label.c_str());
     } else if (isSyncDualTupleMode && (userChangeListener_ == nullptr)) {
         EventType event = isNeedActive ?
             UserChangeMonitor::USER_ACTIVE_EVENT : UserChangeMonitor::USER_NON_ACTIVE_EVENT;
         userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-            std::bind(&SyncAbleKvDB::UserChangeHandle, this), event);
+            [this](void *) { UserChangeHandle(); }, event);
         LOGI("[KVDB] [StartSyncerWithNoLock] [%.3s] After RegisterUserChangedListener event=%d", label.c_str(), event);
     }
     return errCode;
 }
 
 // Stop syncer
-void SyncAbleKvDB::StopSyncer(bool isClosedOperation)
+void SyncAbleKvDB::StopSyncer(bool isClosedOperation, bool isStopTaskOnly)
 {
+    {
+        std::unique_lock<std::mutex> lock(cloudSyncerLock_);
+        if (cloudSyncer_ != nullptr) {
+            if (isStopTaskOnly) {
+                cloudSyncer_->StopAllTasks();
+            } else if (isClosedOperation) {
+                cloudSyncer_->Close();
+                RefObject::KillAndDecObjRef(cloudSyncer_);
+                cloudSyncer_ = nullptr;
+            }
+        }
+    }
     NotificationChain::Listener *userChangeListener = nullptr;
     {
         std::unique_lock<std::mutex> lock(syncerOperateLock_);
@@ -209,14 +230,6 @@ void SyncAbleKvDB::StopSyncer(bool isClosedOperation)
         userChangeListener = userChangeListener_;
         userChangeListener_ = nullptr;
     }
-    {
-        std::unique_lock<std::mutex> lock(cloudSyncerLock_);
-        if (isClosedOperation && cloudSyncer_ != nullptr) {
-            cloudSyncer_->Close();
-            RefObject::KillAndDecObjRef(cloudSyncer_);
-            cloudSyncer_ = nullptr;
-        }
-    }
     if (userChangeListener != nullptr) {
         userChangeListener->Drop(true);
         userChangeListener = nullptr;
@@ -225,6 +238,12 @@ void SyncAbleKvDB::StopSyncer(bool isClosedOperation)
 
 void SyncAbleKvDB::StopSyncerWithNoLock(bool isClosedOperation)
 {
+    if (!isClosedOperation && userChangeListener_ != nullptr) {
+        std::unique_lock<std::mutex> lock(cloudSyncerLock_);
+        if (cloudSyncer_ != nullptr) {
+            cloudSyncer_->StopAllTasks();
+        }
+    }
     ReSetSyncModuleActive();
     syncer_.Close(isClosedOperation);
     if (started_) {
@@ -232,7 +251,6 @@ void SyncAbleKvDB::StopSyncerWithNoLock(bool isClosedOperation)
     }
     closed_ = isClosedOperation;
     if (!isClosedOperation && userChangeListener_ != nullptr) {
-        cloudSyncer_->StopAllTasks();
         userChangeListener_->Drop(false);
         userChangeListener_ = nullptr;
     }
@@ -278,7 +296,7 @@ void SyncAbleKvDB::ChangeUserListener()
     }
     if (userChangeListener_ == nullptr) {
         userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-            std::bind(&SyncAbleKvDB::UserChangeHandle, this), UserChangeMonitor::USER_NON_ACTIVE_EVENT);
+            [this](void *) { UserChangeHandle(); }, UserChangeMonitor::USER_NON_ACTIVE_EVENT);
         IKvDBSyncInterface *syncInterface = GetSyncInterface();
         std::string label = syncInterface->GetDbProperties().GetStringProp(DBProperties::IDENTIFIER_DATA, "");
         LOGI("[KVDB] [ChangeUserListener] [%.3s] After RegisterUserChangedListener", label.c_str());
@@ -532,7 +550,8 @@ void SyncAbleKvDB::FillSyncInfo(const CloudSyncOption &option, const SyncProcess
     info.callback = onProcess;
     info.devices = option.devices;
     info.mode = option.mode;
-    info.users = option.users;
+    std::set<std::string> userSet(option.users.begin(), option.users.end());
+    info.users = std::vector<std::string>(userSet.begin(), userSet.end());
     info.lockAction = option.lockAction;
     info.storeId = MyProp().GetStringProp(DBProperties::STORE_ID, "");
     info.merge = option.merge;
@@ -552,7 +571,7 @@ int SyncAbleKvDB::CheckSyncOption(const CloudSyncOption &option, const CloudSync
     auto schemas = GetDataBaseSchemas();
     if (schemas.empty()) {
         LOGE("[SyncAbleKvDB][Sync] not set cloud schema");
-        return -E_CLOUD_ERROR;
+        return -E_SCHEMA_MISMATCH;
     }
     for (const auto &user : option.users) {
         if (cloudDBs.find(user) == cloudDBs.end()) {
@@ -568,6 +587,9 @@ int SyncAbleKvDB::CheckSyncOption(const CloudSyncOption &option, const CloudSync
         LOGE("[SyncAbleKvDB][Sync] invalid wait time of sync option: %lld", option.waitTime);
         return -E_INVALID_ARGS;
     }
+    if (!CheckSchemaSupportForCloudSync()) {
+        return -E_NOT_SUPPORT;
+    }
     return E_OK;
 }
 
@@ -654,4 +676,9 @@ std::map<std::string, DataBaseSchema> SyncAbleKvDB::GetDataBaseSchemas()
 {
     return {};
 }
+
+bool SyncAbleKvDB::CheckSchemaSupportForCloudSync() const
+{
+    return true; // default is valid
+}
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.h b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.h
index 116e1c0068d58b555c710300ebfe9265d47f64c0..99340ace44f6bf181689314112370f162c43a5cb 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb.h
@@ -45,6 +45,9 @@ public:
     // Start a sync action.
     int Sync(const ISyncer::SyncParma &parma, uint64_t connectionId);
 
+    // Cancel a sync action.
+    int CancelSync(uint32_t syncId);
+
     // Enable auto sync
     void EnableAutoSync(bool enable);
 
@@ -122,7 +125,7 @@ protected:
     int StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedActive);
 
     // Stop syncer
-    void StopSyncer(bool isClosedOperation = false);
+    void StopSyncer(bool isClosedOperation = false, bool isStopTaskOnly = false);
 
     void StopSyncerWithNoLock(bool isClosedOperation = false);
 
@@ -140,8 +143,10 @@ protected:
     virtual ICloudSyncStorageInterface *GetICloudSyncInterface() const;
 
     int CleanAllWaterMark();
-
+protected:
     virtual std::map<std::string, DataBaseSchema> GetDataBaseSchemas();
+
+    virtual bool CheckSchemaSupportForCloudSync() const;
 private:
     int RegisterEventType(EventType type);
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.cpp
index 48b82e88eb3322febd8ff1318d09403bbed96595..37d7c2d4be4e09fa18ebee46d37b3bd800d5d1af 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.cpp
@@ -56,6 +56,8 @@ void SyncAbleKvDBConnection::InitPragmaFunc()
     pragmaFunc_ = {
         {PRAGMA_SYNC_DEVICES, [this](void *parameter, int &errCode) {
             errCode = PragmaSyncAction(static_cast<PragmaSync *>(parameter)); }},
+        {PRAGMA_CANCEL_SYNC_DEVICES, [this](void *parameter, int &errCode) {
+            errCode = CancelDeviceSync(*(static_cast<uint32_t *>(parameter))); }},
         {PRAGMA_AUTO_SYNC, [this](void *parameter, int &errCode) {
             errCode = EnableAutoSync(*(static_cast<bool *>(parameter))); }},
         {PRAGMA_PERFORMANCE_ANALYSIS_GET_REPORT, [](void *parameter, int &errCode) {
@@ -150,8 +152,19 @@ int SyncAbleKvDBConnection::PragmaSyncAction(const PragmaSync *syncParameter)
     syncParam.isQuerySync = syncParameter->isQuerySync_;
     syncParam.syncQuery = syncParameter->query_;
     syncParam.onFinalize =  [this]() { DecObjRef(this); };
-    syncParam.onComplete = std::bind(&SyncAbleKvDBConnection::OnSyncComplete, this, std::placeholders::_1,
-        syncParameter->onComplete_, syncParameter->wait_);
+    if (syncParameter->onComplete_) {
+        syncParam.onComplete = [this, onComplete = syncParameter->onComplete_, wait = syncParameter->wait_](
+            const std::map<std::string, int> &statuses) {
+            OnSyncComplete(statuses, onComplete, wait);
+        };
+    }
+    if (syncParameter->onSyncProcess_) {
+        syncParam.onSyncProcess = [this, onSyncProcess = syncParameter->onSyncProcess_](
+            const std::map<std::string, DeviceSyncProcess> &syncRecordMap) {
+            OnDeviceSyncProcess(syncRecordMap, onSyncProcess);
+        };
+    }
+
     int errCode = kvDB->Sync(syncParam, GetConnectionId());
     if (errCode != E_OK) {
         DecObjRef(this);
@@ -159,6 +172,31 @@ int SyncAbleKvDBConnection::PragmaSyncAction(const PragmaSync *syncParameter)
     return errCode;
 }
 
+int SyncAbleKvDBConnection::CancelDeviceSync(uint32_t syncId)
+{
+    SyncAbleKvDB *kvDB = GetDB<SyncAbleKvDB>();
+    if (kvDB == nullptr) {
+        return -E_INVALID_CONNECTION;
+    }
+
+    if (isExclusive_.load()) {
+        return -E_BUSY;
+    }
+    {
+        AutoLock lockGuard(this);
+        if (IsKilled()) {
+            // If this happens, users are using a closed connection.
+            LOGE("CancelDeviceSync on a closed connection.");
+            return -E_STALE;
+        }
+        IncObjRef(this);
+    }
+
+    int errCode = kvDB->CancelSync(syncId);
+    DecObjRef(this);
+    return errCode;
+}
+
 int SyncAbleKvDBConnection::EnableAutoSync(bool enable)
 {
     SyncAbleKvDB *kvDB = GetDB<SyncAbleKvDB>();
@@ -186,6 +224,23 @@ void SyncAbleKvDBConnection::OnSyncComplete(const std::map<std::string, int> &st
     }
 }
 
+void SyncAbleKvDBConnection::OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &syncRecordMap,
+    const DeviceSyncProcessCallback &onProcess)
+{
+    AutoLock lockGuard(this);
+    if (!IsKilled() && onProcess) {
+        // Drop the lock before invoking the callback.
+        // Do pragma-sync again in the prev sync callback is supported.
+        UnlockObj();
+        // The connection may be closed after UnlockObj().
+        // RACE: 'KillObj()' against 'onComplete()'.
+        if (!IsKilled()) {
+            onProcess(syncRecordMap);
+        }
+        LockObj();
+    }
+}
+
 int SyncAbleKvDBConnection::GetQueuedSyncSize(int *queuedSyncSize) const
 {
     if (queuedSyncSize == nullptr) {
@@ -373,7 +428,7 @@ int32_t SyncAbleKvDBConnection::GetTaskCount()
     SyncAbleKvDB *kvDB = GetDB<SyncAbleKvDB>();
     if (kvDB == nullptr) {
         LOGW("[SyncAbleKvDBConnection] Get task count with null db");
-        return 0;
+        return -1;
     }
     return kvDB->GetTaskCount();
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.h b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.h
index f624c86807dacb6fe5b41ea084a2311024c56a58..fac8ef0e89e7f5629afc474da8e2dc7bf8229ccb 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/kv/sync_able_kvdb_connection.h
@@ -57,6 +57,7 @@ private:
     // Do pragma-sync action.
     int PragmaParamCheck(int cmd, const void *parameter);
     int PragmaSyncAction(const PragmaSync *syncParameter);
+    int CancelDeviceSync(uint32_t syncId);
     void InitPragmaFunc();
 
     // If enable is true, it will enable auto sync
@@ -65,6 +66,9 @@ private:
     void OnSyncComplete(const std::map<std::string, int> &statuses,
         const std::function<void(const std::map<std::string, int> &devicesMap)> &onComplete, bool wait);
 
+    void OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &syncRecordMap,
+        const DeviceSyncProcessCallback &onProcess);
+
     int GetQueuedSyncSize(int *queuedSyncSize) const;
 
     int SetQueuedSyncLimit(const int *queuedSyncLimit);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_storage_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_storage_executor.cpp
index a3220acc603e4efe5304c6c70f7915dc57fdf92c..639a260f8b63ea0ea4e0bc66d463c02cdaa2ddcb 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_storage_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/multiver/multi_ver_storage_executor.cpp
@@ -1298,7 +1298,7 @@ int MultiVerStorageExecutor::CommitTransaction(const MultiVerCommitNode &multiVe
 
     Version commitVersion;
     CommitID commitId;
-    UpdateVerTimestamp multiVerTimestamp = {0ull, false};
+    UpdateVerTimestamp multiVerTimestamp = {0ULL, false};
     bool isDataChanged = transaction_->IsDataChanged();
 
     int errCode = dataStorage_->CommitWritePhaseOne(transaction_, multiVerTimestamp);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/operation/database_oper.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/operation/database_oper.cpp
index 22bebe6746c810e65bacf26627bd7626551c104d..0e2b73849f1f7f002f71240357a80e64a6d5bbe9 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/operation/database_oper.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/operation/database_oper.cpp
@@ -321,11 +321,11 @@ int DatabaseOper::RenameStatusCtrlFile(const std::string &orgCtrlFile, const std
 
 int DatabaseOper::RecoverPrehandle(int dbType, const std::string &dir, const std::string &fileName)
 {
-    if (DBCommon::RemoveAllFilesOfDirectory(dir, true) != E_OK) {
+    if (DBCommon::RemoveAllFilesOfDirectory(dir, true) != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Remove the backup dir failed:%d", errno);
         return -E_REMOVE_FILE;
     }
-    if (RemoveFile(fileName) != E_OK) {
+    if (RemoveFile(fileName) != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Remove the pre ctrl file failed:%d", errno);
         return -E_REMOVE_FILE;
     }
@@ -334,23 +334,23 @@ int DatabaseOper::RecoverPrehandle(int dbType, const std::string &dir, const std
 
 int DatabaseOper::RemoveDbDir(const std::string &dir, int dbType, bool isNeedDelDir)
 {
-    if (!OS::CheckPathExistence(dir)) {
+    if (!OS::CheckPathExistence(dir)) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
 
-    if (dbType == DBConstant::DB_TYPE_LOCAL) {
+    if (dbType == DBConstant::DB_TYPE_LOCAL) { // LCOV_EXCL_BR_LINE
         std::vector<std::string> dbNameList = {
             DBConstant::LOCAL_DATABASE_NAME
         };
         return RemoveDbFiles(dir, dbNameList, isNeedDelDir);
     }
-    if (dbType == DBConstant::DB_TYPE_SINGLE_VER) {
+    if (dbType == DBConstant::DB_TYPE_SINGLE_VER) { // LCOV_EXCL_BR_LINE
         std::vector<std::string> dbNameList = {
             DBConstant::SINGLE_VER_DATA_STORE
         };
         return RemoveDbFiles(dir, dbNameList, isNeedDelDir);
     }
-    if (dbType == DBConstant::DB_TYPE_MULTI_VER) {
+    if (dbType == DBConstant::DB_TYPE_MULTI_VER) { // LCOV_EXCL_BR_LINE
         std::vector<std::string> dbNameList = {
             DBConstant::MULTI_VER_DATA_STORE, DBConstant::MULTI_VER_COMMIT_STORE,
             DBConstant::MULTI_VER_VALUE_STORE, DBConstant::MULTI_VER_META_STORE
@@ -391,24 +391,24 @@ int DatabaseOper::RemoveDbFiles(const std::string &dir, const std::vector<std::s
     for (const auto &iter : dbNameList) {
         // remove
         std::string dbFile = dir + "/" + iter + ".db";
-        if (RemoveFile(dbFile) != E_OK) {
+        if (RemoveFile(dbFile) != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Remove the db file failed:%d", errno);
             return -E_REMOVE_FILE;
         }
 
         dbFile = dir + "/" + iter + ".db-wal";
-        if (RemoveFile(dbFile) != E_OK) {
+        if (RemoveFile(dbFile) != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Remove the wal file failed:%d", errno);
             return -E_REMOVE_FILE;
         }
 
         dbFile = dir + "/" + iter + ".db-shm";
-        if (RemoveFile(dbFile) != E_OK) {
+        if (RemoveFile(dbFile) != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Remove the shm file failed:%d", errno);
             return -E_REMOVE_FILE;
         }
     }
-    if (isNeedDelDir && OS::RemoveDBDirectory(dir) != E_OK) {
+    if (isNeedDelDir && OS::RemoveDBDirectory(dir) != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Remove directory:%d", errno);
         return -E_REMOVE_FILE;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/package_file.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/package_file.cpp
index 94d7760e7062c1ad9b0ee7feecdf9a84da83de0d..03ade33e270ce4a2a845c05075312c8bf6b5141a 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/package_file.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/package_file.cpp
@@ -443,28 +443,28 @@ int PackageFile::GetPackageVersion(const std::string &sourceFile, uint32_t &vers
     Parcel parcel(fileHeader.data(), FILE_HEADER_LEN);
 
     ifstream sourceHandle(sourceFile, ios::in | ios::binary);
-    if (!sourceHandle.good()) {
+    if (!sourceHandle.good()) { // LCOV_EXCL_BR_LINE
         LOGE("sourceHandle error, sys err [%d]", errno);
         errCode = -E_INVALID_PATH;
         goto END;
     }
 
     sourceHandle.read(reinterpret_cast<char *>(fileHeader.data()), FILE_HEADER_LEN);
-    if (!sourceHandle.good()) {
+    if (!sourceHandle.good()) { // LCOV_EXCL_BR_LINE
         LOGE("GetPackageVersion read sourceFile handle error!");
         errCode = -E_INVALID_PATH;
         goto END;
     }
 
     errCode = CheckMagicHeader(parcel);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         errCode = -E_INVALID_PATH;
         goto END;
     }
 
     (void)parcel.ReadUInt32(version);
 END:
-    if (errno == EKEYREVOKED) {
+    if (errno == EKEYREVOKED) { // LCOV_EXCL_BR_LINE
         errCode = -E_EKEYREVOKED;
         LOGE("[PackageFile][PackageFiles] Forbid access files by secLabel, errCode [%d].", errCode);
     }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_store_instance.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_store_instance.cpp
index 67cfce0af20e38d64cbe0c9c848c19d2055f9e09..9cd05382f234cd5211fa5e1de49fb6feed70b793 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_store_instance.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_store_instance.cpp
@@ -128,10 +128,16 @@ IRelationalStore *RelationalStoreInstance::OpenDatabase(const RelationalDBProper
     return db;
 }
 
-IRelationalStore *RelationalStoreInstance::GetDataBase(const RelationalDBProperties &properties, int &errCode)
+IRelationalStore *RelationalStoreInstance::GetDataBase(const RelationalDBProperties &properties, int &errCode,
+    bool isNeedIfOpened)
 {
     auto *db = GetFromCache(properties, errCode);
-    if (db != nullptr) {
+    if (db != nullptr && !isNeedIfOpened) {
+        RefObject::DecObjRef(db);
+        errCode = -E_ALREADY_OPENED;
+        LOGI("Database has already been opened.");
+        return nullptr;
+    } else if (db != nullptr) {
         LOGD("Get db from cache.");
         return db;
     }
@@ -185,7 +191,7 @@ int CheckCompatibility(const RelationalDBProperties &prop, const RelationalDBPro
 }
 
 RelationalStoreConnection *RelationalStoreInstance::GetDatabaseConnection(const RelationalDBProperties &properties,
-    int &errCode)
+    int &errCode, bool isNeedIfOpened)
 {
     std::string identifier = properties.GetStringProp(DBProperties::IDENTIFIER_DATA, "");
     LOGD("Begin to get [%s] database connection.", STR_MASK(DBCommon::TransferStringToHex(identifier)));
@@ -196,7 +202,7 @@ RelationalStoreConnection *RelationalStoreInstance::GetDatabaseConnection(const
     }
     manager->EnterDBOpenCloseProcess(properties.GetStringProp(DBProperties::IDENTIFIER_DATA, ""));
     RelationalStoreConnection *connection = nullptr;
-    IRelationalStore *db = GetDataBase(properties, errCode);
+    IRelationalStore *db = GetDataBase(properties, errCode, isNeedIfOpened);
     if (db == nullptr) {
         DBDfxAdapter::ReportBehavior(
             {__func__, Scene::OPEN_CONN, State::BEGIN, Stage::GET_DB, StageResult::FAIL, errCode});
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_sync_able_storage.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_sync_able_storage.cpp
index 4a5f0a6f31643f98aeb1da08ec85d9e2f75255dc..04c846a96e106ffd28ab43199c122d90fd0dcfb2 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_sync_able_storage.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/relational/relational_sync_able_storage.cpp
@@ -418,9 +418,9 @@ int RelationalSyncAbleStorage::GetSyncDataForQuerySync(std::vector<DataItem> &da
         errCode = handle->GetSyncDataByQuery(dataItems,
             Parcel::GetAppendedLen(),
             dataSizeInfo,
-            std::bind(&SQLiteSingleVerRelationalContinueToken::GetStatement, *token,
-                std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4),
-            storageEngine_->GetSchema().GetTable(token->GetQuery().GetTableName()));
+            [token](sqlite3 *db, sqlite3_stmt *&queryStmt, sqlite3_stmt *&fullStmt, bool &isGettingDeletedData) {
+                return token->GetStatement(db, queryStmt, fullStmt, isGettingDeletedData);
+            }, storageEngine_->GetSchema().GetTable(token->GetQuery().GetTableName()));
         if (errCode == -E_FINISHED) {
             token->FinishGetData();
             errCode = token->IsGetAllDataFinished() ? E_OK : -E_UNFINISHED;
@@ -1137,7 +1137,7 @@ int RelationalSyncAbleStorage::GetCloudDataNext(ContinueToken &continueStmtToken
     cloudDataResult.isShared = IsSharedTable(cloudDataResult.tableName);
     auto config = GetCloudSyncConfig();
     transactionHandle_->SetUploadConfig(config.maxUploadCount, config.maxUploadSize);
-    int errCode = transactionHandle_->GetSyncCloudData(cloudDataResult, *token);
+    int errCode = transactionHandle_->GetSyncCloudData(uploadRecorder_, cloudDataResult, *token);
     LOGI("mode:%d upload data, ins:%zu, upd:%zu, del:%zu, lock:%zu", cloudDataResult.mode,
         cloudDataResult.insData.extend.size(), cloudDataResult.updData.extend.size(),
         cloudDataResult.delData.extend.size(), cloudDataResult.lockData.extend.size());
@@ -1165,6 +1165,7 @@ int RelationalSyncAbleStorage::GetCloudGid(const TableSchema &tableSchema, const
     SyncTimeRange syncTimeRange = { .beginTime = beginTime };
     QuerySyncObject query = querySyncObject;
     query.SetSchema(GetSchemaInfo());
+    handle->SetTableSchema(tableSchema);
     errCode = handle->GetSyncCloudGid(query, syncTimeRange, isCloudForcePush, isCompensatedTask, cloudGid);
     ReleaseHandle(handle);
     if (errCode != E_OK) {
@@ -1188,11 +1189,46 @@ int RelationalSyncAbleStorage::ReleaseCloudDataToken(ContinueToken &continueStmt
     return errCode;
 }
 
+int RelationalSyncAbleStorage::GetSchemaFromDB(RelationalSchemaObject &schema)
+{
+    Key schemaKey;
+    DBCommon::StringToVector(DBConstant::RELATIONAL_SCHEMA_KEY, schemaKey);
+    Value schemaVal;
+    int errCode = GetMetaData(schemaKey, schemaVal);
+    if (errCode != E_OK && errCode != -E_NOT_FOUND) {
+        LOGE("Get relational schema from DB failed. %d", errCode);
+        return errCode;
+    } else if (errCode == -E_NOT_FOUND || schemaVal.empty()) {
+        LOGW("No relational schema info was found. error %d size %zu", errCode, schemaVal.size());
+        return -E_NOT_FOUND;
+    }
+    std::string schemaStr;
+    DBCommon::VectorToString(schemaVal, schemaStr);
+    errCode = schema.ParseFromSchemaString(schemaStr);
+    if (errCode != E_OK) {
+        LOGE("Parse schema string from DB failed.");
+        return errCode;
+    }
+    storageEngine_->SetSchema(schema);
+    return errCode;
+}
+
 int RelationalSyncAbleStorage::ChkSchema(const TableName &tableName)
 {
     std::shared_lock<std::shared_mutex> readLock(schemaMgrMutex_);
     RelationalSchemaObject localSchema = GetSchemaInfo();
-    return schemaMgr_.ChkSchema(tableName, localSchema);
+    int errCode = schemaMgr_.ChkSchema(tableName, localSchema);
+    if (errCode == -E_SCHEMA_MISMATCH) {
+        LOGI("Get schema by tableName %s failed.", DBCommon::STR_MASK(tableName));
+        RelationalSchemaObject newSchema;
+        errCode = GetSchemaFromDB(newSchema);
+        if (errCode != E_OK) {
+            LOGE("Get schema from db when check schema.");
+            return errCode;
+        }
+        errCode = schemaMgr_.ChkSchema(tableName, newSchema);
+    }
+    return errCode;
 }
 
 int RelationalSyncAbleStorage::SetCloudDbSchema(const DataBaseSchema &schema)
@@ -1271,7 +1307,23 @@ int RelationalSyncAbleStorage::CleanCloudData(ClearMode mode, const std::vector<
         LOGE("the transaction has not been started");
         return -E_INVALID_DB;
     }
-    return transactionHandle_->DoCleanInner(mode, tableNameList, localSchema, assets);
+    transactionHandle_->SetLogicDelete(logicDelete_);
+    std::vector<std::string> notifyTableList;
+    int errCode = transactionHandle_->DoCleanInner(mode, tableNameList, localSchema, assets, notifyTableList);
+    if (!notifyTableList.empty()) {
+        for (auto notifyTableName : notifyTableList) {
+            ChangedData changedData;
+            changedData.type = ChangedDataType::DATA;
+            changedData.tableName = notifyTableName;
+            std::vector<DistributedDB::Type> dataVec;
+            DistributedDB::Type type = std::string(CloudDbConstant::FLAG_AND_DATA_MODE_NOTIFY);
+            dataVec.push_back(type);
+            changedData.primaryData[ChangeType::OP_DELETE].push_back(dataVec);
+            TriggerObserverAction("CLOUD", std::move(changedData), true);
+        }
+    }
+    transactionHandle_->SetLogicDelete(false);
+    return errCode;
 }
 
 int RelationalSyncAbleStorage::GetCloudTableSchema(const TableName &tableName, TableSchema &tableSchema)
@@ -1782,7 +1834,8 @@ int RelationalSyncAbleStorage::UpdateRecordFlag(const std::string &tableName, bo
         LOGE("[RelationalSyncAbleStorage] the transaction has not been started");
         return -E_INVALID_DB;
     }
-    return transactionHandle_->UpdateRecordFlag(tableName, recordConflict, logInfo);
+    std::string sql = CloudStorageUtils::GetUpdateRecordFlagSql(tableName, recordConflict, logInfo);
+    return transactionHandle_->UpdateRecordFlag(tableName, sql, logInfo);
 }
 
 int RelationalSyncAbleStorage::FillCloudLogAndAssetInner(SQLiteSingleVerRelationalStorageExecutor *handle,
@@ -1799,19 +1852,19 @@ int RelationalSyncAbleStorage::FillCloudLogAndAssetInner(SQLiteSingleVerRelation
         return errCode;
     }
     if (opType == OpType::INSERT) {
-        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.insData);
+        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.insData, CloudWaterType::INSERT);
     } else if (opType == OpType::UPDATE) {
-        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.updData);
+        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.updData, CloudWaterType::UPDATE);
     } else if (opType == OpType::DELETE) {
-        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.delData);
+        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.delData, CloudWaterType::DELETE);
     } else if (opType == OpType::LOCKED_NOT_HANDLE) {
-        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.lockData, true);
+        errCode = UpdateRecordFlagAfterUpload(handle, data.tableName, data.lockData, CloudWaterType::BUTT, true);
     }
     return errCode;
 }
 
 int RelationalSyncAbleStorage::UpdateRecordFlagAfterUpload(SQLiteSingleVerRelationalStorageExecutor *handle,
-    const std::string &tableName, const CloudSyncBatch &updateData, bool isLock)
+    const std::string &tableName, const CloudSyncBatch &updateData, const CloudWaterType &type, bool isLock)
 {
     if (updateData.timestamp.size() != updateData.extend.size()) {
         LOGE("the num of extend:%zu and timestamp:%zu is not equal.",
@@ -1820,7 +1873,11 @@ int RelationalSyncAbleStorage::UpdateRecordFlagAfterUpload(SQLiteSingleVerRelati
     }
     for (size_t i = 0; i < updateData.extend.size(); ++i) {
         const auto &record = updateData.extend[i];
-        if (DBCommon::IsRecordError(record) || DBCommon::IsRecordVersionConflict(record) || isLock) {
+        if (DBCommon::IsRecordError(record) || DBCommon::IsRecordAssetsMissing(record) ||
+            DBCommon::IsRecordVersionConflict(record) || isLock) {
+            if (DBCommon::IsRecordAssetsMissing(record)) {
+                LOGI("[RDBStorage][UpdateRecordFlagAfterUpload] Record assets missing, skip update.");
+            }
             int errCode = handle->UpdateRecordStatus(tableName, CloudDbConstant::TO_LOCAL_CHANGE,
                 updateData.hashKey[i]);
             if (errCode != E_OK) {
@@ -1837,11 +1894,15 @@ int RelationalSyncAbleStorage::UpdateRecordFlagAfterUpload(SQLiteSingleVerRelati
         logInfo.timestamp = updateData.timestamp[i];
         logInfo.dataKey = rowId;
         logInfo.hashKey = updateData.hashKey[i];
-        int errCode = handle->UpdateRecordFlag(tableName, DBCommon::IsRecordIgnored(record), logInfo);
+        std::string sql = CloudStorageUtils::GetUpdateRecordFlagSql(tableName, DBCommon::IsRecordIgnored(record),
+            logInfo, record, type);
+        int errCode = handle->UpdateRecordFlag(tableName, sql, logInfo);
         if (errCode != E_OK) {
             LOGE("[RDBStorage] Update record flag failed in index %zu", i);
             return errCode;
         }
+        handle->MarkFlagAsUploadFinished(tableName, updateData.hashKey[i], updateData.timestamp[i]);
+        uploadRecorder_.RecordUploadRecord(tableName, logInfo.hashKey, type, updateData.timestamp[i]);
     }
     return E_OK;
 }
@@ -1912,7 +1973,7 @@ int RelationalSyncAbleStorage::GetCompensatedSyncQueryInner(SQLiteSingleVerRelat
             continue;
         }
         QuerySyncObject syncObject;
-        errCode = GetSyncQueryByPk(table.name, syncDataPk, syncObject);
+        errCode = CloudStorageUtils::GetSyncQueryByPk(table.name, syncDataPk, false, syncObject);
         if (errCode != E_OK) {
             LOGW("[RDBStorageEngine] Get compensated sync query happen error, ignore it! errCode = %d", errCode);
             errCode = E_OK;
@@ -1934,48 +1995,6 @@ int RelationalSyncAbleStorage::GetCompensatedSyncQueryInner(SQLiteSingleVerRelat
     return errCode;
 }
 
-int RelationalSyncAbleStorage::GetSyncQueryByPk(const std::string &tableName,
-    const std::vector<VBucket> &data, QuerySyncObject &querySyncObject)
-{
-    std::map<std::string, size_t> dataIndex;
-    std::map<std::string, std::vector<Type>> syncPk;
-    int ignoreCount = 0;
-    for (const auto &oneRow : data) {
-        if (oneRow.size() >= 2u) { // mean this data has more than 2 pk
-            LOGW("[RDBStorageEngine] Not support compensated sync with composite primary key now");
-            return -E_NOT_SUPPORT;
-        }
-        for (const auto &[col, value] : oneRow) {
-            bool isFind = dataIndex.find(col) != dataIndex.end();
-            if (!isFind && value.index() == TYPE_INDEX<Nil>) {
-                ignoreCount++;
-                continue;
-            }
-            if (!isFind && value.index() != TYPE_INDEX<Nil>) {
-                dataIndex[col] = value.index();
-                syncPk[col].push_back(value);
-                continue;
-            }
-            if (isFind && dataIndex[col] != value.index()) {
-                ignoreCount++;
-                continue;
-            }
-            syncPk[col].push_back(value);
-        }
-    }
-    LOGI("[RDBStorageEngine] match %zu data for compensated sync, ignore %d", data.size(), ignoreCount);
-    Query query = Query::Select().From(tableName);
-    for (const auto &[col, pkList] : syncPk) {
-        QueryUtils::FillQueryInKeys(col, pkList, dataIndex[col], query);
-    }
-    auto objectList = QuerySyncObject::GetQuerySyncObject(query);
-    if (objectList.size() != 1u) {
-        return -E_INTERNAL_ERROR;
-    }
-    querySyncObject = objectList[0];
-    return E_OK;
-}
-
 int RelationalSyncAbleStorage::CreateTempSyncTriggerInner(SQLiteSingleVerRelationalStorageExecutor *handle,
     const std::string &tableName)
 {
@@ -2024,30 +2043,6 @@ int RelationalSyncAbleStorage::MarkFlagAsConsistent(const std::string &tableName
     return errCode;
 }
 
-void RelationalSyncAbleStorage::SyncFinishHook()
-{
-    if (syncFinishFunc_) {
-        syncFinishFunc_();
-    }
-}
-
-void RelationalSyncAbleStorage::SetSyncFinishHook(const std::function<void (void)> &func)
-{
-    syncFinishFunc_ = func;
-}
-
-void RelationalSyncAbleStorage::DoUploadHook()
-{
-    if (uploadStartFunc_) {
-        uploadStartFunc_();
-    }
-}
-
-void RelationalSyncAbleStorage::SetDoUploadHook(const std::function<void (void)> &func)
-{
-    uploadStartFunc_ = func;
-}
-
 CloudSyncConfig RelationalSyncAbleStorage::GetCloudSyncConfig() const
 {
     std::lock_guard<std::mutex> autoLock(configMutex_);
@@ -2071,5 +2066,41 @@ bool RelationalSyncAbleStorage::IsTableExistReference(const std::string &table)
     }
     return !tableReference.empty();
 }
+
+bool RelationalSyncAbleStorage::IsTableExistReferenceOrReferenceBy(const std::string &table)
+{
+    // check whether reference or reference by exist
+    if (storageEngine_ == nullptr) {
+        LOGE("[IsTableExistReferenceOrReferenceBy] storage is null when get reference gid");
+        return false;
+    }
+    RelationalSchemaObject schema = storageEngine_->GetSchema();
+    auto referenceProperty = schema.GetReferenceProperty();
+    if (referenceProperty.empty()) {
+        return false;
+    }
+    auto [sourceTableName, errCode] = GetSourceTableName(table);
+    if (errCode != E_OK) {
+        return false;
+    }
+    for (const auto &property : referenceProperty) {
+        if (DBCommon::CaseInsensitiveCompare(property.sourceTableName, sourceTableName) ||
+            DBCommon::CaseInsensitiveCompare(property.targetTableName, sourceTableName)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void RelationalSyncAbleStorage::ReleaseUploadRecord(const std::string &tableName, const CloudWaterType &type,
+    Timestamp localMark)
+{
+    uploadRecorder_.ReleaseUploadRecord(tableName, type, localMark);
+}
+
+bool RelationalSyncAbleStorage::IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo)
+{
+    return false;
+}
 }
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.cpp
index 21750611d28ba5b760845611c641322537bff861..27eaca7fea28eca23fb7ddc29ea27b7147de0e95 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.cpp
@@ -18,6 +18,7 @@
 #include "db_common.h"
 #include "platform_specific.h"
 #include "runtime_context.h"
+#include "sqlite_utils.h"
 
 namespace DistributedDB {
 
@@ -155,4 +156,35 @@ void InitCommitNotifyDataKeyStatus(SingleVerNaturalStoreCommitNotifyData *commit
 
     committedData->InitKeyPropRecord(hashKey, existedStatus);
 }
+
+int CheckStoreStatus(const OpenDbProperties &opt)
+{
+    // Check the existence of the database, include the origin database and the database in the 'main' directory.
+    auto mainDbDir = GetDbDir(opt.subdir, DbType::MAIN);
+    auto mainDbFilePath = mainDbDir + "/" + DBConstant::SINGLE_VER_DATA_STORE + DBConstant::DB_EXTENSION;
+    auto origDbFilePath = opt.subdir + "/" + DBConstant::SINGLE_VER_DATA_STORE + DBConstant::DB_EXTENSION;
+    if (!OS::CheckPathExistence(origDbFilePath) && !OS::CheckPathExistence(mainDbFilePath)) {
+        return E_OK;
+    }
+    sqlite3 *db = nullptr;
+    OpenDbProperties checkOpt = opt;
+    if (OS::CheckPathExistence(mainDbFilePath)) {
+        checkOpt.uri = mainDbFilePath;
+    } else {
+        checkOpt.uri = origDbFilePath;
+    }
+    int errCode = SQLiteUtils::OpenDatabase(checkOpt, db);
+    if (db != nullptr) {
+        int ret = sqlite3_close_v2(db);
+        if (ret != E_OK) {
+            LOGW("close db failed %d when check db status", ret);
+        }
+    }
+    if (errCode != E_OK && errCode != -E_EKEYREVOKED) {
+        LOGE("check db status failed %d", errCode);
+    } else {
+        errCode = E_OK;
+    }
+    return errCode;
+}
 } // namespace DistributedDB
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.h b/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.h
index afcb10fc4b59fd0655305aeb79f2ba6db0e1d4b9..6243d39b8902fcbd7f8200d6001d147b2a1f00eb 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/single_ver_utils.h
@@ -65,6 +65,8 @@ int CreateNewDirsAndSetSecOption(const OpenDbProperties &option);
 
 int GetExistedSecOpt(const OpenDbProperties &option, SecurityOption &secOption);
 
+int CheckStoreStatus(const OpenDbProperties &option);
+
 void InitCommitNotifyDataKeyStatus(SingleVerNaturalStoreCommitNotifyData *committedData, const Key &hashKey,
     const DataOperStatus &dataStatus);
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
index bd6a27f0bd5e309a4eacb79b199ded4df1975d73..ed5379071abbef8658b4edc6f56b07d683b8a672 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/query_sync_object.cpp
@@ -500,6 +500,10 @@ int QuerySyncObject::TransformNodeType(const QueryObjNode &objNode, QueryNode &n
         case QueryObjType::END_GROUP:
             node.type = QueryNodeType::END_GROUP;
             break;
+        case QueryObjType::IN_KEYS:
+            node.fieldName = CloudDbConstant::CLOUD_KV_FIELD_KEY;
+            node.type = QueryNodeType::IN;
+            break;
         default:
             LOGE("[Query] not support type %d", static_cast<int>(objNode.operFlag));
             errCode = -E_NOT_SUPPORT;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/cloud_sync_log_table_manager.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/cloud_sync_log_table_manager.cpp
index 1348cb7970bec2350c6f4e69a93a6a01dae833ef..b6302aff78e816f30f6b3ee2c540485e473f264e 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/cloud_sync_log_table_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/cloud_sync_log_table_manager.cpp
@@ -95,9 +95,10 @@ std::string CloudSyncLogTableManager::GetInsertTrigger(const TableInfo &table, c
     std::string insertTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     insertTrigger += "naturalbase_rdb_" + tableName + "_ON_INSERT AFTER INSERT \n";
     insertTrigger += "ON '" + tableName + "'\n";
-    insertTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
+    insertTrigger += "WHEN (SELECT count(*) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     insertTrigger += "WHERE key = 'log_trigger_switch' AND value = 'true')\n";
     insertTrigger += "BEGIN\n";
+    insertTrigger += CloudStorageUtils::GetCursorIncSql(tableName) + "\n";
     insertTrigger += "\t INSERT OR REPLACE INTO " + logTblName;
     insertTrigger += " (data_key, device, ori_device, timestamp, wtimestamp, flag, hash_key, cloud_gid, ";
     insertTrigger += " extend_field, cursor, version, sharing_resource, status)";
@@ -108,10 +109,10 @@ std::string CloudSyncLogTableManager::GetInsertTrigger(const TableInfo &table, c
     insertTrigger += ") THEN (SELECT cloud_gid FROM " + logTblName + " WHERE hash_key = ";
     insertTrigger += CalcPrimaryKeyHash("NEW.", table, identity) + ") ELSE '' END, ";
     insertTrigger += table.GetTrackerTable().GetAssignValSql();
-    insertTrigger += ", case when (SELECT MIN(_rowid_) IS NOT NULL FROM " + logTblName + ") then ";
-    insertTrigger += " (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END";
-    insertTrigger += " FROM " +  logTblName + ")";
-    insertTrigger += " ELSE new." + std::string(DBConstant::SQLITE_INNER_ROWID) + " end, '', '', 0);\n";
+    insertTrigger += ", " + CloudStorageUtils::GetSelectIncCursorSql(tableName) + ", ";
+    insertTrigger += "(SELECT CASE WHEN version IS NULL THEN '' ELSE version END FROM " + logTblName;
+    insertTrigger += " WHERE hash_key = " + CalcPrimaryKeyHash("NEW.", table, identity);
+    insertTrigger += "), '', 0);\n";
     insertTrigger += CloudStorageUtils::GetTableRefUpdateSql(table, OpType::INSERT);
     insertTrigger += "SELECT client_observer('" + tableName + "', NEW." + std::string(DBConstant::SQLITE_INNER_ROWID);
     insertTrigger += ", 0, ";
@@ -129,20 +130,20 @@ std::string CloudSyncLogTableManager::GetUpdateTrigger(const TableInfo &table, c
     std::string updateTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     updateTrigger += "naturalbase_rdb_" + tableName + "_ON_UPDATE AFTER UPDATE \n";
     updateTrigger += "ON '" + tableName + "'\n";
-    updateTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
+    updateTrigger += "WHEN (SELECT count(*) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     updateTrigger += "WHERE key = 'log_trigger_switch' AND value = 'true')\n";
     updateTrigger += "BEGIN\n"; // if user change the primary key, we can still use gid to identify which one is updated
+    updateTrigger += CloudStorageUtils::GetCursorIncSql(tableName) + "\n";
     updateTrigger += "\t UPDATE " + logTblName;
     updateTrigger += " SET timestamp=get_raw_sys_time(), device='', flag=0x02|0x20";
     if (!table.GetTrackerTable().GetTrackerColNames().empty()) {
         updateTrigger += table.GetTrackerTable().GetExtendAssignValSql();
     }
-    updateTrigger += ", cursor = (SELECT case when (MAX(cursor) is null) then 1 else (MAX(cursor) + 1) END ";
-    updateTrigger += " from " + logTblName + "), ";
+    updateTrigger += ", cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName) + ", ";
     updateTrigger += CloudStorageUtils::GetUpdateLockChangedSql();
     updateTrigger += " WHERE data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
     updateTrigger += CloudStorageUtils::GetTableRefUpdateSql(table, OpType::UPDATE);
-    updateTrigger += "select client_observer('" + tableName + "', OLD.";
+    updateTrigger += "SELECT client_observer('" + tableName + "', OLD.";
     updateTrigger += std::string(DBConstant::SQLITE_INNER_ROWID);
     updateTrigger += ", 1, ";
     updateTrigger += table.GetTrackerTable().GetDiffTrackerValSql();
@@ -159,18 +160,21 @@ std::string CloudSyncLogTableManager::GetDeleteTrigger(const TableInfo &table, c
     std::string deleteTrigger = "CREATE TRIGGER IF NOT EXISTS ";
     deleteTrigger += "naturalbase_rdb_" + tableName + "_ON_DELETE BEFORE DELETE \n";
     deleteTrigger += "ON '" + tableName + "'\n";
-    deleteTrigger += "WHEN (SELECT count(*) from " + DBConstant::RELATIONAL_PREFIX + "metadata ";
+    deleteTrigger += "WHEN (SELECT count(*) FROM " + DBConstant::RELATIONAL_PREFIX + "metadata ";
     deleteTrigger += "WHERE key = 'log_trigger_switch' AND VALUE = 'true')\n";
     deleteTrigger += "BEGIN\n";
+    deleteTrigger += CloudStorageUtils::GetCursorIncSql(tableName) + "\n";
     deleteTrigger += "\t UPDATE " + GetLogTableName(table);
     deleteTrigger += " SET data_key=-1,";
-    deleteTrigger += "flag=(CASE WHEN cloud_gid='' then 0x03 else 0x03|0x20 END),";
+    uint32_t localDeleteFlag = static_cast<uint32_t>(LogInfoFlag::FLAG_DELETE) |
+        static_cast<uint32_t>(LogInfoFlag::FLAG_LOCAL);
+    deleteTrigger += "flag=(CASE WHEN cloud_gid='' THEN " + std::to_string(localDeleteFlag) + " ELSE " +
+        std::to_string(localDeleteFlag | static_cast<uint32_t>(LogInfoFlag::FLAG_DEVICE_CLOUD_CONSISTENCY)) + " END),";
     deleteTrigger += "timestamp=get_raw_sys_time()";
     if (!table.GetTrackerTable().GetTrackerColNames().empty()) {
         deleteTrigger += table.GetTrackerTable().GetExtendAssignValSql(true);
     }
-    deleteTrigger += ", cursor = (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END ";
-    deleteTrigger += " FROM " +  logTblName + "), ";
+    deleteTrigger += ", cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName) + ", ";
     deleteTrigger += CloudStorageUtils::GetDeleteLockChangedSql();
     deleteTrigger += " WHERE data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
     deleteTrigger += CloudStorageUtils::GetTableRefUpdateSql(table, OpType::DELETE);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/simple_tracker_log_table_manager.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/simple_tracker_log_table_manager.cpp
index 4e6d2f068147fc7f9d50f7b8c7908edee1c71a23..7511fee9460e0b81dce054a7d57c89a621eb375b 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/simple_tracker_log_table_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/simple_tracker_log_table_manager.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+#include "cloud/cloud_storage_utils.h"
 #include "simple_tracker_log_table_manager.h"
 
 namespace DistributedDB {
@@ -66,6 +67,7 @@ std::string SimpleTrackerLogTableManager::GetInsertTrigger(const TableInfo &tabl
     insertTrigger += "ON '" + tableName + "'\n";
     insertTrigger += " FOR EACH ROW \n";
     insertTrigger += "BEGIN\n";
+    insertTrigger += CloudStorageUtils::GetCursorIncSql(tableName) + "\n";
     insertTrigger += "\t INSERT OR REPLACE INTO " + logTblName;
     insertTrigger += " (data_key, device, ori_device, timestamp, wtimestamp, flag, hash_key, cloud_gid";
     insertTrigger += ", extend_field, cursor, version, sharing_resource, status)";
@@ -73,10 +75,7 @@ std::string SimpleTrackerLogTableManager::GetInsertTrigger(const TableInfo &tabl
     insertTrigger += " get_raw_sys_time(), get_raw_sys_time(), 0x02, ";
     insertTrigger += CalcPrimaryKeyHash("NEW.", table, identity) + ", '', ";
     insertTrigger += table.GetTrackerTable().GetAssignValSql();
-    insertTrigger += ", case when (SELECT MIN(_rowid_) IS NOT NULL FROM " + logTblName + ") then ";
-    insertTrigger += " (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END";
-    insertTrigger += " FROM " +  logTblName + ")";
-    insertTrigger += " ELSE new." + std::string(DBConstant::SQLITE_INNER_ROWID) + " end, '', '', 0);\n";
+    insertTrigger += ", " + CloudStorageUtils::GetSelectIncCursorSql(tableName) + ", '', '', 0);\n";
     insertTrigger += "SELECT client_observer('" + tableName + "', NEW._rowid_, 0, ";
     insertTrigger += table.GetTrackerTable().GetTrackerColNames().empty() ? "0" : "1";
     insertTrigger += ");\n";
@@ -97,12 +96,15 @@ std::string SimpleTrackerLogTableManager::GetUpdateTrigger(const TableInfo &tabl
     updateTrigger += "ON '" + tableName + "'\n";
     updateTrigger += " FOR EACH ROW ";
     updateTrigger += "BEGIN\n"; // if user change the primary key, we can still use gid to identify which one is updated
+    updateTrigger += CloudStorageUtils::GetCursorIncSql(tableName);
+    updateTrigger.pop_back();
+    updateTrigger += " AND " + table.GetTrackerTable().GetDiffTrackerValSql() + ";";
     updateTrigger += "\t UPDATE " + logTblName;
     updateTrigger += " SET timestamp=get_raw_sys_time(), device='', flag=0x02";
     updateTrigger += table.GetTrackerTable().GetExtendAssignValSql();
-    updateTrigger += table.GetTrackerTable().GetDiffIncCursorSql(logTblName);
-    updateTrigger += " where data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
-    updateTrigger += "select client_observer('" + tableName + "', OLD." + std::string(DBConstant::SQLITE_INNER_ROWID);
+    updateTrigger += table.GetTrackerTable().GetDiffIncCursorSql(tableName);
+    updateTrigger += " WHERE data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";\n";
+    updateTrigger += "SELECT client_observer('" + tableName + "', OLD." + std::string(DBConstant::SQLITE_INNER_ROWID);
     updateTrigger += ", 1, ";
     updateTrigger += table.GetTrackerTable().GetDiffTrackerValSql();
     updateTrigger += ");";
@@ -122,11 +124,11 @@ std::string SimpleTrackerLogTableManager::GetDeleteTrigger(const TableInfo &tabl
     deleteTrigger += "ON '" + tableName + "'\n";
     deleteTrigger += " FOR EACH ROW \n";
     deleteTrigger += "BEGIN\n";
+    deleteTrigger += CloudStorageUtils::GetCursorIncSql(tableName) + "\n";
     deleteTrigger += "\t UPDATE " + GetLogTableName(table);
     deleteTrigger += " SET data_key=-1,flag=0x03,timestamp=get_raw_sys_time()";
     deleteTrigger += table.GetTrackerTable().GetExtendAssignValSql(true);
-    deleteTrigger += ", cursor = (SELECT case when (MAX(cursor) is null) then 1 else MAX(cursor) + 1 END ";
-    deleteTrigger += " FROM " + GetLogTableName(table) + ")";
+    deleteTrigger += ", cursor=" + CloudStorageUtils::GetSelectIncCursorSql(tableName) + "";
     deleteTrigger += " WHERE data_key = OLD." + std::string(DBConstant::SQLITE_INNER_ROWID) + ";";
     // -1 is rowid when data is deleted, 2 means change type is delete(ClientChangeType)
     deleteTrigger += "SELECT client_observer('" + tableName + "', -1, 2, ";
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.cpp
index 2d7baf1992910e26b27c73d4bad474c0f5f6bec0..a62a9f64b9ed0cae339b44af9930c07486108dfa 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.cpp
@@ -15,6 +15,7 @@
 
 #include "sqlite_relational_database_upgrader.h"
 
+#include "cloud/cloud_storage_utils.h"
 #include "db_common.h"
 #include "db_constant.h"
 #include "db_errno.h"
@@ -154,7 +155,7 @@ int SqliteRelationalDatabaseUpgrader::UpgradeTrigger(const std::string &logTable
         }
     }
     LOGI("[Relational][UpgradeLogTable] recreate trigger success, ver:%s to ver:%s", logTableVersion.c_str(),
-        DBConstant::LOG_TABLE_VERSION_CURRENT.c_str());
+        DBConstant::LOG_TABLE_VERSION_CURRENT);
     return E_OK;
 }
 
@@ -163,8 +164,7 @@ int SqliteRelationalDatabaseUpgrader::UpgradeLogTable(const std::string &logTabl
 {
     TableInfoMap trackerTables = trackerSchemaObj.GetTrackerTables();
     for (const auto &table : schemaObj.GetTables()) {
-        std::string logName = DBCommon::GetLogTableName(table.first);
-        int errCode = UpgradeLogBaseOnVersion(logTableVersion, logName);
+        int errCode = UpgradeLogBaseOnVersion(logTableVersion, table.first);
         if (errCode != E_OK) {
             LOGE("[Relational][UpgradeLogTable] upgrade distributed log table failed. err:%d", errCode);
             return errCode;
@@ -173,21 +173,21 @@ int SqliteRelationalDatabaseUpgrader::UpgradeLogTable(const std::string &logTabl
     }
     // Need to upgrade non-distributed log table
     for (const auto &table: trackerTables) {
-        std::string logName = DBCommon::GetLogTableName(table.first);
-        int errCode = UpgradeLogBaseOnVersion(logTableVersion, logName);
+        int errCode = UpgradeLogBaseOnVersion(logTableVersion, table.first);
         if (errCode != E_OK) {
             LOGE("[Relational][UpgradeLogTable] upgrade tracker log table failed. err:%d", errCode);
             return errCode;
         }
     }
     LOGI("[Relational][UpgradeLogTable] success, ver:%s to ver:%s", logTableVersion.c_str(),
-        DBConstant::LOG_TABLE_VERSION_CURRENT.c_str());
+        DBConstant::LOG_TABLE_VERSION_CURRENT);
     return E_OK;
 }
 
 int SqliteRelationalDatabaseUpgrader::UpgradeLogBaseOnVersion(const std::string &oldVersion,
-    const std::string &logName)
+    const std::string &tableName)
 {
+    std::string logName = DBCommon::GetLogTableName(tableName);
     TableInfo tableInfo;
     tableInfo.SetTableName(logName);
     int errCode = SQLiteUtils::AnalysisSchemaFieldDefine(db_, logName, tableInfo);
@@ -212,11 +212,14 @@ int SqliteRelationalDatabaseUpgrader::UpgradeLogBaseOnVersion(const std::string
     if (oldVersion < DBConstant::LOG_TABLE_VERSION_5_5) {
         SQLiteRelationalUtils::AddUpgradeSqlToList(tableInfo, { { "status", "int default 0" } }, addColSqlVec);
     }
+    if (oldVersion < DBConstant::LOG_TABLE_VERSION_5_8) {
+        addColSqlVec.push_back(CloudStorageUtils::GetCursorUpgradeSql(tableName));
+    }
     for (size_t i = 0; i < addColSqlVec.size(); ++i) {
         errCode = SQLiteUtils::ExecuteRawSQL(db_, addColSqlVec[i]);
         if (errCode != E_OK) {
             LOGE("[Relational][UpgradeLogTable] add column failed. err:%d, index:%zu, curVer:%s, maxVer:%s", errCode,
-                 i, oldVersion.c_str(), DBConstant::LOG_TABLE_VERSION_CURRENT.c_str());
+                 i, oldVersion.c_str(), DBConstant::LOG_TABLE_VERSION_CURRENT);
             return errCode;
         }
     }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.h
index 153c23e391bd99f2ad779058dbef261fb6951e2a..f515e25e8fa39a0af9a2c59cf338d6afb80a6478 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_database_upgrader.h
@@ -37,7 +37,7 @@ private:
         const RelationalSchemaObject &trackerSchemaObj);
     int UpgradeLogTable(const std::string &logTableVersion, const RelationalSchemaObject &schemaObj,
         const RelationalSchemaObject &trackerSchemaObj);
-    int UpgradeLogBaseOnVersion(const std::string &oldVersion, const std::string &logName);
+    int UpgradeLogBaseOnVersion(const std::string &oldVersion, const std::string &tableName);
     int GetParseSchema(RelationalSchemaObject &schemaObj, RelationalSchemaObject &trackerSchemaObj);
     sqlite3 *db_;
 };
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
index 3a682d8d9f31b8770f2c8e37887ae4b7f72a5e03..83d151178c60d8724e3fd25d8ed9e5342d0ae81f 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.cpp
@@ -124,7 +124,7 @@ int SQLiteRelationalStore::GetSchemaFromMeta(RelationalSchemaObject &schema)
         LOGE("Get relational schema from meta table failed. %d", errCode);
         return errCode;
     } else if (errCode == -E_NOT_FOUND || schemaVal.empty()) {
-        LOGW("No relational schema info was found.");
+        LOGW("No relational schema info was found. error %d size %zu", errCode, schemaVal.size());
         return -E_NOT_FOUND;
     }
 
@@ -227,9 +227,10 @@ int SQLiteRelationalStore::SaveTableModeToMeta(DistributedTableMode mode)
 
 int SQLiteRelationalStore::SaveLogTableVersionToMeta()
 {
-    LOGD("save log table version to meta table, version: %s", DBConstant::LOG_TABLE_VERSION_CURRENT.c_str());
+    LOGD("save log table version to meta table, version: %s", DBConstant::LOG_TABLE_VERSION_CURRENT);
     const Key logVersionKey(DBConstant::LOG_TABLE_VERSION_KEY.begin(), DBConstant::LOG_TABLE_VERSION_KEY.end());
-    Value logVersionVal(DBConstant::LOG_TABLE_VERSION_CURRENT.begin(), DBConstant::LOG_TABLE_VERSION_CURRENT.end());
+    std::string versionStr(DBConstant::LOG_TABLE_VERSION_CURRENT);
+    Value logVersionVal(versionStr.begin(), versionStr.end());
     int errCode = storageEngine_->PutMetaData(logVersionKey, logVersionVal);
     if (errCode != E_OK) {
         LOGE("save log table version to meta table failed. %d", errCode);
@@ -696,7 +697,7 @@ int SQLiteRelationalStore::RegisterLifeCycleCallback(const DatabaseLifeCycleNoti
             return errCode;
         }
     }
-    auto listener = std::bind(&SQLiteRelationalStore::HeartBeat, this);
+    auto listener = [this] { HeartBeat(); };
     storageEngine_->RegisterHeartBeatListener(listener);
     return errCode;
 }
@@ -1078,7 +1079,7 @@ int SQLiteRelationalStore::ChkSchema(const TableName &tableName)
     return storageEngine_->ChkSchema(tableName);
 }
 
-int SQLiteRelationalStore::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess)
+int SQLiteRelationalStore::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess, uint64_t taskId)
 {
     if (storageEngine_ == nullptr) {
         LOGE("[RelationalStore][Sync] storageEngine was not initialized");
@@ -1090,8 +1091,8 @@ int SQLiteRelationalStore::Sync(const CloudSyncOption &option, const SyncProcess
     }
     LOGI("sync mode:%d, pri:%d, comp:%d", option.mode, option.priorityTask, option.compensatedSyncOnly);
     if (option.compensatedSyncOnly) {
-        CloudSyncer::CloudTaskInfo info = CloudSyncUtils::InitCompensatedSyncTaskInfo();
-        info.callback = onProcess;
+        CloudSyncer::CloudTaskInfo info = CloudSyncUtils::InitCompensatedSyncTaskInfo(option, onProcess);
+        info.storeId = sqliteStorageEngine_->GetProperties().GetStringProp(DBProperties::STORE_ID, "");
         cloudSyncer_->GenerateCompensatedSync(info);
         return E_OK;
     }
@@ -1105,7 +1106,9 @@ int SQLiteRelationalStore::Sync(const CloudSyncOption &option, const SyncProcess
     if (ret != E_OK) {
         return ret;
     }
-    return cloudSyncer_->Sync(info);
+    info.taskId = taskId;
+    errCode = cloudSyncer_->Sync(info);
+    return errCode;
 }
 
 int SQLiteRelationalStore::CheckBeforeSync(const CloudSyncOption &option)
@@ -1274,7 +1277,8 @@ int SQLiteRelationalStore::ExecuteSql(const SqlCondition &condition, std::vector
     return sqliteStorageEngine_->ExecuteSql(condition, records);
 }
 
-int SQLiteRelationalStore::CleanWaterMark(std::set<std::string> &clearWaterMarkTable)
+int SQLiteRelationalStore::CleanWaterMark(SQLiteSingleVerRelationalStorageExecutor *&handle,
+    std::set<std::string> &clearWaterMarkTable)
 {
     int errCode = E_OK;
     for (const auto &tableName : clearWaterMarkTable) {
@@ -1290,6 +1294,11 @@ int SQLiteRelationalStore::CleanWaterMark(std::set<std::string> &clearWaterMarkT
             LOGE("[SQLiteRelationalStore] put meta data failed, errCode = %d", errCode);
             return errCode;
         }
+        errCode = handle->CleanUploadFinishedFlag(tableName);
+        if (errCode != E_OK) {
+            LOGE("[SQLiteRelationalStore] clean upload finished flag failed, errCode = %d", errCode);
+            return errCode;
+        }
     }
     errCode = cloudSyncer_->CleanWaterMarkInMemory(clearWaterMarkTable);
     if (errCode != E_OK) {
@@ -1318,7 +1327,7 @@ int SQLiteRelationalStore::SetReference(const std::vector<TableReferenceProperty
 
     if (!clearWaterMarkTables.empty()) {
         storageEngine_->SetReusedHandle(handle);
-        int ret = CleanWaterMark(clearWaterMarkTables);
+        int ret = CleanWaterMark(handle, clearWaterMarkTables);
         if (ret != E_OK) {
             LOGE("[SQLiteRelationalStore] SetReference failed, errCode = %d", ret);
             storageEngine_->SetReusedHandle(nullptr);
@@ -1567,5 +1576,10 @@ int SQLiteRelationalStore::SetCloudSyncConfig(const CloudSyncConfig &config)
     storageEngine_->SetCloudSyncConfig(config);
     return E_OK;
 }
+
+SyncProcess SQLiteRelationalStore::GetCloudTaskStatus(uint64_t taskId)
+{
+    return cloudSyncer_->GetCloudTaskStatus(taskId);
+}
 } //namespace DistributedDB
 #endif
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
index d110eed95264053d7730a38c0dd472450601b080..786691aa6ca3a8f387d129ee488bfb25a3e65293 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store.h
@@ -91,7 +91,7 @@ public:
 
     int ChkSchema(const TableName &tableName);
 
-    int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess);
+    int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess, uint64_t taskId);
 
     int SetTrackerTable(const TrackerSchema &trackerSchema);
 
@@ -106,6 +106,8 @@ public:
     int UpsertData(RecordStatus status, const std::string &tableName, const std::vector<VBucket> &records);
 
     int SetCloudSyncConfig(const CloudSyncConfig &config);
+
+    SyncProcess GetCloudTaskStatus(uint64_t taskId);
 private:
     void ReleaseResources();
 
@@ -154,7 +156,7 @@ private:
     void FillSyncInfo(const CloudSyncOption &option, const SyncProcessCallback &onProcess,
         CloudSyncer::CloudTaskInfo &info);
 
-    int CleanWaterMark(std::set<std::string> &clearWaterMarkTable);
+    int CleanWaterMark(SQLiteSingleVerRelationalStorageExecutor *&handle, std::set<std::string> &clearWaterMarkTable);
 
     int InitTrackerSchemaFromMeta();
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.cpp
index 2c36a9855e48663e20bcc5330099e69812357ed4..45c437bc4097abe5bf37b957263a2c3187f02bb4 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.cpp
@@ -70,7 +70,7 @@ std::string SQLiteRelationalStoreConnection::GetIdentifier()
 SQLiteSingleVerRelationalStorageExecutor *SQLiteRelationalStoreConnection::GetExecutor(bool isWrite, int &errCode) const
 {
     auto *store = GetDB<SQLiteRelationalStore>();
-    if (store == nullptr) {
+    if (store == nullptr) { // LCOV_EXCL_BR_LINE
         errCode = -E_NOT_INIT;
         LOGE("[RelationalConnection] store is null, get executor failed! errCode = [%d]", errCode);
         return nullptr;
@@ -82,7 +82,7 @@ SQLiteSingleVerRelationalStorageExecutor *SQLiteRelationalStoreConnection::GetEx
 void SQLiteRelationalStoreConnection::ReleaseExecutor(SQLiteSingleVerRelationalStorageExecutor *&executor) const
 {
     auto *store = GetDB<SQLiteRelationalStore>();
-    if (store != nullptr) {
+    if (store != nullptr) { // LCOV_EXCL_BR_LINE
         store->ReleaseHandle(executor);
     }
 }
@@ -90,19 +90,19 @@ void SQLiteRelationalStoreConnection::ReleaseExecutor(SQLiteSingleVerRelationalS
 int SQLiteRelationalStoreConnection::StartTransaction()
 {
     std::lock_guard<std::mutex> lock(transactionMutex_);
-    if (writeHandle_ != nullptr) {
+    if (writeHandle_ != nullptr) { // LCOV_EXCL_BR_LINE
         LOGD("Transaction started already.");
         return -E_TRANSACT_STATE;
     }
 
     int errCode = E_OK;
     auto *handle = GetExecutor(true, errCode);
-    if (handle == nullptr) {
+    if (handle == nullptr) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
 
     errCode = handle->StartTransaction(TransactType::DEFERRED);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         ReleaseExecutor(handle);
         return errCode;
     }
@@ -115,7 +115,7 @@ int SQLiteRelationalStoreConnection::StartTransaction()
 int SQLiteRelationalStoreConnection::Commit()
 {
     std::lock_guard<std::mutex> lock(transactionMutex_);
-    if (writeHandle_ == nullptr) {
+    if (writeHandle_ == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("single version database is null or the transaction has not been started");
         return -E_INVALID_DB;
     }
@@ -130,7 +130,7 @@ int SQLiteRelationalStoreConnection::Commit()
 int SQLiteRelationalStoreConnection::RollBack()
 {
     std::lock_guard<std::mutex> lock(transactionMutex_);
-    if (writeHandle_ == nullptr) {
+    if (writeHandle_ == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("Invalid handle for rollback or the transaction has not been started.");
         return -E_INVALID_DB;
     }
@@ -341,27 +341,6 @@ int SQLiteRelationalStoreConnection::SetIAssetLoader(const std::shared_ptr<IAsse
     return ret;
 }
 
-int SQLiteRelationalStoreConnection::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess)
-{
-    auto *store = GetDB<SQLiteRelationalStore>();
-    if (store == nullptr) {
-        LOGE("[RelationalConnection] store is null, get executor failed!");
-        return -E_INVALID_CONNECTION;
-    }
-    {
-        AutoLock lockGuard(this);
-        if (IsKilled()) {
-            // If this happens, users are using a closed connection.
-            LOGE("Sync on a closed connection.");
-            return -E_STALE;
-        }
-        IncObjRef(this);
-    }
-    int errCode = store->Sync(option, onProcess);
-    DecObjRef(this);
-    return errCode;
-}
-
 int SQLiteRelationalStoreConnection::GetStoreInfo(std::string &userId, std::string &appId, std::string &storeId)
 {
     auto *store = GetDB<SQLiteRelationalStore>();
@@ -413,7 +392,7 @@ int SQLiteRelationalStoreConnection::SetReference(const std::vector<TableReferen
 int SQLiteRelationalStoreConnection::CleanTrackerData(const std::string &tableName, int64_t cursor)
 {
     auto *store = GetDB<SQLiteRelationalStore>();
-    if (store == nullptr) {
+    if (store == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalConnection] store is null, get executor failed!");
         return -E_INVALID_CONNECTION;
     }
@@ -444,11 +423,58 @@ int SQLiteRelationalStoreConnection::UpsertData(RecordStatus status, const std::
 int SQLiteRelationalStoreConnection::SetCloudSyncConfig(const CloudSyncConfig &config)
 {
     auto *store = GetDB<SQLiteRelationalStore>();
-    if (store == nullptr) {
+    if (store == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("[RelationalConnection] store is null, set cloud sync config failed!");
         return -E_INVALID_CONNECTION;
     }
     return store->SetCloudSyncConfig(config);
 }
+
+int SQLiteRelationalStoreConnection::Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess,
+    uint64_t taskId)
+{
+    auto *store = GetDB<SQLiteRelationalStore>();
+    if (store == nullptr) {
+        LOGE("[RelationalConnection] store is null, get executor failed!");
+        return -E_INVALID_CONNECTION;
+    }
+    {
+        AutoLock lockGuard(this);
+        if (IsKilled()) {
+            // If this happens, users are using a closed connection.
+            LOGE("[RelationalConnection] Sync on a closed connection.");
+            return -E_STALE;
+        }
+        IncObjRef(this);
+    }
+    int errCode = store->Sync(option, onProcess, taskId);
+    DecObjRef(this);
+    return errCode;
+}
+
+SyncProcess SQLiteRelationalStoreConnection::GetCloudTaskStatus(uint64_t taskId)
+{
+    auto *store = GetDB<SQLiteRelationalStore>();
+    if (store == nullptr) {
+        LOGE("[RelationalConnection] store is null, get executor failed!");
+        SyncProcess process;
+        process.errCode = DB_ERROR;
+        return process;
+    }
+    {
+        AutoLock lockGuard(this);
+        if (IsKilled()) {
+            // If this happens, users are using a closed connection.
+            LOGE("[RelationalConnection] Get sync task on a closed connection.");
+            SyncProcess process;
+            process.errCode = DB_ERROR;
+            return process;
+        }
+        IncObjRef(this);
+    }
+    SyncProcess process = store->GetCloudTaskStatus(taskId);
+    DecObjRef(this);
+    return process;
+}
 }
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.h
index 6d248ea4489c3c538070e214a8364f2d9fc1c93d..0107f9b2faffff873200562aeed76338c6985d67 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_store_connection.h
@@ -51,8 +51,6 @@ public:
     int PrepareAndSetCloudDbSchema(const DataBaseSchema &schema) override;
     int SetIAssetLoader(const std::shared_ptr<IAssetLoader> &loader) override;
 
-    int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess) override;
-
     int GetStoreInfo(std::string &userId, std::string &appId, std::string &storeId) override;
 
     int SetTrackerTable(const TrackerSchema &schema) override;
@@ -66,6 +64,10 @@ public:
     int UpsertData(RecordStatus status, const std::string &tableName, const std::vector<VBucket> &records) override;
 
     int SetCloudSyncConfig(const CloudSyncConfig &config) override;
+
+    int Sync(const CloudSyncOption &option, const SyncProcessCallback &onProcess, uint64_t taskId) override;
+
+    SyncProcess GetCloudTaskStatus(uint64_t taskId) override;
 protected:
 
     int Pragma(int cmd, void *parameter) override;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_utils.cpp
index b61cf9d50153f67143b66a51f5af182d6fa0204d..5dd72f49421e0779169eabb6843493b78522b0a6 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_relational_utils.cpp
@@ -276,12 +276,12 @@ int SQLiteRelationalUtils::GetTypeValByStatement(sqlite3_stmt *stmt, int cid, Ty
     switch (sqlite3_column_type(stmt, cid)) {
         case SQLITE_INTEGER: {
             const char *declType = sqlite3_column_decltype(stmt, cid);
-            if (declType == nullptr) {
+            if (declType == nullptr) { // LCOV_EXCL_BR_LINE
                 typeVal = static_cast<int64_t>(sqlite3_column_int64(stmt, cid));
                 break;
             }
             if (strcasecmp(declType, SchemaConstant::KEYWORD_TYPE_BOOL.c_str()) == 0 ||
-                strcasecmp(declType, SchemaConstant::KEYWORD_TYPE_BOOLEAN.c_str()) == 0) {
+                strcasecmp(declType, SchemaConstant::KEYWORD_TYPE_BOOLEAN.c_str()) == 0) { // LCOV_EXCL_BR_LINE
                 typeVal = static_cast<bool>(sqlite3_column_int(stmt, cid));
                 break;
             }
@@ -298,7 +298,7 @@ int SQLiteRelationalUtils::GetTypeValByStatement(sqlite3_stmt *stmt, int cid, Ty
         }
         case SQLITE3_TEXT: {
             errCode = GetBlobByStatement(stmt, cid, typeVal);
-            if (errCode != E_OK || typeVal.index() != TYPE_INDEX<Nil>) {
+            if (errCode != E_OK || typeVal.index() != TYPE_INDEX<Nil>) { // LCOV_EXCL_BR_LINE
                 break;
             }
             std::string str;
@@ -317,34 +317,34 @@ int SQLiteRelationalUtils::GetBlobByStatement(sqlite3_stmt *stmt, int cid, Type
 {
     const char *declType = sqlite3_column_decltype(stmt, cid);
     int errCode = E_OK;
-    if (declType != nullptr && strcasecmp(declType, CloudDbConstant::ASSET) == 0) {
+    if (declType != nullptr && strcasecmp(declType, CloudDbConstant::ASSET) == 0) { // LCOV_EXCL_BR_LINE
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(stmt, cid, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             return errCode;
         }
         Asset asset;
         errCode = RuntimeContext::GetInstance()->BlobToAsset(blobValue, asset);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             return errCode;
         }
         typeVal = asset;
     } else if (declType != nullptr && strcasecmp(declType, CloudDbConstant::ASSETS) == 0) {
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(stmt, cid, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             return errCode;
         }
         Assets assets;
         errCode = RuntimeContext::GetInstance()->BlobToAssets(blobValue, assets);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             return errCode;
         }
         typeVal = assets;
     } else if (sqlite3_column_type(stmt, cid) == SQLITE_BLOB) {
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(stmt, cid, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             return errCode;
         }
         typeVal = blobValue;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
index 4150ede839c8b0649720b5cac395dafcb5cac9f1..f4c49cbe40a2b7a97840ce32f1e239bf957e903e 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_relational_storage_engine.cpp
@@ -192,8 +192,9 @@ int SaveSyncTableTypeAndDropFlagToMeta(SQLiteSingleVerRelationalStorageExecutor
     errCode = handle->DeleteMetaData({ key });
     if (errCode != E_OK) {
         LOGE("Save table drop flag to meta table failed. %d", errCode);
+        return errCode;
     }
-    return errCode;
+    return handle->InitCursorToMeta(tableName);
 }
 }
 
@@ -245,7 +246,7 @@ int SQLiteSingleRelationalStorageEngine::CreateDistributedSharedTable(SQLiteSing
     table.SetSharedTableMark(true);
     table.SetTableSyncType(tableSyncType);
     table.SetTrackerTable(trackerSchema_.GetTrackerTable(sharedTableName));
-    if (!table.GetTrackerTable().IsEmpty() && tableSyncType == TableSyncType::DEVICE_COOPERATION) {
+    if (!table.GetTrackerTable().IsEmpty() && tableSyncType == TableSyncType::DEVICE_COOPERATION) { // LCOV_EXCL_BR_LINE
         LOGE("current is trackerTable, not support creating device distributed table.");
         return -E_NOT_SUPPORT;
     }
@@ -500,7 +501,7 @@ int SQLiteSingleRelationalStorageEngine::CheckAndCacheTrackerSchema(const Tracke
         return errCode;
     }
     RelationalSchemaObject tracker = trackerSchema_;
-    if (!tracker.GetTrackerTable(schema.tableName).IsChanging(schema)) {
+    if (!tracker.GetTrackerTable(schema.tableName).IsChanging(schema)) { // LCOV_EXCL_BR_LINE
         ReleaseExecutor(handle);
         LOGW("tracker schema is no change for distributed table.");
         return -E_IGNORE_DATA;
@@ -542,7 +543,7 @@ int SQLiteSingleRelationalStorageEngine::GetOrInitTrackerSchemaFromMeta()
     for (const auto &iter: tableInfoMap) {
         TableInfo tableInfo;
         errCode = handle->AnalysisTrackerTable(iter.second.GetTrackerTable(), tableInfo);
-        if (errCode == -E_NOT_FOUND) {
+        if (errCode == -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             const std::string trackerTableName = iter.second.GetTrackerTable().GetTableName();
             errCode = CleanTrackerDeviceTable({ trackerTableName }, trackerSchema, handle);
             if (errCode != E_OK) {
@@ -550,7 +551,7 @@ int SQLiteSingleRelationalStorageEngine::GetOrInitTrackerSchemaFromMeta()
                 ReleaseExecutor(handle);
                 return errCode;
             }
-        } else if (errCode != E_OK) {
+        } else if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("the tracker schema does not match the tracker schema. %d", errCode);
             ReleaseExecutor(handle);
             return errCode;
@@ -679,7 +680,7 @@ int SQLiteSingleRelationalStorageEngine::CleanTrackerData(const std::string &tab
     int errCode = E_OK;
     auto *handle = static_cast<SQLiteSingleVerRelationalStorageExecutor *>(FindExecutor(true, OperatePerm::NORMAL_PERM,
         errCode));
-    if (handle == nullptr) {
+    if (handle == nullptr) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
     errCode = handle->CleanTrackerData(tableName, cursor);
@@ -976,11 +977,11 @@ int SQLiteSingleRelationalStorageEngine::CleanTrackerDeviceTable(const std::vect
 {
     std::vector<std::string> missingTrackerTables;
     int errCode = handle->CheckAndCleanDistributedTable(tableNames, missingTrackerTables);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Check tracker table failed. %d", errCode);
         return errCode;
     }
-    if (missingTrackerTables.empty()) {
+    if (missingTrackerTables.empty()) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
     for (const auto &tableName : missingTrackerTables) {
@@ -989,7 +990,7 @@ int SQLiteSingleRelationalStorageEngine::CleanTrackerDeviceTable(const std::vect
         trackerSchemaObj.RemoveTrackerSchema(schema);
     }
     errCode = SaveTrackerSchemaToMetaTable(handle, trackerSchemaObj); // save schema to meta_data
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Save tracker schema to metaTable failed. %d", errCode);
     }
     return errCode;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_continue_token.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_continue_token.cpp
index 1d6104522e5ddc30e18de1999b19132f5376955d..8777844b7edd9d07d47f125f7703870f643d3a6a 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_continue_token.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_continue_token.cpp
@@ -18,8 +18,8 @@
 
 namespace DistributedDB {
 SQLiteSingleVerRelationalContinueToken::SQLiteSingleVerRelationalContinueToken(
-    const SyncTimeRange &timeRange, const QueryObject &object)
-    : isGettingDeletedData_(false), queryObj_(object), tableName_(queryObj_.GetTableName()), timeRange_(timeRange)
+    const SyncTimeRange &timeRange, const QueryObject &queryObject)
+    : isGettingDeletedData_(false), queryObj_(queryObject), tableName_(queryObj_.GetTableName()), timeRange_(timeRange)
 {}
 
 bool SQLiteSingleVerRelationalContinueToken::CheckValid() const
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.cpp
index d46bef53a4a3d806ceee743c6d4fecd3c31e0ab2..dad010cdc57b6c8ac7a70a3323634da72f6455a9 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.cpp
@@ -28,6 +28,7 @@
 #include "runtime_context.h"
 #include "sqlite_meta_executor.h"
 #include "sqlite_relational_utils.h"
+#include "time_helper.h"
 #include "value_hash_calc.h"
 
 namespace DistributedDB {
@@ -38,11 +39,15 @@ static constexpr const char *CLOUD_GID_FIELD = "CLOUD_GID";
 static constexpr const char *VERSION = "VERSION";
 static constexpr const char *SHARING_RESOURCE = "SHARING_RESOURCE";
 static constexpr const char *FLAG_IS_CLOUD = "FLAG & 0x02 = 0"; // see if 1th bit of a flag is cloud
+static constexpr const char *FLAG_IS_CLOUD_CONSISTENCY = "FLAG & 0x20 = 0"; // see if flag is cloud_consistency
 // set 1th bit of flag to one which is local, clean 5th bit of flag to one which is wait compensated sync
 static constexpr const char *SET_FLAG_LOCAL_AND_CLEAN_WAIT_COMPENSATED_SYNC = "(CASE WHEN data_key = -1 and "
     "FLAG & 0x02 = 0x02 THEN (FLAG | 0x02) & (~0x10) & (~0x20) ELSE (FLAG | 0x02 | 0x20) & (~0x10) END)";
 static constexpr const char *FLAG_IS_LOGIC_DELETE = "FLAG & 0x08 != 0"; // see if 3th bit of a flag is logic delete
+// set data logic delete and exist passport
+static constexpr const char *SET_FLAG_LOGIC_DELETE = "(FLAG | 0x08 | 0x800 | 0x01) & (~0x02)";
 static constexpr const char *DATA_IS_DELETE = "data_key = -1 AND FLAG & 0X08 = 0"; // see if data is delete
+static constexpr const char *UPDATE_CURSOR_SQL = "cursor=update_cursor()";
 static constexpr const int SET_FLAG_ZERO_MASK = ~0x04; // clear 2th bit of flag
 static constexpr const int SET_FLAG_ONE_MASK = 0x04; // set 2th bit of flag
 static constexpr const int SET_CLOUD_FLAG = ~0x02; // set 1th bit of flag to 0
@@ -158,26 +163,40 @@ int SQLiteSingleVerRelationalStorageExecutor::GeneLogInfoForExistedData(sqlite3
     if (errCode != E_OK) {
         return errCode;
     }
+    errCode = SetLogTriggerStatus(false);
+    if (errCode != E_OK) {
+        return errCode;
+    }
     std::string timeOffsetStr = std::to_string(timeOffset);
     std::string logTable = DBConstant::RELATIONAL_PREFIX + tableName + "_log";
-    std::string sql = "INSERT OR REPLACE INTO " + logTable + " SELECT " + std::string(DBConstant::SQLITE_INNER_ROWID) +
-        ", '', '', " + timeOffsetStr + " + " + std::string(DBConstant::SQLITE_INNER_ROWID) + ", " +
-        timeOffsetStr + " + " + std::string(DBConstant::SQLITE_INNER_ROWID) +  ", " +
-        std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_LOCAL) |
-            static_cast<uint32_t>(LogInfoFlag::FLAG_DEVICE_CLOUD_CONSISTENCY)) +
-        ", " + calPrimaryKeyHash + ", '', ";
+    std::string rowid = std::string(DBConstant::SQLITE_INNER_ROWID);
+    std::string flag = std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_LOCAL) |
+        static_cast<uint32_t>(LogInfoFlag::FLAG_DEVICE_CLOUD_CONSISTENCY));
     if (tableInfo.GetTableSyncType() == TableSyncType::DEVICE_COOPERATION) {
-        sql += "'', ''";
-    } else {
-        sql += tableInfo.GetTrackerTable().GetExtendName().empty() ? "''" : tableInfo.GetTrackerTable().GetExtendName();
-        sql += ", case when (SELECT count(1)<>0 FROM " + logTable + ")" +
-            " then ((SELECT CASE WHEN MAX(cursor) IS NULL THEN 0 ELSE MAX(cursor) END FROM " + logTable + ") + " +
-            std::string(DBConstant::SQLITE_INNER_ROWID) +
-            ") ELSE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " end";
+        std::string sql = "INSERT OR REPLACE INTO " + logTable + " SELECT " + rowid + ", '', '', " + timeOffsetStr +
+            " + " + rowid + ", " + timeOffsetStr + " + " + rowid + ", " + flag + ", " + calPrimaryKeyHash + ", '', " +
+            "'', '', '', '', 0 FROM '" + tableName + "' AS a WHERE 1=1;";
+        errCode = SQLiteUtils::ExecuteRawSQL(db, sql);
+        if (errCode != E_OK) {
+            LOGE("Failed to initialize device type log data.%d", errCode);
+        }
+        return errCode;
     }
-    sql += ", '', '', 0";
-    sql += " FROM '" + tableName + "' AS a WHERE 1=1;";
-    return SQLiteUtils::ExecuteRawSQL(db, sql);
+    TrackerTable trackerTable = tableInfo.GetTrackerTable();
+    trackerTable.SetTableName(tableName);
+    std::string sql = "INSERT OR REPLACE INTO " + logTable + " SELECT " + rowid +
+        ", '', '', " + timeOffsetStr + " + " + rowid + ", " +
+        timeOffsetStr + " + " + rowid + ", " + flag + ", " + calPrimaryKeyHash + ", '', ";
+    sql += tableInfo.GetTrackerTable().GetExtendName().empty() ? "''" : tableInfo.GetTrackerTable().GetExtendName();
+    sql += ", 0, '', '', 0 FROM '" + tableName + "' AS a WHERE 1=1;";
+    errCode = trackerTable.ReBuildTempTrigger(db, TriggerMode::TriggerModeEnum::INSERT, [db, &sql]() {
+        int ret = SQLiteUtils::ExecuteRawSQL(db, sql);
+        if (ret != E_OK) {
+            LOGE("Failed to initialize cloud type log data.%d", ret);
+        }
+        return ret;
+    });
+    return errCode;
 }
 
 int SQLiteSingleVerRelationalStorageExecutor::CreateDistributedTable(DistributedTableMode mode, bool isUpgraded,
@@ -225,9 +244,9 @@ int SQLiteSingleVerRelationalStorageExecutor::CreateDistributedTable(Distributed
     if (!isUpgraded) {
         std::string calPrimaryKeyHash = tableManager->CalcPrimaryKeyHash("a.", table, identity);
         errCode = GeneLogInfoForExistedData(dbHandle_, tableName, calPrimaryKeyHash, table);
-    }
-    if (errCode != E_OK) {
-        return errCode;
+        if (errCode != E_OK) {
+            return errCode;
+        }
     }
 
     // add trigger
@@ -541,8 +560,16 @@ static int GetLogData(sqlite3_stmt *logStatement, LogInfo &logInfo)
 namespace {
 void GetCloudLog(sqlite3_stmt *logStatement, VBucket &logInfo, uint32_t &totalSize)
 {
-    logInfo.insert_or_assign(CloudDbConstant::MODIFY_FIELD,
-        static_cast<int64_t>(sqlite3_column_int64(logStatement, TIMESTAMP_INDEX)));
+    int64_t modifyTime = static_cast<int64_t>(sqlite3_column_int64(logStatement, TIMESTAMP_INDEX));
+    uint64_t curTime = 0;
+    if (TimeHelper::GetSysCurrentRawTime(curTime) == E_OK) {
+        if (modifyTime > static_cast<int64_t>(curTime)) {
+            modifyTime = static_cast<int64_t>(curTime);
+        }
+    } else {
+        LOGW("[Relational] get raw sys time failed.");
+    }
+    logInfo.insert_or_assign(CloudDbConstant::MODIFY_FIELD, modifyTime);
     logInfo.insert_or_assign(CloudDbConstant::CREATE_FIELD,
         static_cast<int64_t>(sqlite3_column_int64(logStatement, W_TIMESTAMP_INDEX)));
     totalSize += sizeof(int64_t) + sizeof(int64_t);
@@ -1622,8 +1649,8 @@ int SQLiteSingleVerRelationalStorageExecutor::UpdateCloudLogGid(const CloudSyncD
     return errCode == E_OK ? resetCode : errCode;
 }
 
-int SQLiteSingleVerRelationalStorageExecutor::GetSyncCloudData(CloudSyncData &cloudDataResult,
-    SQLiteSingleVerRelationalContinueToken &token)
+int SQLiteSingleVerRelationalStorageExecutor::GetSyncCloudData(const CloudUploadRecorder &uploadRecorder,
+    CloudSyncData &cloudDataResult, SQLiteSingleVerRelationalContinueToken &token)
 {
     token.GetCloudTableSchema(tableSchema_);
     sqlite3_stmt *queryStmt = nullptr;
@@ -1644,7 +1671,7 @@ int SQLiteSingleVerRelationalStorageExecutor::GetSyncCloudData(CloudSyncData &cl
             }
         }
         isStepNext = true;
-        errCode = GetCloudDataForSync(queryStmt, cloudDataResult, ++stepNum, totalSize);
+        errCode = GetCloudDataForSync(uploadRecorder, queryStmt, cloudDataResult, ++stepNum, totalSize);
     } while (errCode == E_OK);
     if (errCode != -E_UNFINISHED) {
         (void)token.ReleaseCloudStatement();
@@ -1682,8 +1709,8 @@ int SQLiteSingleVerRelationalStorageExecutor::GetSyncCloudGid(QuerySyncObject &q
     return (errCode == E_OK ? resetStatementErrCode : errCode);
 }
 
-int SQLiteSingleVerRelationalStorageExecutor::GetCloudDataForSync(sqlite3_stmt *statement,
-    CloudSyncData &cloudDataResult, uint32_t &stepNum, uint32_t &totalSize)
+int SQLiteSingleVerRelationalStorageExecutor::GetCloudDataForSync(const CloudUploadRecorder &uploadRecorder,
+    sqlite3_stmt *statement, CloudSyncData &cloudDataResult, uint32_t &stepNum, uint32_t &totalSize)
 {
     VBucket log;
     VBucket extraLog;
@@ -1714,7 +1741,7 @@ int SQLiteSingleVerRelationalStorageExecutor::GetCloudDataForSync(sqlite3_stmt *
     }
 
     if (CloudStorageUtils::IsGetCloudDataContinue(stepNum, totalSize, maxUploadSize_, maxUploadCount_)) {
-        errCode = CloudStorageUtils::IdentifyCloudType(cloudDataResult, data, log, extraLog);
+        errCode = CloudStorageUtils::IdentifyCloudType(uploadRecorder, cloudDataResult, data, log, extraLog);
     } else {
         errCode = -E_UNFINISHED;
     }
@@ -1775,21 +1802,38 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanCloudDataOnLogTable(const std
         return errCode;
     }
     cleanLogSql = "DELETE FROM " + logTableName + " WHERE " + FLAG_IS_CLOUD + " AND " + DATA_IS_DELETE + ";";
+    errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, cleanLogSql);
+    if (errCode != E_OK) {
+        LOGE("delete cloud log failed, %d", errCode);
+        return errCode;
+    }
+    // set all flag logout and data upload is not finished.
+    cleanLogSql = "UPDATE " + logTableName + " SET " + CloudDbConstant::FLAG + " = flag | 0x800 & ~0x400;";
     return SQLiteUtils::ExecuteRawSQL(dbHandle_, cleanLogSql);
 }
 
+int SQLiteSingleVerRelationalStorageExecutor::CleanUploadFinishedFlag(const std::string &tableName)
+{
+    // unset upload finished flag
+    std::string cleanUploadFinishedSql = "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET " +
+        CloudDbConstant::FLAG + " = flag & ~0x400;";
+    return SQLiteUtils::ExecuteRawSQL(dbHandle_, cleanUploadFinishedSql);
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::CleanCloudDataAndLogOnUserTable(const std::string &tableName,
     const std::string &logTableName, const RelationalSchemaObject &localSchema)
 {
     std::string sql = "DELETE FROM '" + tableName + "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) +
         " IN (SELECT " + DATAKEY + " FROM '" + logTableName + "' WHERE (" + FLAG_IS_LOGIC_DELETE +
-        ") OR CLOUD_GID IS NOT NULL AND CLOUD_GID != '' AND " + FLAG_IS_CLOUD + ");";
+        ") OR CLOUD_GID IS NOT NULL AND CLOUD_GID != '' AND (" + FLAG_IS_CLOUD + " OR " + FLAG_IS_CLOUD_CONSISTENCY +
+        "));";
     int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
     if (errCode != E_OK) {
         LOGE("Failed to delete cloud data on usertable, %d.", errCode);
         return errCode;
     }
-    std::string cleanLogSql = "DELETE FROM '" + logTableName + "' WHERE " + FLAG_IS_CLOUD + ";";
+    std::string cleanLogSql = "DELETE FROM '" + logTableName + "' WHERE " + FLAG_IS_CLOUD + " OR " +
+        FLAG_IS_CLOUD_CONSISTENCY + ";";
     errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, cleanLogSql);
     if (errCode != E_OK) {
         LOGE("Failed to delete cloud data on log table, %d.", errCode);
@@ -1807,6 +1851,58 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanCloudDataAndLogOnUserTable(co
     return errCode;
 }
 
+int SQLiteSingleVerRelationalStorageExecutor::ChangeCloudDataFlagOnLogTable(const std::string &logTableName)
+{
+    std::string cleanLogSql = "UPDATE " + logTableName + " SET " + CloudDbConstant::FLAG + " = " +
+        SET_FLAG_LOCAL_AND_CLEAN_WAIT_COMPENSATED_SYNC + ", " + VERSION + " = '', " + DEVICE_FIELD + " = '', " +
+        CLOUD_GID_FIELD + " = '', " + SHARING_RESOURCE + " = '' " + "WHERE NOT " + FLAG_IS_CLOUD_CONSISTENCY + ";";
+    int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, cleanLogSql);
+    if (errCode != E_OK) {
+        LOGE("change cloud log flag failed, %d", errCode);
+    }
+    return errCode;
+}
+
+int SQLiteSingleVerRelationalStorageExecutor::SetDataOnUserTablWithLogicDelete(const std::string &tableName,
+    const std::string &logTableName)
+{
+    UpdateCursorContext context;
+    context.cursor = GetCursor(tableName);
+    LOGI("removeData start and cursor is, %d.", context.cursor);
+    int errCode = CreateFuncUpdateCursor(context, &UpdateCursor);
+    std::string sql = "UPDATE '" + logTableName + "' SET " + CloudDbConstant::FLAG + " = " + SET_FLAG_LOGIC_DELETE +
+                      ", " + VERSION + " = '', " + DEVICE_FIELD + " = '', " + CLOUD_GID_FIELD + " = '', " +
+                      SHARING_RESOURCE + " = '', " + UPDATE_CURSOR_SQL +
+                      " WHERE (CLOUD_GID IS NOT NULL AND CLOUD_GID != '' AND " + FLAG_IS_CLOUD_CONSISTENCY + ");";
+    errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
+    if (errCode != E_OK) {
+        LOGE("Failed to change cloud data flag on usertable, %d.", errCode);
+        CreateFuncUpdateCursor(context, nullptr);
+        return errCode;
+    }
+    // deal when data is logicDelete
+    sql = "UPDATE '" + logTableName + "' SET " + VERSION + " = '', " + DEVICE_FIELD + " = '', " + CLOUD_GID_FIELD +
+          " = '', " + SHARING_RESOURCE + " = '' WHERE " + FLAG_IS_LOGIC_DELETE + ";";
+    errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
+    if (errCode != E_OK) {
+        LOGE("Failed to deal logic delete data flag on usertable, %d.", errCode);
+        CreateFuncUpdateCursor(context, nullptr);
+        return errCode;
+    }
+    LOGI("removeData finish and cursor is %d.", context.cursor);
+    errCode = SetCursor(tableName, context.cursor);
+    if (errCode != E_OK) {
+        CreateFuncUpdateCursor(context, nullptr);
+        LOGE("set new cursor after removeData error %d.", errCode);
+        return errCode;
+    }
+    errCode = CreateFuncUpdateCursor(context, nullptr);
+    if (errCode != E_OK) {
+        LOGE("Clear FuncUpdateCursor error %d.", errCode);
+    }
+    return ChangeCloudDataFlagOnLogTable(logTableName);
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::GetCleanCloudDataKeys(const std::string &logTableName,
     std::vector<int64_t> &dataKeys, bool distinguishCloudFlag)
 {
@@ -1814,8 +1910,11 @@ int SQLiteSingleVerRelationalStorageExecutor::GetCleanCloudDataKeys(const std::s
     std::string sql = "SELECT DATA_KEY FROM '" + logTableName + "' WHERE " + CLOUD_GID_FIELD +
         " IS NOT NULL AND " + CLOUD_GID_FIELD + " != '' AND data_key != '-1'";
     if (distinguishCloudFlag) {
-        sql += " AND ";
+        sql += " AND (";
         sql += FLAG_IS_CLOUD;
+        sql += " OR ";
+        sql += FLAG_IS_CLOUD_CONSISTENCY;
+        sql += " ) ";
     }
     sql += ";";
     int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, selectStmt);
@@ -1861,6 +1960,8 @@ int SQLiteSingleVerRelationalStorageExecutor::GetUpdateLogRecordStatement(const
         updateLogSql += std::string(CloudDbConstant::TO_LOCAL_CHANGE) + ", cloud_gid = ?";
         updateColName.push_back(CloudDbConstant::GID_FIELD);
     } else {
+        updateLogSql += " device = 'cloud', timestamp = ?,";
+        updateColName.push_back(CloudDbConstant::MODIFY_FIELD);
         if (opType == OpType::DELETE) {
             updateLogSql += GetCloudDeleteSql(DBCommon::GetLogTableName(tableSchema.name));
         } else {
@@ -1868,8 +1969,6 @@ int SQLiteSingleVerRelationalStorageExecutor::GetUpdateLogRecordStatement(const
             updateColName.push_back(CloudDbConstant::GID_FIELD);
             CloudStorageUtils::AddUpdateColForShare(tableSchema, updateLogSql, updateColName);
         }
-        updateLogSql += ", device = 'cloud', timestamp = ?";
-        updateColName.push_back(CloudDbConstant::MODIFY_FIELD);
     }
 
     int errCode = AppendUpdateLogRecordWhereSqlCondition(tableSchema, vBucket, updateLogSql);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.h
index 856a178e5e6a20347bef10ad676813863f4be8bc..d41ea10ac1974a8c99c299d631a3c8a3f7bbacb1 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor.h
@@ -20,6 +20,7 @@
 #include "cloud/asset_operation_utils.h"
 #include "cloud/cloud_db_constant.h"
 #include "cloud/cloud_store_types.h"
+#include "cloud/cloud_upload_recorder.h"
 #include "data_transformer.h"
 #include "db_types.h"
 #include "icloud_sync_storage_interface.h"
@@ -44,6 +45,12 @@ public:
         DEFAULT,
         SET_WAIT_COMPENSATED_SYNC
     };
+
+    struct UpdateCursorContext {
+        int errCode = E_OK;
+        int cursor;
+    };
+
     SQLiteSingleVerRelationalStorageExecutor(sqlite3 *dbHandle, bool writable, DistributedTableMode mode);
     ~SQLiteSingleVerRelationalStorageExecutor() override = default;
 
@@ -113,7 +120,8 @@ public:
 
     int UpdateCloudLogGid(const CloudSyncData &cloudDataResult, bool ignoreEmptyGid);
 
-    int GetSyncCloudData(CloudSyncData &cloudDataResult, SQLiteSingleVerRelationalContinueToken &token);
+    int GetSyncCloudData(const CloudUploadRecorder &uploadRecorder, CloudSyncData &cloudDataResult,
+        SQLiteSingleVerRelationalContinueToken &token);
 
     int GetSyncCloudGid(QuerySyncObject &query, const SyncTimeRange &syncTimeRange, bool isCloudForcePushStrategy,
         bool isCompensatedTask, std::vector<std::string> &cloudGid);
@@ -128,7 +136,8 @@ public:
 
     int FillCloudAssetForDownload(const TableSchema &tableSchema, VBucket &vBucket, bool isDownloadSuccess);
     int DoCleanInner(ClearMode mode, const std::vector<std::string> &tableNameList,
-        const RelationalSchemaObject &localSchema, std::vector<Asset> &assets);
+        const RelationalSchemaObject &localSchema, std::vector<Asset> &assets,
+        std::vector<std::string> &notifyTableList);
 
     int FillCloudAssetForUpload(OpType opType, const TableSchema &tableSchema, const CloudSyncBatch &data);
     int FillCloudVersionForUpload(const OpType opType, const CloudSyncData &data);
@@ -177,7 +186,11 @@ public:
 
     int UpgradedLogForExistedData(TableInfo &tableInfo, bool schemaChanged);
 
-    int UpdateRecordFlag(const std::string &tableName, bool recordConflict, const LogInfo &logInfo);
+    int UpdateRecordFlag(const std::string &tableName, const std::string &sql, const LogInfo &logInfo);
+
+    void MarkFlagAsUploadFinished(const std::string &tableName, const Key &hashKey, Timestamp timestamp);
+
+    int CleanUploadFinishedFlag(const std::string &tableName);
 
     int GetWaitCompensatedSyncDataPk(const TableSchema &table, std::vector<VBucket> &data);
 
@@ -189,6 +202,10 @@ public:
     int UpdateRecordStatus(const std::string &tableName, const std::string &status, const Key &hashKey);
 
     void SetUploadConfig(int32_t maxUploadCount, int32_t maxUploadSize);
+
+    int InitCursorToMeta(const std::string &tableName);
+
+    void SetTableSchema(const TableSchema &tableSchema);
 private:
     int DoCleanLogs(const std::vector<std::string> &tableNameList, const RelationalSchemaObject &localSchema);
 
@@ -200,6 +217,21 @@ private:
     int CleanCloudDataAndLogOnUserTable(const std::string &tableName, const std::string &logTableName,
         const RelationalSchemaObject &localSchema);
 
+    int ChangeCloudDataFlagOnLogTable(const std::string &logTableName);
+
+    int SetDataOnUserTablWithLogicDelete(const std::string &tableName, const std::string &logTableName);
+
+    static void UpdateCursor(sqlite3_context *ctx, int argc, sqlite3_value **argv);
+
+    int CreateFuncUpdateCursor(UpdateCursorContext &context,
+        void(*updateCursorFunc)(sqlite3_context *ctx, int argc, sqlite3_value **argv)) const;
+
+    int GetCursor(const std::string &tableName);
+
+    int SetCursor(const std::string &tableName, int cursor);
+
+    int IncreaseCursorOnAssetData(const std::string &tableName, const std::string &gid);
+
     int GetCleanCloudDataKeys(const std::string &logTableName, std::vector<int64_t> &dataKeys,
         bool distinguishCloudFlag);
 
@@ -243,10 +275,10 @@ private:
 
     int GeneLogInfoForExistedData(sqlite3 *db, const std::string &tableName, const std::string &calPrimaryKeyHash,
         TableInfo &tableInfo);
-    int CleanExtendAndCursorForDeleteData(sqlite3 *db, const std::string &tableName);
+    int CleanExtendAndCursorForDeleteData(const std::string &tableName);
 
-    int GetCloudDataForSync(sqlite3_stmt *statement, CloudSyncData &cloudDataResult, uint32_t &stepNum,
-        uint32_t &totalSize);
+    int GetCloudDataForSync(const CloudUploadRecorder &uploadRecorder, sqlite3_stmt *statement,
+        CloudSyncData &cloudDataResult, uint32_t &stepNum, uint32_t &totalSize);
 
     int PutVBucketByType(VBucket &vBucket, const Field &field, Type &cloudValue);
 
@@ -287,6 +319,8 @@ private:
 
     int BindValueToUpsertStatement(const VBucket &vBucket,  const std::vector<Field> &fields, sqlite3_stmt *upsertStmt);
 
+    int BindStatusSubQueryHashKeyStatement(sqlite3_stmt *insertLogStmt, std::vector<uint8_t> &hashKey);
+
     int BindHashKeyAndGidToInsertLogStatement(const VBucket &vBucket, const TableSchema &tableSchema,
         const TrackerTable &trackerTable, sqlite3_stmt *insertLogStmt);
 
@@ -426,6 +460,9 @@ private:
 
     int GetUploadCountInner(const Timestamp &timestamp, SqliteQueryHelper &helper, std::string &sql, int64_t &count);
 
+    int LogicDeleteCloudData(const std::string &tableName, const VBucket &vBucket,
+        const TableSchema &tableSchema, const TrackerTable &trackerTable);
+
     static constexpr const char *CONSISTENT_FLAG = "0x20";
     static constexpr const char *UPDATE_FLAG_CLOUD = "flag = flag & 0x20";
     static constexpr const char *UPDATE_FLAG_WAIT_COMPENSATED_SYNC = "flag = flag | 0x10";
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor_extend.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor_extend.cpp
index eaaa54ef5ae1bd1d47008e59a415dd497897a69d..88830d0ce3ece6a88e57c8371d3f82584e1d78ae 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor_extend.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_executor_extend.cpp
@@ -293,7 +293,7 @@ int SQLiteSingleVerRelationalStorageExecutor::ExecutePutCloudData(const std::str
 
 int SQLiteSingleVerRelationalStorageExecutor::DoCleanInner(ClearMode mode,
     const std::vector<std::string> &tableNameList, const RelationalSchemaObject &localSchema,
-    std::vector<Asset> &assets)
+    std::vector<Asset> &assets, std::vector<std::string> &notifyTableList)
 {
     int errCode = SetLogTriggerStatus(false);
     if (errCode != E_OK) {
@@ -312,6 +312,7 @@ int SQLiteSingleVerRelationalStorageExecutor::DoCleanInner(ClearMode mode,
             LOGE("[Storage Executor] Failed to do clean log and data when clean cloud data.");
             return errCode;
         }
+        notifyTableList = tableNameList;
     } else if (mode == CLEAR_SHARED_TABLE) {
         errCode = DoCleanShareTableDataAndLog(tableNameList);
         if (errCode != E_OK) {
@@ -351,6 +352,101 @@ int SQLiteSingleVerRelationalStorageExecutor::DoCleanLogs(const std::vector<std:
     return errCode;
 }
 
+void SQLiteSingleVerRelationalStorageExecutor::UpdateCursor(sqlite3_context *ctx, int argc, sqlite3_value **argv)
+{
+    if (ctx == nullptr || argc != 0 || argv == nullptr) {
+        LOGW("[SqlSinRDBExe][UpdateCursor] invalid param=%d", argc);
+        return;
+    }
+    auto context = static_cast<UpdateCursorContext *>(sqlite3_user_data(ctx));
+    if (context == nullptr) {
+        LOGW("[SqlSinRDBExe][UpdateCursor] invalid context");
+        return;
+    }
+    context->cursor++;
+    sqlite3_result_int64(ctx, static_cast<sqlite3_int64>(context->cursor));
+}
+
+int SQLiteSingleVerRelationalStorageExecutor::CreateFuncUpdateCursor(UpdateCursorContext &context,
+    void (*updateCursor)(sqlite3_context *ctx, int argc, sqlite3_value **argv)) const
+{
+    std::string sql = "update_cursor";
+    int errCode = sqlite3_create_function_v2(dbHandle_, sql.c_str(), 0, SQLITE_UTF8 | SQLITE_DIRECTONLY,
+        &context, updateCursor, nullptr, nullptr, nullptr);
+    if (errCode != SQLITE_OK) {
+        LOGE("[Storage Executor][UpdateCursor] Create func=updateCursor failed=%d", errCode);
+        return SQLiteUtils::MapSQLiteErrno(errCode);
+    }
+    return E_OK;
+}
+
+int SQLiteSingleVerRelationalStorageExecutor::GetCursor(const std::string &tableName)
+{
+    int cursor = -1;
+    std::string sql = "SELECT value FROM " + DBConstant::RELATIONAL_PREFIX + "metadata where key = ?;";
+    sqlite3_stmt *stmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, stmt);
+    if (errCode != E_OK) {
+        LOGE("[Storage Executor]get cursor failed=%d", errCode);
+        return cursor;
+    }
+    ResFinalizer finalizer([stmt]() {
+        sqlite3_stmt *statement = stmt;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("Reset stmt failed %d when get cursor", ret);
+        }
+    });
+    Key key;
+    DBCommon::StringToVector(DBCommon::GetCursorKey(tableName), key);
+    errCode = SQLiteUtils::BindBlobToStatement(stmt, 1, key, false); // first arg.
+    if (errCode != E_OK) {
+        return cursor;
+    }
+    errCode = SQLiteUtils::StepWithRetry(stmt, isMemDb_);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+        cursor = static_cast<int64_t>(sqlite3_column_int64(stmt, 0));
+    }
+    return cursor;
+}
+
+int SQLiteSingleVerRelationalStorageExecutor::SetCursor(const std::string &tableName, int cursor)
+{
+    std::string sql = "UPDATE " + DBConstant::RELATIONAL_PREFIX + "metadata SET VALUE = ? where KEY = ?;";
+    sqlite3_stmt *stmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, stmt);
+    if (errCode != E_OK) {
+        LOGE("Set cursor sql failed=%d", errCode);
+        return cursor;
+    }
+    ResFinalizer finalizer([stmt]() {
+        sqlite3_stmt *statement = stmt;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("Reset stmt failed %d when set cursor", ret);
+        }
+    });
+    int index = 1;
+    errCode = SQLiteUtils::BindInt64ToStatement(stmt, index++, cursor);
+    if (errCode != E_OK) {
+        LOGE("Bind saved cursor failed:%d", errCode);
+        return errCode;
+    }
+    Key key;
+    DBCommon::StringToVector(DBCommon::GetCursorKey(tableName), key);
+    errCode = SQLiteUtils::BindBlobToStatement(stmt, index, key, false);
+    if (errCode != E_OK) {
+        return cursor;
+    }
+    errCode = SQLiteUtils::StepWithRetry(stmt, isMemDb_);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        errCode = E_OK;
+    }
+    return errCode;
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::DoCleanLogAndData(const std::vector<std::string> &tableNameList,
     const RelationalSchemaObject &localSchema, std::vector<Asset> &assets)
 {
@@ -371,8 +467,11 @@ int SQLiteSingleVerRelationalStorageExecutor::DoCleanLogAndData(const std::vecto
             LOGE("[Storage Executor] failed to get cloud assets when clean cloud data, %d", errCode);
             return errCode;
         }
-
-        errCode = CleanCloudDataAndLogOnUserTable(tableName, logTableName, localSchema);
+        if (isLogicDelete_) {
+            errCode = SetDataOnUserTablWithLogicDelete(tableName, logTableName);
+        } else {
+            errCode = CleanCloudDataAndLogOnUserTable(tableName, logTableName, localSchema);
+        }
         if (errCode != E_OK) {
             LOGE("[Storage Executor] failed to clean cloud data and log on user table, %d.", errCode);
             return errCode;
@@ -392,21 +491,21 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetOnTable(const std::string
         std::string queryAssetSql = "SELECT " + fieldName + " FROM '" + tableName +
             "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(rowId) + ";";
         errCode = SQLiteUtils::GetStatement(dbHandle_, queryAssetSql, selectStmt);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get select asset statement failed, %d", errCode);
             return errCode;
         }
         errCode = SQLiteUtils::StepWithRetry(selectStmt);
-        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // LCOV_EXCL_BR_LINE
             std::vector<uint8_t> blobValue;
             errCode = SQLiteUtils::GetColumnBlobValue(selectStmt, 0, blobValue);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("Get column blob value failed, %d", errCode);
                 goto END;
             }
             Asset asset;
             errCode = RuntimeContext::GetInstance()->BlobToAsset(blobValue, asset);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("Transfer blob to asset failed, %d", errCode);
                 goto END;
             }
@@ -434,12 +533,12 @@ int SQLiteSingleVerRelationalStorageExecutor::GetCloudAssetsOnTable(const std::s
         std::string queryAssetsSql = "SELECT " + fieldName + " FROM '" + tableName +
             "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(rowId) + ";";
         errCode = SQLiteUtils::GetStatement(dbHandle_, queryAssetsSql, selectStmt);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get select assets statement failed, %d", errCode);
             goto END;
         }
         errCode = SQLiteUtils::StepWithRetry(selectStmt);
-        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // LCOV_EXCL_BR_LINE
             std::vector<uint8_t> blobValue;
             errCode = SQLiteUtils::GetColumnBlobValue(selectStmt, 0, blobValue);
             if (errCode != E_OK) {
@@ -447,12 +546,14 @@ int SQLiteSingleVerRelationalStorageExecutor::GetCloudAssetsOnTable(const std::s
             }
             Assets tmpAssets;
             errCode = RuntimeContext::GetInstance()->BlobToAssets(blobValue, tmpAssets);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 goto END;
             }
             for (const auto &asset: tmpAssets) {
                 assets.push_back(asset);
             }
+        } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+            errCode = E_OK;
         }
         SQLiteUtils::ResetStatement(selectStmt, true, ret);
     }
@@ -576,7 +677,9 @@ int SQLiteSingleVerRelationalStorageExecutor::InsertLogRecord(const TableSchema
     }
 
     std::string sql = "INSERT OR REPLACE INTO " + DBCommon::GetLogTableName(tableSchema.name) +
-        " VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, 0)";
+        " VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, " + "CASE WHEN (SELECT status FROM " +
+        DBCommon::GetLogTableName(tableSchema.name) + " WHERE hash_key=?) IS NULL THEN 0 ELSE " +
+        "(SELECT status FROM " + DBCommon::GetLogTableName(tableSchema.name) + " WHERE hash_key=?) " + "END)";
     sqlite3_stmt *insertLogStmt = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, insertLogStmt);
     if (errCode != E_OK) {
@@ -627,6 +730,23 @@ int SQLiteSingleVerRelationalStorageExecutor::BindValueToUpsertStatement(const V
     return errCode;
 }
 
+int SQLiteSingleVerRelationalStorageExecutor::BindStatusSubQueryHashKeyStatement(sqlite3_stmt *insertLogStmt,
+    std::vector<uint8_t> &hashKey)
+{
+    int errCode = SQLiteUtils::BindBlobToStatement(insertLogStmt, 12, hashKey); // 12 is hash_key
+    if (errCode != E_OK) {
+        LOGE("Bind hash_key to status subQuery statement failed, %d", errCode);
+        return errCode;
+    }
+
+    errCode = SQLiteUtils::BindBlobToStatement(insertLogStmt, 13, hashKey); // 13 is hash_key
+    if (errCode != E_OK) {
+        LOGE("Bind hash_key to status subQuery2 statement failed, %d", errCode);
+        return errCode;
+    }
+    return errCode;
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::BindHashKeyAndGidToInsertLogStatement(const VBucket &vBucket,
     const TableSchema &tableSchema, const TrackerTable &trackerTable, sqlite3_stmt *insertLogStmt)
 {
@@ -667,7 +787,11 @@ int SQLiteSingleVerRelationalStorageExecutor::BindHashKeyAndGidToInsertLogStatem
         return errCode;
     }
 
-    return BindShareValueToInsertLogStatement(vBucket, tableSchema, insertLogStmt);
+    errCode = BindShareValueToInsertLogStatement(vBucket, tableSchema, insertLogStmt);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    return BindStatusSubQueryHashKeyStatement(insertLogStmt, hashKey);
 }
 
 int SQLiteSingleVerRelationalStorageExecutor::BindValueToInsertLogStatement(VBucket &vBucket,
@@ -942,12 +1066,7 @@ int SQLiteSingleVerRelationalStorageExecutor::DeleteCloudData(const std::string
     const TableSchema &tableSchema, const TrackerTable &trackerTable)
 {
     if (isLogicDelete_) {
-        LOGD("[RDBExecutor] logic delete skip delete data");
-        int errCode = UpdateLogRecord(vBucket, tableSchema, OpType::DELETE);
-        if (errCode == E_OK && !trackerTable.IsEmpty()) {
-            return SQLiteRelationalUtils::SelectServerObserver(dbHandle_, tableName, true);
-        }
-        return errCode;
+        return LogicDeleteCloudData(tableName, vBucket, tableSchema, trackerTable);
     }
     std::set<std::string> pkSet = CloudStorageUtils::GetCloudPrimaryKey(tableSchema);
     sqlite3_stmt *deleteStmt = nullptr;
@@ -1037,5 +1156,48 @@ void SQLiteSingleVerRelationalStorageExecutor::SetUploadConfig(int32_t maxUpload
     maxUploadCount_ = maxUploadCount;
     maxUploadSize_ = maxUploadSize;
 }
+
+int SQLiteSingleVerRelationalStorageExecutor::LogicDeleteCloudData(const std::string &tableName, const VBucket &vBucket,
+    const TableSchema &tableSchema, const TrackerTable &trackerTable)
+{
+    LOGD("[RDBExecutor] logic delete skip delete data");
+    int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, CloudStorageUtils::GetCursorIncSql(tableName));
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    errCode = UpdateLogRecord(vBucket, tableSchema, OpType::DELETE);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    if (!trackerTable.IsEmpty()) {
+        return SQLiteRelationalUtils::SelectServerObserver(dbHandle_, tableName, true);
+    }
+    return E_OK;
+}
+
+int SQLiteSingleVerRelationalStorageExecutor::InitCursorToMeta(const std::string &tableName)
+{
+    Value key;
+    Value cursor;
+    DBCommon::StringToVector(DBCommon::GetCursorKey(tableName), key);
+    int errCode = GetKvData(key, cursor);
+    if (errCode == -E_NOT_FOUND) {
+        DBCommon::StringToVector(std::string("0"), cursor);
+        errCode = PutKvData(key, cursor);
+        if (errCode != E_OK) {
+            LOGE("Init cursor to meta table failed. %d", errCode);
+        }
+        return errCode;
+    }
+    if (errCode != E_OK) {
+        LOGE("Get cursor from meta table failed. %d", errCode);
+    }
+    return errCode;
+}
+
+void SQLiteSingleVerRelationalStorageExecutor::SetTableSchema(const TableSchema &tableSchema)
+{
+    tableSchema_ = tableSchema;
+}
 } // namespace DistributedDB
 #endif
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_extend_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_extend_executor.cpp
index 44d2ee02f99b77a51e88b79c3acd5bcce046edbe..2581170702cad4060f995c53210fa2827e0439de 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_extend_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/relational/sqlite_single_ver_relational_storage_extend_executor.cpp
@@ -20,6 +20,7 @@
 #include "cloud/cloud_storage_utils.h"
 #include "db_common.h"
 #include "log_table_manager_factory.h"
+#include "res_finalizer.h"
 #include "runtime_context.h"
 #include "simple_tracker_log_table_manager.h"
 #include "sqlite_relational_utils.h"
@@ -123,6 +124,10 @@ int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForDownload(const Ta
     if (isDownloadSuccess) {
         CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets,
             CloudStorageUtils::FillAssetAfterDownload, CloudStorageUtils::FillAssetsAfterDownload);
+        errCode = IncreaseCursorOnAssetData(tableSchema.name, cloudGid);
+        if (errCode != E_OK) {
+            return errCode;
+        }
     } else {
         CloudStorageUtils::FillAssetFromVBucketFinish(assetOpType, vBucket, dbAssets,
             CloudStorageUtils::FillAssetAfterDownloadFail, CloudStorageUtils::FillAssetsAfterDownloadFail);
@@ -138,6 +143,53 @@ int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForDownload(const Ta
     return errCode == E_OK ? ret : errCode;
 }
 
+int SQLiteSingleVerRelationalStorageExecutor::IncreaseCursorOnAssetData(const std::string &tableName,
+    const std::string &gid)
+{
+    int cursor = GetCursor(tableName);
+    cursor++;
+    std::string sql = "UPDATE " + DBConstant::RELATIONAL_PREFIX + tableName + "_log";
+    sql += " SET cursor = ? where cloud_gid = ?;";
+    sqlite3_stmt *statement = nullptr;
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
+    if (errCode != E_OK) {
+        LOGE("get update asset data cursor stmt failed %d.", errCode);
+        return errCode;
+    }
+    ResFinalizer finalizer([statement]() {
+        sqlite3_stmt *statementInner = statement;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statementInner, true, ret);
+        if (ret != E_OK) {
+            LOGW("Reset stmt failed %d when increase cursor on asset data", ret);
+        }
+    });
+    int index = 1;
+    errCode = SQLiteUtils::BindInt64ToStatement(statement, index++, cursor);
+    int ret = E_OK;
+    if (errCode != E_OK) {
+        LOGE("bind cursor data stmt failed %d.", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindTextToStatement(statement, index, gid);
+    ret = E_OK;
+    if (errCode != E_OK) {
+        LOGE("bind cursor gid data stmt failed %d.", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::StepWithRetry(statement, false);
+    if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        LOGE("Fill upload asset failed:%d.", errCode);
+        return errCode;
+    }
+    LOGI("Upgrade cursor to %d after asset download success.", cursor);
+    errCode = SetCursor(tableName, cursor);
+    if (errCode != E_OK) {
+        LOGE("Upgrade cursor failed after asset download success %d.", errCode);
+    }
+    return errCode;
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForUpload(OpType opType, const TableSchema &tableSchema,
     const CloudSyncBatch &data)
 {
@@ -155,7 +207,8 @@ int SQLiteSingleVerRelationalStorageExecutor::FillCloudAssetForUpload(OpType opT
         if (data.assets.at(i).empty()) {
             continue;
         }
-        if (DBCommon::IsRecordIgnored(data.extend[i]) || DBCommon::IsRecordVersionConflict(data.extend[i])) {
+        if (DBCommon::IsRecordIgnored(data.extend[i]) || DBCommon::IsRecordVersionConflict(data.extend[i]) ||
+            DBCommon::IsCloudRecordNotFound(data.extend[i]) || DBCommon::IsCloudRecordAlreadyExisted(data.extend[i])) {
             continue;
         }
         errCode = InitFillUploadAssetStatement(opType, tableSchema, data, i, stmt);
@@ -285,31 +338,43 @@ int SQLiteSingleVerRelationalStorageExecutor::CreateTrackerTable(const TrackerTa
         return errCode;
     }
     auto tableManager = std::make_unique<SimpleTrackerLogTableManager>();
-    if (!trackerTable.GetTrackerColNames().empty()) {
-        // create log table
-        errCode = tableManager->CreateRelationalLogTable(dbHandle_, table);
-        if (errCode != E_OK) {
-            return errCode;
-        }
-        std::string calPrimaryKeyHash = tableManager->CalcPrimaryKeyHash("a.", table, "");
-        if (isUpgrade) {
-            errCode = CleanExtendAndCursorForDeleteData(dbHandle_, table.GetTableName());
-            if (errCode != E_OK) {
-                LOGE("clean tracker log info for deleted data failed %d.", errCode);
-                return errCode;
-            }
-        }
-        errCode = GeneLogInfoForExistedData(dbHandle_, trackerTable.GetTableName(), calPrimaryKeyHash, table);
+    if (trackerTable.GetTrackerColNames().empty()) {
+        // drop trigger
+        return tableManager->AddRelationalLogTableTrigger(dbHandle_, table, "");
+    }
+
+    // create log table
+    errCode = tableManager->CreateRelationalLogTable(dbHandle_, table);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    // init cursor
+    errCode = InitCursorToMeta(table.GetTableName());
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    std::string calPrimaryKeyHash = tableManager->CalcPrimaryKeyHash("a.", table, "");
+    if (isUpgrade) {
+        errCode = CleanExtendAndCursorForDeleteData(table.GetTableName());
         if (errCode != E_OK) {
-            LOGE("general tracker log info for existed data failed %d.", errCode);
+            LOGE("clean tracker log info for deleted data failed %d.", errCode);
             return errCode;
         }
     }
+    errCode = GeneLogInfoForExistedData(dbHandle_, trackerTable.GetTableName(), calPrimaryKeyHash, table);
+    if (errCode != E_OK) {
+        LOGE("general tracker log info for existed data failed %d.", errCode);
+        return errCode;
+    }
+    errCode = SetLogTriggerStatus(true);
+    if (errCode != E_OK) {
+        return errCode;
+    }
     errCode = tableManager->AddRelationalLogTableTrigger(dbHandle_, table, "");
     if (errCode != E_OK) {
         return errCode;
     }
-    if (!trackerTable.GetTrackerColNames().empty() && !isUpgrade) {
+    if (!isUpgrade) {
         return CheckInventoryData(DBCommon::GetLogTableName(table.GetTableName()));
     }
     return E_OK;
@@ -429,24 +494,21 @@ int SQLiteSingleVerRelationalStorageExecutor::UpgradedLogForExistedData(TableInf
         return E_OK;
     }
     LOGI("Upgrade tracker table log, schemaChanged:%d.", schemaChanged);
-    int64_t timeOffset = 0;
-    std::string timeOffsetStr = std::to_string(timeOffset);
-    std::string sql = "UPDATE " + logTable + " SET extend_field = " +
-        tableInfo.GetTrackerTable().GetUpgradedExtendValSql();
-    int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
+    int errCode = SetLogTriggerStatus(false);
     if (errCode != E_OK) {
-        LOGE("Upgrade log for extend field failed.");
         return errCode;
     }
-    sql = "UPDATE " + logTable + " SET cursor = (SELECT (SELECT CASE WHEN MAX(cursor) IS NULL THEN 0 ELSE"
-        " MAX(cursor) END from " + logTable + ") + " + std::string(DBConstant::SQLITE_INNER_ROWID) +
-        " FROM " + tableInfo.GetTableName() + " WHERE " + tableInfo.GetTableName() + "." +
-        std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + logTable + ".data_key);";
-    errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
-    if (errCode != E_OK) {
-        LOGE("Upgrade log for cursor failed.");
-    }
-    return errCode;
+    std::string sql = "UPDATE " + tableInfo.GetTableName() + " SET _rowid_=_rowid_";
+    TrackerTable trackerTable = tableInfo.GetTrackerTable();
+    errCode = trackerTable.ReBuildTempTrigger(dbHandle_, TriggerMode::TriggerModeEnum::UPDATE,
+        [this, &sql]() {
+        int ret = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
+        if (ret != E_OK) {
+            LOGE("Upgrade log for extend field failed.");
+        }
+        return ret;
+    });
+    return SetLogTriggerStatus(true);
 }
 
 int SQLiteSingleVerRelationalStorageExecutor::CreateTempSyncTrigger(const TrackerTable &trackerTable)
@@ -524,19 +586,19 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanTrackerData(const std::string
     sql += " SET extend_field = NULL where data_key = -1 and cursor <= ?;";
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("get clean tracker data stmt failed %d.", errCode);
         return errCode;
     }
     errCode = SQLiteUtils::BindInt64ToStatement(statement, 1, cursor);
     int ret = E_OK;
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("bind clean tracker data stmt failed %d.", errCode);
         SQLiteUtils::ResetStatement(statement, true, ret);
         return errCode;
     }
     errCode = SQLiteUtils::StepWithRetry(statement);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
         errCode = E_OK;
     } else {
         LOGE("clean tracker step failed: %d.", errCode);
@@ -864,7 +926,12 @@ int SQLiteSingleVerRelationalStorageExecutor::BindStmtWithCloudGid(const CloudSy
     for (size_t i = 0; i < cloudDataResult.insData.extend.size(); ++i) {
         auto gidEntry = cloudDataResult.insData.extend[i].find(CloudDbConstant::GID_FIELD);
         if (gidEntry == cloudDataResult.insData.extend[i].end()) {
-            if (ignoreEmptyGid) {
+            bool isSkipAssetsMissRecord = false;
+            if (DBCommon::IsRecordAssetsMissing(cloudDataResult.insData.extend[i])) {
+                LOGI("[RDBExecutor] Local assets missing and skip filling assets.");
+                isSkipAssetsMissRecord = true;
+            }
+            if (ignoreEmptyGid || isSkipAssetsMissRecord) {
                 continue;
             }
             errCode = -E_INVALID_ARGS;
@@ -897,13 +964,12 @@ int SQLiteSingleVerRelationalStorageExecutor::BindStmtWithCloudGid(const CloudSy
     return errCode;
 }
 
-int SQLiteSingleVerRelationalStorageExecutor::CleanExtendAndCursorForDeleteData(sqlite3 *db,
-    const std::string &tableName)
+int SQLiteSingleVerRelationalStorageExecutor::CleanExtendAndCursorForDeleteData(const std::string &tableName)
 {
     std::string logTable = DBConstant::RELATIONAL_PREFIX + tableName + "_log";
     std::string sql = "UPDATE " + logTable + " SET extend_field = NULL, cursor = NULL where flag&0x01=0x01;";
-    int errCode = SQLiteUtils::ExecuteRawSQL(db, sql);
-    if (errCode != E_OK) {
+    int errCode = SQLiteUtils::ExecuteRawSQL(dbHandle_, sql);
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("update extend field and cursor failed %d.", errCode);
     }
     return errCode;
@@ -936,16 +1002,16 @@ int SQLiteSingleVerRelationalStorageExecutor::CheckIfExistUserTable(const std::s
 std::string SQLiteSingleVerRelationalStorageExecutor::GetCloudDeleteSql(const std::string &logTable)
 {
     std::string sql;
+    sql += " cloud_gid = '', version = '', ";
     if (isLogicDelete_) {
         // 1001 which is logicDelete|cloudForcePush|local|delete
-        sql += "flag = flag&" + std::string(CONSISTENT_FLAG) + "|0x09, cursor = (SELECT case when "
-            "(MAX(cursor) is null) then 1 else MAX(cursor) + 1 END FROM " + logTable + ")";
+        sql += "flag = flag&" + std::string(CONSISTENT_FLAG) + "|" +
+            std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_DELETE) |
+            static_cast<uint32_t>(LogInfoFlag::FLAG_LOGIC_DELETE)) + ", cursor = (SELECT CASE WHEN (MAX(cursor) is "
+            "null) THEN 1 ELSE MAX(cursor) + 1 END FROM " + logTable + ")";
     } else {
-        sql += "data_key = -1,  flag = flag&" + std::string(CONSISTENT_FLAG) + "|0x01";
-    }
-    sql += ", cloud_gid = '', version = ''";
-    if (!isLogicDelete_) {
-        sql += ", sharing_resource = ''";
+        sql += "data_key = -1, flag = flag&" + std::string(CONSISTENT_FLAG) + "|" +
+            std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_DELETE)) + ", sharing_resource = ''";
     }
     return sql;
 }
@@ -1057,7 +1123,7 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanAssetId(const std::string &ta
 int SQLiteSingleVerRelationalStorageExecutor::UpdateAssetIdOnUserTable(const std::string &tableName,
     const std::string &fieldName, const std::vector<int64_t> &dataKeys, std::vector<Asset> &assets)
 {
-    if (assets.empty()) {
+    if (assets.empty()) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
     int errCode = E_OK;
@@ -1068,14 +1134,14 @@ int SQLiteSingleVerRelationalStorageExecutor::UpdateAssetIdOnUserTable(const std
         if (rowId == -1) { // -1 means data is deleted
             continue;
         }
-        if (assets[index].name.empty()) {
+        if (assets[index].name.empty()) { // LCOV_EXCL_BR_LINE
             index++;
             continue;
         }
         std::string cleanAssetIdSql = "UPDATE " + tableName  + " SET " + fieldName + " = ? WHERE " +
             std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(rowId) + ";";
         errCode = SQLiteUtils::GetStatement(dbHandle_, cleanAssetIdSql, stmt);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get statement failed, %d", errCode);
             return errCode;
         }
@@ -1083,12 +1149,12 @@ int SQLiteSingleVerRelationalStorageExecutor::UpdateAssetIdOnUserTable(const std
         assets[index].status &= ~AssetStatus::UPLOADING;
         errCode = BindAssetToBlobStatement(assets[index], 1, stmt); // 1 means sqlite statement index
         index++;
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Bind asset to blob statement failed, %d", errCode);
             goto END;
         }
         errCode = SQLiteUtils::StepWithRetry(stmt);
-        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
             errCode = E_OK;
         } else {
             LOGE("Step statement failed, %d", errCode);
@@ -1112,18 +1178,18 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetsAndUpdateAssetsId(const s
         std::string queryAssetsSql = "SELECT " + fieldName + " FROM '" + tableName +
             "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(rowId) + ";";
         errCode = SQLiteUtils::GetStatement(dbHandle_, queryAssetsSql, selectStmt);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get select assets statement failed, %d.", errCode);
             goto END;
         }
         Assets assets;
         errCode = GetAssetsByRowId(selectStmt, assets);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get assets by rowId failed, %d.", errCode);
             goto END;
         }
         SQLiteUtils::ResetStatement(selectStmt, true, ret);
-        if (assets.empty()) {
+        if (assets.empty()) { // LCOV_EXCL_BR_LINE
             continue;
         }
         for (auto &asset : assets) {
@@ -1132,12 +1198,12 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetsAndUpdateAssetsId(const s
         }
         std::vector<uint8_t> assetsValue;
         errCode = RuntimeContext::GetInstance()->AssetsToBlob(assets, assetsValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[CleanAssetsIdOnUserTable] failed to transfer assets to blob, %d.", errCode);
             return errCode;
         }
         errCode = CleanAssetsIdOnUserTable(tableName, fieldName, rowId, assetsValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[CleanAssetsIdOnUserTable] clean assets id on user table failed, %d", errCode);
             return errCode;
         }
@@ -1155,18 +1221,18 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanAssetsIdOnUserTable(const std
         std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(rowId) + ";";
     sqlite3_stmt *stmt = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, cleanAssetIdSql, stmt);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Get statement failed, %d", errCode);
         SQLiteUtils::ResetStatement(stmt, true, errCode);
         return errCode;
     }
     errCode = SQLiteUtils::BindBlobToStatement(stmt, 1, assetsValue, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         SQLiteUtils::ResetStatement(stmt, true, errCode);
         return errCode;
     }
     errCode = SQLiteUtils::StepWithRetry(stmt);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
         errCode = E_OK;
     }
     SQLiteUtils::ResetStatement(stmt, true, errCode);
@@ -1307,15 +1373,15 @@ int SQLiteSingleVerRelationalStorageExecutor::FillHandleWithOpType(const OpType
 int SQLiteSingleVerRelationalStorageExecutor::GetAssetsByRowId(sqlite3_stmt *&selectStmt, Assets &assets)
 {
     int errCode = SQLiteUtils::StepWithRetry(selectStmt);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // LCOV_EXCL_BR_LINE
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(selectStmt, 0, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get column blob value failed %d.", errCode);
             return errCode;
         }
         errCode = RuntimeContext::GetInstance()->BlobToAssets(blobValue, assets);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Transfer blob to assets failed %d", errCode);
         }
         return errCode;
@@ -1365,7 +1431,7 @@ int SQLiteSingleVerRelationalStorageExecutor::CleanDownloadChangedAssets(
     if (toDeleteAssets.empty()) {
         return E_OK;
     }
-    int ret = assetLoader_->RemoveLocalAssets(toDeleteAssets);
+    DBStatus ret = assetLoader_->RemoveLocalAssets(toDeleteAssets);
     if (ret != OK) {
         LOGE("remove local assets failed %d.", ret);
         return -E_REMOVE_ASSETS_FAILED;
@@ -1483,15 +1549,15 @@ int SQLiteSingleVerRelationalStorageExecutor::BindAssetsToBlobStatement(const As
 int SQLiteSingleVerRelationalStorageExecutor::GetAssetOnTableInner(sqlite3_stmt *&stmt, Asset &asset)
 {
     int errCode = SQLiteUtils::StepWithRetry(stmt);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // LCOV_EXCL_BR_LINE
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(stmt, 0, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RDBExecutor][GetAssetOnTableInner] Get column blob value failed, %d.", errCode);
             return errCode;
         }
         errCode = RuntimeContext::GetInstance()->BlobToAsset(blobValue, asset);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RDBExecutor] Transfer blob to asset failed, %d.", errCode);
         }
     } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
@@ -1509,7 +1575,7 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetOnTable(const std::string
     std::string queryAssetSql = "SELECT " + fieldName + " FROM '" + tableName +
         "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(dataKey) + ";";
     int errCode = SQLiteUtils::GetStatement(dbHandle_, queryAssetSql, selectStmt);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Get select asset statement failed, %d.", errCode);
         return errCode;
     }
@@ -1522,15 +1588,15 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetOnTable(const std::string
 int SQLiteSingleVerRelationalStorageExecutor::GetAssetsOnTableInner(sqlite3_stmt *&stmt, Assets &assets)
 {
     int errCode = SQLiteUtils::StepWithRetry(stmt);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // LCOV_EXCL_BR_LINE
         std::vector<uint8_t> blobValue;
         errCode = SQLiteUtils::GetColumnBlobValue(stmt, 0, blobValue);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RDBExecutor][GetAssetsOnTableInner] Get column blob value failed, %d.", errCode);
             return errCode;
         }
         errCode = RuntimeContext::GetInstance()->BlobToAssets(blobValue, assets);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[RDBExecutor] Transfer blob to assets failed, %d.", errCode);
         }
     } else if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
@@ -1548,7 +1614,7 @@ int SQLiteSingleVerRelationalStorageExecutor::GetAssetsOnTable(const std::string
     std::string queryAssetsSql = "SELECT " + fieldName + " FROM '" + tableName +
         "' WHERE " + std::string(DBConstant::SQLITE_INNER_ROWID) + " = " + std::to_string(dataKey) + ";";
     int errCode = SQLiteUtils::GetStatement(dbHandle_, queryAssetsSql, selectStmt);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Get select assets statement failed, %d.", errCode);
         return errCode;
     }
@@ -1720,7 +1786,7 @@ std::vector<Field> SQLiteSingleVerRelationalStorageExecutor::GetUpdateField(cons
     return fields;
 }
 
-int SQLiteSingleVerRelationalStorageExecutor::UpdateRecordFlag(const std::string &tableName, bool recordConflict,
+int SQLiteSingleVerRelationalStorageExecutor::UpdateRecordFlag(const std::string &tableName, const std::string &sql,
     const LogInfo &logInfo)
 {
     bool useHashKey = false;
@@ -1731,7 +1797,6 @@ int SQLiteSingleVerRelationalStorageExecutor::UpdateRecordFlag(const std::string
         }
         useHashKey = true;
     }
-    std::string sql = CloudStorageUtils::GetUpdateRecordFlagSql(tableName, recordConflict, logInfo);
     sqlite3_stmt *stmt = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, stmt);
     if (errCode != E_OK) {
@@ -1769,6 +1834,34 @@ int SQLiteSingleVerRelationalStorageExecutor::UpdateRecordFlag(const std::string
     return errCode == E_OK ? ret : errCode;
 }
 
+void SQLiteSingleVerRelationalStorageExecutor::MarkFlagAsUploadFinished(const std::string &tableName,
+    const Key &hashKey, Timestamp timestamp)
+{
+    sqlite3_stmt *stmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, CloudStorageUtils::GetUpdateUploadFinishedSql(tableName),
+        stmt);
+    int index = 1;
+    errCode = SQLiteUtils::BindInt64ToStatement(stmt, index++, timestamp);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, errCode);
+        LOGW("[Storage Executor] Bind timestamp to update record flag for upload finished stmt failed, %d", errCode);
+        return;
+    }
+    errCode = SQLiteUtils::BindBlobToStatement(stmt, index++, hashKey);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, errCode);
+        LOGW("[Storage Executor] Bind hashKey to update record flag for upload finished stmt failed, %d", errCode);
+        return;
+    }
+    errCode = SQLiteUtils::StepWithRetry(stmt);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        errCode = E_OK;
+    } else {
+        LOGE("[Storage Executor]Step update record flag for upload finished stmt failed, %d", errCode);
+    }
+    SQLiteUtils::ResetStatement(stmt, true, errCode);
+}
+
 int SQLiteSingleVerRelationalStorageExecutor::GetWaitCompensatedSyncDataPk(const TableSchema &table,
     std::vector<VBucket> &data)
 {
@@ -1866,7 +1959,6 @@ int SQLiteSingleVerRelationalStorageExecutor::BindShareValueToInsertLogStatement
     errCode = SQLiteUtils::BindTextToStatement(insertLogStmt, 11, shareUri); // 11 is sharing_resource
     if (errCode != E_OK) {
         LOGE("Bind shareUri to insert log statement failed, %d", errCode);
-        return errCode;
     }
     return errCode;
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.cpp
index 2e8b68aa7280c76a2824618d4f3abf65ade24e15..cf8564d4015ca0fb2e578720380ee0becea60fa5 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.cpp
@@ -21,19 +21,21 @@
 #include "res_finalizer.h"
 #include "runtime_context.h"
 #include "sqlite_single_ver_storage_executor_sql.h"
+#include "time_helper.h"
 
 namespace DistributedDB {
-int SqliteCloudKvExecutorUtils::GetCloudData(const CloudSyncConfig &config, sqlite3 *db, bool isMemory,
-    SQLiteSingleVerContinueToken &token, CloudSyncData &data)
+int SqliteCloudKvExecutorUtils::GetCloudData(const CloudSyncConfig &config, const DBParam &param,
+    const CloudUploadRecorder &recorder, SQLiteSingleVerContinueToken &token, CloudSyncData &data)
 {
+    auto [db, isMemory] = param;
     bool stepNext = false;
     auto [errCode, stmt] = token.GetCloudQueryStmt(db, data.isCloudForcePushStrategy, stepNext, data.mode);
     if (errCode != E_OK) {
         token.ReleaseCloudQueryStmt();
         return errCode;
     }
-    uint32_t totalSize = 0;
-    uint32_t stepNum = 0;
+    UploadDetail detail;
+    auto &[stepNum, totalSize] = detail;
     do {
         if (stepNext) {
             errCode = SQLiteUtils::StepNext(stmt, isMemory);
@@ -43,11 +45,11 @@ int SqliteCloudKvExecutorUtils::GetCloudData(const CloudSyncConfig &config, sqli
             }
         }
         stepNext = true;
-        errCode = GetCloudDataForSync(config, stmt, data, stepNum, totalSize);
+        errCode = GetCloudDataForSync(config, recorder, stmt, data, detail);
         stepNum++;
     } while (errCode == E_OK);
-    LOGI("[SqliteCloudKvExecutorUtils] Get cloud sync data, insData:%u, upData:%u, delLog:%u errCode:%d",
-         data.insData.record.size(), data.updData.record.size(), data.delData.extend.size(), errCode);
+    LOGI("[SqliteCloudKvExecutorUtils] Get cloud sync data, insData:%u, upData:%u, delLog:%u errCode:%d total:%" PRIu32,
+         data.insData.record.size(), data.updData.record.size(), data.delData.extend.size(), errCode, totalSize);
     if (errCode != -E_UNFINISHED) {
         token.ReleaseCloudQueryStmt();
     } else if (isMemory && UpdateBeginTimeForMemoryDB(token, data)) {
@@ -80,6 +82,9 @@ bool SqliteCloudKvExecutorUtils::UpdateBeginTimeForMemoryDB(SQLiteSingleVerConti
         case DistributedDB::CloudWaterType::INSERT:
             maxTimeStamp = GetMaxTimeStamp(data.insData.extend);
             break;
+        case DistributedDB::CloudWaterType::BUTT:
+        default:
+            break;
     }
     if (maxTimeStamp > token.GetQueryBeginTime()) {
         token.SetNextBeginTime("", maxTimeStamp);
@@ -89,9 +94,10 @@ bool SqliteCloudKvExecutorUtils::UpdateBeginTimeForMemoryDB(SQLiteSingleVerConti
     return false;
 }
 
-int SqliteCloudKvExecutorUtils::GetCloudDataForSync(const CloudSyncConfig &config, sqlite3_stmt *statement,
-    CloudSyncData &cloudDataResult, uint32_t &stepNum, uint32_t &totalSize)
+int SqliteCloudKvExecutorUtils::GetCloudDataForSync(const CloudSyncConfig &config, const CloudUploadRecorder &recorder,
+    sqlite3_stmt *statement, CloudSyncData &cloudDataResult, UploadDetail &detail)
 {
+    auto &[stepNum, totalSize] = detail;
     VBucket log;
     VBucket extraLog;
     uint32_t preSize = totalSize;
@@ -113,13 +119,10 @@ int SqliteCloudKvExecutorUtils::GetCloudDataForSync(const CloudSyncConfig &confi
     }
 
     if (CloudStorageUtils::IsGetCloudDataContinue(stepNum, totalSize, config.maxUploadSize, config.maxUploadCount)) {
-        errCode = CloudStorageUtils::IdentifyCloudType(cloudDataResult, data, log, extraLog);
+        errCode = CloudStorageUtils::IdentifyCloudType(recorder, cloudDataResult, data, log, extraLog);
     } else {
         errCode = -E_UNFINISHED;
     }
-    if (errCode == E_OK) {
-        errCode = CheckIgnoreData(config, data, extraLog);
-    }
     if (errCode == -E_IGNORE_DATA) {
         errCode = E_OK;
         totalSize = preSize;
@@ -131,8 +134,16 @@ int SqliteCloudKvExecutorUtils::GetCloudDataForSync(const CloudSyncConfig &confi
 void SqliteCloudKvExecutorUtils::GetCloudLog(sqlite3_stmt *stmt, VBucket &logInfo,
     uint32_t &totalSize)
 {
-    logInfo.insert_or_assign(CloudDbConstant::MODIFY_FIELD,
-        static_cast<int64_t>(sqlite3_column_int64(stmt, CLOUD_QUERY_MODIFY_TIME_INDEX)));
+    int64_t modifyTime = static_cast<int64_t>(sqlite3_column_int64(stmt, CLOUD_QUERY_MODIFY_TIME_INDEX));
+    uint64_t curTime = 0;
+    if (TimeHelper::GetSysCurrentRawTime(curTime) == E_OK) {
+        if (modifyTime > static_cast<int64_t>(curTime)) {
+            modifyTime = static_cast<int64_t>(curTime);
+        }
+    } else {
+        LOGW("[SqliteCloudKvExecutorUtils] get raw sys time failed.");
+    }
+    logInfo.insert_or_assign(CloudDbConstant::MODIFY_FIELD, modifyTime);
     logInfo.insert_or_assign(CloudDbConstant::CREATE_FIELD,
         static_cast<int64_t>(sqlite3_column_int64(stmt, CLOUD_QUERY_CREATE_TIME_INDEX)));
     totalSize += sizeof(int64_t) + sizeof(int64_t);
@@ -161,6 +172,8 @@ void SqliteCloudKvExecutorUtils::GetCloudExtraLog(sqlite3_stmt *stmt, VBucket &f
     Bytes hashKey;
     (void)SQLiteUtils::GetColumnBlobValue(stmt, CLOUD_QUERY_HASH_KEY_INDEX, hashKey);
     flags.insert_or_assign(CloudDbConstant::HASH_KEY, hashKey);
+    flags.insert_or_assign(CloudDbConstant::CLOUD_FLAG,
+        static_cast<int64_t>(sqlite3_column_int64(stmt, CLOUD_QUERY_CLOUD_FLAG_INDEX)));
 }
 
 int SqliteCloudKvExecutorUtils::GetCloudKvData(sqlite3_stmt *stmt, VBucket &data, uint32_t &totalSize)
@@ -201,7 +214,10 @@ int SqliteCloudKvExecutorUtils::GetCloudKvBlobData(const std::string &keyStr, in
     if ((keyStr == CloudDbConstant::CLOUD_KV_FIELD_DEVICE ||
         keyStr == CloudDbConstant::CLOUD_KV_FIELD_ORI_DEVICE)) {
         if (tmp.empty()) {
-            (void)RuntimeContext::GetInstance()->GetLocalIdentity(tmp);
+            errCode = RuntimeContext::GetInstance()->GetLocalIdentity(tmp);
+            if (errCode != E_OK) {
+                return errCode;
+            }
             tmp = DBCommon::TransferHashString(tmp);
         }
         tmp = DBBase64Utils::Encode(std::vector<uint8_t>(tmp.begin(), tmp.end()));
@@ -211,24 +227,6 @@ int SqliteCloudKvExecutorUtils::GetCloudKvBlobData(const std::string &keyStr, in
     return E_OK;
 }
 
-int SqliteCloudKvExecutorUtils::CheckIgnoreData(const CloudSyncConfig &config, VBucket &data, VBucket &flags)
-{
-    auto iter = data.find(CloudDbConstant::CLOUD_KV_FIELD_VALUE);
-    if (iter == data.end()) {
-        return E_OK;
-    }
-    auto &valueStr = std::get<std::string>(iter->second);
-    if (valueStr.size() <= static_cast<size_t>(config.maxUploadSize)) {
-        return E_OK;
-    }
-    Bytes *hashKey = std::get_if<Bytes>(&flags[CloudDbConstant::HASH_KEY]);
-    if (hashKey != nullptr) {
-        LOGW("[SqliteCloudKvExecutorUtils] Ignore value size %zu hash is %.3s", valueStr.size(),
-            std::string(hashKey->begin(), hashKey->end()).c_str());
-    }
-    return -E_IGNORE_DATA;
-}
-
 std::pair<int, DataInfoWithLog> SqliteCloudKvExecutorUtils::GetLogInfo(sqlite3 *db, bool isMemory,
     const VBucket &cloudData)
 {
@@ -245,8 +243,10 @@ std::pair<int, DataInfoWithLog> SqliteCloudKvExecutorUtils::GetLogInfo(sqlite3 *
     }
     Bytes key;
     DBCommon::StringToVector(keyStr, key);
+    Bytes hashKey;
+    DBCommon::CalcValueHash(key, hashKey);
     sqlite3_stmt *stmt = nullptr;
-    std::tie(errCode, stmt) = GetLogInfoStmt(db, cloudData, !key.empty());
+    std::tie(errCode, stmt) = GetLogInfoStmt(db, cloudData, !hashKey.empty());
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Get stmt failed %d", errCode);
         return res;
@@ -257,7 +257,7 @@ std::pair<int, DataInfoWithLog> SqliteCloudKvExecutorUtils::GetLogInfo(sqlite3 *
         LOGE("[SqliteCloudKvExecutorUtils] Get gid failed %d", errCode);
         return res;
     }
-    return GetLogInfoInner(stmt, isMemory, gid, key);
+    return GetLogInfoInner(stmt, isMemory, gid, hashKey);
 }
 
 std::pair<int, sqlite3_stmt*> SqliteCloudKvExecutorUtils::GetLogInfoStmt(sqlite3 *db, const VBucket &cloudData,
@@ -270,7 +270,7 @@ std::pair<int, sqlite3_stmt*> SqliteCloudKvExecutorUtils::GetLogInfoStmt(sqlite3
     if (existKey) {
         sql += " UNION ";
         sql += QUERY_CLOUD_SYNC_DATA_LOG;
-        sql += " WHERE key = ?";
+        sql += " WHERE sync_data.hash_key = ?";
     }
     errCode = SQLiteUtils::GetStatement(db, sql, stmt);
     return res;
@@ -339,6 +339,7 @@ DataInfoWithLog SqliteCloudKvExecutorUtils::FillLogInfoWithStmt(sqlite3_stmt *st
     std::string keyStr(key.begin(), key.end());
     dataInfoWithLog.primaryKeys.insert_or_assign(CloudDbConstant::CLOUD_KV_FIELD_KEY, keyStr);
     (void)SQLiteUtils::GetColumnTextValue(stmt, index++, dataInfoWithLog.logInfo.version);
+    dataInfoWithLog.logInfo.cloud_flag = static_cast<uint64_t>(sqlite3_column_int64(stmt, index++));
     return dataInfoWithLog;
 }
 
@@ -466,11 +467,68 @@ std::string SqliteCloudKvExecutorUtils::GetOperateLogSql(OpType opType)
             return INSERT_CLOUD_SYNC_DATA_LOG;
         case OpType::DELETE:
             return UPDATE_CLOUD_SYNC_DATA_LOG;
+        case OpType::SET_CLOUD_FORCE_PUSH_FLAG_ZERO: // fallthrough
+        case OpType::SET_CLOUD_FORCE_PUSH_FLAG_ONE:  // fallthrough
+        case OpType::UPDATE_TIMESTAMP:               // fallthrough
+        case OpType::ONLY_UPDATE_GID:                // fallthrough
+        case OpType::NOT_HANDLE:                     // fallthrough
+        case OpType::CLEAR_GID:                      // fallthrough
+            return UPSERT_CLOUD_SYNC_DATA_LOG;
         default:
             return "";
     }
 }
 
+OpType SqliteCloudKvExecutorUtils::TransToOpType(const CloudWaterType type)
+{
+    switch (type) {
+        case CloudWaterType::INSERT:
+            return OpType::INSERT;
+        case CloudWaterType::UPDATE:
+            return OpType::UPDATE;
+        case CloudWaterType::DELETE:
+            return OpType::DELETE;
+        default:
+            return OpType::NOT_HANDLE;
+    }
+}
+
+int SqliteCloudKvExecutorUtils::BindOnlyUpdateLogStmt(sqlite3_stmt *logStmt, const std::string &user,
+    const DataItem &dataItem)
+{
+    int index = 0;
+    int errCode = SQLiteUtils::BindTextToStatement(logStmt, ++index, user);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind user failed %d when only insert log", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindBlobToStatement(logStmt, ++index, dataItem.hashKey);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind hashKey failed %d when only insert log", errCode);
+    }
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, ++index, dataItem.gid);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind gid failed %d when only insert gid.", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, ++index, dataItem.version);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind version failed %d when only insert log", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, ++index, dataItem.gid);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind gid failed %d when only update gid.", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, ++index, dataItem.version);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind version failed %d when only update log", errCode);
+        return errCode;
+    }
+    return errCode;
+}
+
 int SqliteCloudKvExecutorUtils::BindStmt(sqlite3_stmt *logStmt, sqlite3_stmt *dataStmt, int index, OpType opType,
     DownloadData &downloadData)
 {
@@ -506,28 +564,31 @@ int SqliteCloudKvExecutorUtils::BindInsertStmt(sqlite3_stmt *logStmt, sqlite3_st
 int SqliteCloudKvExecutorUtils::BindInsertLogStmt(sqlite3_stmt *logStmt, const std::string &user,
     const DataItem &dataItem)
 {
-    int index = 1;
-    int errCode = SQLiteUtils::BindTextToStatement(logStmt, index++, user);
+    int errCode = SQLiteUtils::BindTextToStatement(logStmt, BIND_INSERT_USER_INDEX, user);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind user failed %d when insert", errCode);
         return errCode;
     }
-    errCode = SQLiteUtils::BindBlobToStatement(logStmt, index++, dataItem.hashKey);
+    errCode = SQLiteUtils::BindBlobToStatement(logStmt, BIND_INSERT_HASH_KEY_INDEX, dataItem.hashKey);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind hashKey failed %d when insert", errCode);
         return errCode;
     }
-    errCode = SQLiteUtils::BindTextToStatement(logStmt, index++, dataItem.gid);
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, BIND_INSERT_CLOUD_GID_INDEX, dataItem.gid);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind gid failed %d when insert", errCode);
         return errCode;
     }
-    errCode = SQLiteUtils::BindTextToStatement(logStmt, index++, dataItem.version);
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, BIND_INSERT_VERSION_INDEX, dataItem.version);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind version failed %d when insert", errCode);
         return errCode;
     }
-    return E_OK;
+    errCode = SQLiteUtils::BindInt64ToStatement(logStmt, BIND_INSERT_CLOUD_FLAG_INDEX, dataItem.cloud_flag);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind cloud_flag failed %d when insert", errCode);
+    }
+    return errCode;
 }
 
 int SqliteCloudKvExecutorUtils::BindUpdateStmt(sqlite3_stmt *logStmt, sqlite3_stmt *dataStmt, const std::string &user,
@@ -558,6 +619,11 @@ int SqliteCloudKvExecutorUtils::BindUpdateLogStmt(sqlite3_stmt *logStmt, const s
         LOGE("[SqliteCloudKvExecutorUtils] Bind version failed %d when update", errCode);
         return errCode;
     }
+    errCode = SQLiteUtils::BindInt64ToStatement(logStmt, index++, dataItem.cloud_flag);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Bind cloud_flag failed %d when update", errCode);
+        return errCode;
+    }
     errCode = SQLiteUtils::BindTextToStatement(logStmt, index++, user);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind user failed %d when update", errCode);
@@ -686,24 +752,26 @@ int SqliteCloudKvExecutorUtils::StepStmt(sqlite3_stmt *logStmt, sqlite3_stmt *da
     return E_OK;
 }
 
-int SqliteCloudKvExecutorUtils::FillCloudLog(sqlite3 *db, OpType opType, const CloudSyncData &data,
-    const std::string &user, bool ignoreEmptyGid)
+int SqliteCloudKvExecutorUtils::FillCloudLog(const FillGidParam &param, OpType opType, const CloudSyncData &data,
+    const std::string &user, CloudUploadRecorder &recorder)
 {
-    if (db == nullptr) {
+    if (param.first == nullptr) {
         LOGE("[SqliteCloudKvExecutorUtils] Fill log got nullptr db");
         return -E_INVALID_ARGS;
     }
     if (data.isCloudVersionRecord) {
-        int errCode = FillCloudVersionRecord(db, opType, data);
+        int errCode = FillCloudVersionRecord(param.first, opType, data);
         if (errCode != E_OK) {
             return errCode;
         }
     }
     switch (opType) {
         case OpType::INSERT:
-            return FillCloudGid(db, data.insData, user, ignoreEmptyGid);
+            return FillCloudGid(param, data.insData, user, CloudWaterType::INSERT, recorder);
         case OpType::UPDATE:
-            return FillCloudGid(db, data.updData, user, ignoreEmptyGid);
+            return FillCloudGid(param, data.updData, user, CloudWaterType::UPDATE, recorder);
+        case OpType::DELETE:
+            return FillCloudGid(param, data.delData, user, CloudWaterType::DELETE, recorder);
         default:
             return E_OK;
     }
@@ -716,7 +784,7 @@ int SqliteCloudKvExecutorUtils::OnlyUpdateLogTable(sqlite3 *db, bool isMemory, i
         return E_OK;
     }
     sqlite3_stmt *logStmt = nullptr;
-    int errCode = SQLiteUtils::GetStatement(db, GetOperateLogSql(OpType::INSERT), logStmt);
+    int errCode = SQLiteUtils::GetStatement(db, GetOperateLogSql(op), logStmt);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Get update sync data stmt failed %d", errCode);
         return errCode;
@@ -743,7 +811,7 @@ int SqliteCloudKvExecutorUtils::OnlyUpdateLogTable(sqlite3 *db, bool isMemory, i
         res.second.gid.clear();
         res.second.version.clear();
     }
-    errCode = BindInsertLogStmt(logStmt, downloadData.user, res.second);
+    errCode = BindOnlyUpdateLogStmt(logStmt, downloadData.user, res.second);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -754,11 +822,12 @@ int SqliteCloudKvExecutorUtils::OnlyUpdateLogTable(sqlite3 *db, bool isMemory, i
     return errCode;
 }
 
-int SqliteCloudKvExecutorUtils::FillCloudGid(sqlite3 *db, const CloudSyncBatch &data, const std::string &user,
-    bool ignoreEmptyGid)
+int SqliteCloudKvExecutorUtils::FillCloudGid(const FillGidParam &param, const CloudSyncBatch &data,
+    const std::string &user, const CloudWaterType &type, CloudUploadRecorder &recorder)
 {
+    auto [db, ignoreEmptyGid] = param;
     sqlite3_stmt *logStmt = nullptr;
-    int errCode = SQLiteUtils::GetStatement(db, GetOperateLogSql(OpType::INSERT), logStmt);
+    int errCode = SQLiteUtils::GetStatement(db, GetOperateLogSql(TransToOpType(type)), logStmt);
     ResFinalizer finalizerData([logStmt]() {
         sqlite3_stmt *statement = logStmt;
         int ret = E_OK;
@@ -768,7 +837,7 @@ int SqliteCloudKvExecutorUtils::FillCloudGid(sqlite3 *db, const CloudSyncBatch &
         }
     });
     for (size_t i = 0; i < data.hashKey.size(); ++i) {
-        if (DBCommon::IsRecordError(data.extend[i])) {
+        if (DBCommon::IsRecordError(data.extend[i]) || DBCommon::IsRecordVersionConflict(data.extend[i])) {
             continue;
         }
         DataItem dataItem;
@@ -781,7 +850,7 @@ int SqliteCloudKvExecutorUtils::FillCloudGid(sqlite3 *db, const CloudSyncBatch &
         }
         CloudStorageUtils::GetValueFromVBucket(CloudDbConstant::VERSION_FIELD, data.extend[i], dataItem.version);
         dataItem.hashKey = data.hashKey[i];
-        errCode = BindInsertLogStmt(logStmt, user, dataItem);
+        errCode = BindFillGidLogStmt(logStmt, user, dataItem, data.extend[i], type);
         if (errCode != E_OK) {
             return errCode;
         }
@@ -794,6 +863,12 @@ int SqliteCloudKvExecutorUtils::FillCloudGid(sqlite3 *db, const CloudSyncBatch &
             return errCode;
         }
         SQLiteUtils::ResetStatement(logStmt, false, errCode);
+        MarkUploadSuccess(param, data, user, i);
+        // ignored version record
+        if (i >= data.timestamp.size()) {
+            continue;
+        }
+        recorder.RecordUploadRecord(CloudDbConstant::CLOUD_KV_TABLE_NAME, data.hashKey[i], type, data.timestamp[i]);
     }
     return E_OK;
 }
@@ -880,7 +955,10 @@ std::pair<int, DataItem> SqliteCloudKvExecutorUtils::GetDataItem(int index, Down
         return res;
     }
     std::string dev;
-    (void)RuntimeContext::GetInstance()->GetLocalIdentity(dev);
+    errCode = RuntimeContext::GetInstance()->GetLocalIdentity(dev);
+    if (errCode != E_OK) {
+        return res;
+    }
     dev = DBCommon::TransferHashString(dev);
     auto decodeDevice = DBBase64Utils::Decode(dataItem.dev);
     if (!decodeDevice.empty()) {
@@ -947,24 +1025,35 @@ std::pair<int, int64_t> SqliteCloudKvExecutorUtils::CountCloudData(sqlite3 *db,
     return CountCloudDataInner(db, isMemory, timestamp, user, sql);
 }
 
-std::pair<int, int64_t> SqliteCloudKvExecutorUtils::CountAllCloudData(sqlite3 *db, bool isMemory,
-    const std::vector<Timestamp> &timestampVec, const std::string &user, bool forcePush)
+std::pair<int, int64_t> SqliteCloudKvExecutorUtils::CountAllCloudData(const DBParam &param,
+    const std::vector<Timestamp> &timestampVec, const std::string &user, bool forcePush,
+    QuerySyncObject &querySyncObject)
 {
+    std::pair<int, int64_t> res = { E_OK, 0 };
+    auto &[errCode, count] = res;
     if (timestampVec.size() != 3) { // 3 is the number of three mode.
-        return std::pair(-E_INVALID_ARGS, 0);
+        errCode = -E_INVALID_ARGS;
+        return res;
     }
     std::vector<CloudWaterType> typeVec = DBCommon::GetWaterTypeVec();
-    std::pair<int, int64_t> result = std::pair(E_OK, 0);
+    SqliteQueryHelper helper = querySyncObject.GetQueryHelper(errCode);
+    if (errCode != E_OK) {
+        return res;
+    }
     for (size_t i = 0; i < typeVec.size(); i++) {
-        std::string sql = SqliteQueryHelper::GetKvCloudQuerySql(true, forcePush);
-        SqliteQueryHelper::AppendCloudQueryToGetDiffData(sql, typeVec[i], true);
-        std::pair<int, int64_t> res = CountCloudDataInner(db, isMemory, timestampVec[i], user, sql);
-        if (res.first != E_OK) {
+        sqlite3_stmt *stmt = nullptr;
+        errCode = helper.GetCountKvCloudDataStatement(param.first, forcePush, typeVec[i], stmt);
+        if (errCode != E_OK) {
             return res;
         }
-        result.second += res.second;
+        // count no use watermark
+        auto [err, cnt] = helper.BindCountKvCloudDataStatement(param.first, param.second, 0u, user, stmt);
+        if (err != E_OK) {
+            return { err, 0 };
+        }
+        count += cnt;
     }
-    return result;
+    return res;
 }
 
 int SqliteCloudKvExecutorUtils::FillCloudVersionRecord(sqlite3 *db, OpType opType, const CloudSyncData &data)
@@ -1037,7 +1126,10 @@ std::pair<int, CloudSyncData> SqliteCloudKvExecutorUtils::GetLocalCloudVersionIn
         }
     });
     std::string hashDev;
-    (void)RuntimeContext::GetInstance()->GetLocalIdentity(hashDev);
+    errCode = RuntimeContext::GetInstance()->GetLocalIdentity(hashDev);
+    if (errCode != E_OK) {
+        return res;
+    }
     std::string tempDev = DBCommon::TransferHashString(hashDev);
     hashDev = DBCommon::TransferStringToHex(tempDev);
     std::string key = CloudDbConstant::CLOUD_VERSION_RECORD_PREFIX_KEY + hashDev;
@@ -1069,12 +1161,12 @@ int SqliteCloudKvExecutorUtils::GetCloudVersionRecord(bool isMemory, sqlite3_stm
         LOGE("[SqliteCloudKvExecutorUtils] Get local version failed %d", errCode);
         return errCode;
     }
-    uint32_t stepNum = 0;
-    uint32_t totalSize = 0;
     CloudSyncConfig config;
     config.maxUploadSize = CloudDbConstant::MAX_UPLOAD_SIZE;
     config.maxUploadCount = 1;
-    errCode = GetCloudDataForSync(config, stmt, syncData, stepNum, totalSize);
+    CloudUploadRecorder recorder; // ignore last record
+    UploadDetail detail;
+    errCode = GetCloudDataForSync(config, recorder, stmt, syncData, detail);
     return errCode;
 }
 
@@ -1085,8 +1177,9 @@ void SqliteCloudKvExecutorUtils::InitDefaultCloudVersionRecord(const std::string
     VBucket defaultRecord;
     defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_KEY] = key;
     defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_VALUE] = std::string("");
-    defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_DEVICE] = dev;
-    defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_ORI_DEVICE] = dev;
+    auto encodeDev = DBBase64Utils::Encode(dev);
+    defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_DEVICE] = encodeDev;
+    defaultRecord[CloudDbConstant::CLOUD_KV_FIELD_ORI_DEVICE] = encodeDev;
     syncData.insData.record.push_back(std::move(defaultRecord));
     VBucket defaultExtend;
     defaultExtend[CloudDbConstant::HASH_KEY_FIELD] = DBCommon::TransferStringToHex(key);
@@ -1101,7 +1194,10 @@ int SqliteCloudKvExecutorUtils::BindVersionStmt(const std::string &device, const
     sqlite3_stmt *dataStmt)
 {
     std::string hashDevice;
-    (void)RuntimeContext::GetInstance()->GetLocalIdentity(hashDevice);
+    int errCode = RuntimeContext::GetInstance()->GetLocalIdentity(hashDevice);
+    if (errCode != E_OK) {
+        return errCode;
+    }
     Bytes bytes;
     if (device == hashDevice) {
         DBCommon::StringToVector("", bytes);
@@ -1109,7 +1205,7 @@ int SqliteCloudKvExecutorUtils::BindVersionStmt(const std::string &device, const
         hashDevice = DBCommon::TransferHashString(device);
         DBCommon::StringToVector(hashDevice, bytes);
     }
-    int errCode = SQLiteUtils::BindBlobToStatement(dataStmt, BIND_CLOUD_VERSION_DEVICE_INDEX, bytes);
+    errCode = SQLiteUtils::BindBlobToStatement(dataStmt, BIND_CLOUD_VERSION_DEVICE_INDEX, bytes);
     if (errCode != E_OK) {
         LOGE("[SqliteCloudKvExecutorUtils] Bind device failed %d", errCode);
     }
@@ -1170,4 +1266,178 @@ int SqliteCloudKvExecutorUtils::GetCloudVersionRecordData(sqlite3_stmt *stmt, VB
     }
     return GetCloudKvBlobData(CloudDbConstant::CLOUD_KV_FIELD_DEVICE, CLOUD_QUERY_DEV_INDEX, stmt, data, totalSize);
 }
+
+int SqliteCloudKvExecutorUtils::GetWaitCompensatedSyncDataPk(sqlite3 *db, bool isMemory, std::vector<VBucket> &data)
+{
+    sqlite3_stmt *stmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(db, SELECT_COMPENSATE_SYNC_KEY_SQL, stmt);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] Get compensate key stmt failed %d", errCode);
+        return errCode;
+    }
+    ResFinalizer finalizerData([stmt]() {
+        int ret = E_OK;
+        sqlite3_stmt *statement = stmt;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("[SqliteCloudKvExecutorUtils] Reset compensate key stmt failed %d", ret);
+        }
+    });
+    uint32_t totalSize = 0;
+    do {
+        errCode = SQLiteUtils::StepWithRetry(stmt, isMemory);
+        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+            errCode = E_OK;
+            break;
+        } else if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+            LOGE("[SqliteCloudKvExecutorUtils] Get key from compensate key stmt failed. %d", errCode);
+            break;
+        }
+        VBucket key;
+        errCode = GetCloudKvBlobData(CloudDbConstant::CLOUD_KV_FIELD_KEY, CLOUD_QUERY_KEY_INDEX, stmt, key, totalSize);
+        if (errCode != E_OK) {
+            return errCode;
+        }
+        data.push_back(key);
+    } while (errCode == E_OK);
+    return errCode;
+}
+
+int SqliteCloudKvExecutorUtils::QueryCloudGid(sqlite3 *db, bool isMemory, const std::string &user,
+    QuerySyncObject &querySyncObject, std::vector<std::string> &cloudGid)
+{
+    int errCode = E_OK;
+    QuerySyncObject query = querySyncObject;
+    SqliteQueryHelper helper = query.GetQueryHelper(errCode);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    sqlite3_stmt *stmt = nullptr;
+    errCode = helper.GetAndBindGidKvCloudQueryStatement(user, db, stmt);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    do {
+        errCode = SQLiteUtils::StepWithRetry(stmt, isMemory);
+        if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+            errCode = E_OK;
+            break;
+        } else if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+            LOGE("[SqliteCloudKvExecutorUtils] Get cloud version from cloud failed. %d", errCode);
+            break;
+        }
+        std::string gid;
+        errCode = SQLiteUtils::GetColumnTextValue(stmt, 0, gid);
+        cloudGid.push_back(gid);
+    } while (errCode == E_OK);
+    int ret = E_OK;
+    SQLiteUtils::ResetStatement(stmt, true, ret);
+    return errCode == E_OK ? ret : errCode;
+}
+
+int SqliteCloudKvExecutorUtils::BindFillGidLogStmt(sqlite3_stmt *logStmt, const std::string &user,
+    const DataItem &dataItem, const VBucket &uploadExtend, const CloudWaterType &type)
+{
+    DataItem wItem = dataItem;
+    if (DBCommon::IsNeedCompensatedForUpload(uploadExtend, type)) {
+        wItem.cloud_flag |= static_cast<uint32_t>(LogInfoFlag::FLAG_WAIT_COMPENSATED_SYNC);
+    }
+    if (DBCommon::IsCloudRecordNotFound(uploadExtend) &&
+        (type == CloudWaterType::UPDATE || type == CloudWaterType::DELETE)) {
+        wItem.gid = {};
+        wItem.version = {};
+    }
+    int errCode = E_OK;
+    if (type == CloudWaterType::DELETE) {
+        if (DBCommon::IsCloudRecordNotFound(uploadExtend)) {
+            errCode = BindUpdateLogStmt(logStmt, user, wItem);
+        }
+    } else {
+        errCode = BindInsertLogStmt(logStmt, user, wItem);
+    }
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvExecutorUtils] fill cloud gid failed. %d", errCode);
+    }
+    return errCode;
+}
+
+void SqliteCloudKvExecutorUtils::MarkUploadSuccess(const FillGidParam &param, const CloudSyncBatch &data,
+    const std::string &user, size_t dataIndex)
+{
+    if (data.extend.size() <= dataIndex || data.hashKey.size() <= dataIndex || data.timestamp.size() <= dataIndex) {
+        LOGW("[SqliteCloudKvExecutorUtils] invalid index %zu when mark upload success", dataIndex);
+        return;
+    }
+    if (!DBCommon::IsRecordSuccess(data.extend[dataIndex])) {
+        return;
+    }
+    if (CheckDataChanged(param, data, dataIndex)) {
+        LOGW("[SqliteCloudKvExecutorUtils] %zu data changed when mark upload success", dataIndex);
+        return;
+    }
+    MarkUploadSuccessInner(param, data, user, dataIndex);
+}
+
+bool SqliteCloudKvExecutorUtils::CheckDataChanged(const FillGidParam &param,
+    const CloudSyncBatch &data, size_t dataIndex)
+{
+    sqlite3_stmt *checkStmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(param.first, CHECK_DATA_CHANGED, checkStmt);
+    ResFinalizer finalizerData([checkStmt]() {
+        sqlite3_stmt *statement = checkStmt;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("[SqliteCloudKvExecutorUtils] reset log stmt failed %d when check data changed", ret);
+        }
+    });
+    int index = 1;
+    errCode = SQLiteUtils::BindInt64ToStatement(checkStmt, index++, data.timestamp[dataIndex]);
+    if (errCode != E_OK) {
+        LOGW("[SqliteCloudKvExecutorUtils] bind modify time failed %d when check data changed", errCode);
+        return true;
+    }
+    errCode = SQLiteUtils::BindBlobToStatement(checkStmt, index++, data.hashKey[dataIndex]);
+    if (errCode != E_OK) {
+        LOGW("[SqliteCloudKvExecutorUtils] bind hashKey failed %d when check data changed", errCode);
+        return true;
+    }
+    errCode = SQLiteUtils::StepNext(checkStmt);
+    if (errCode != E_OK) {
+        LOGW("[SqliteCloudKvExecutorUtils] step failed %d when check data changed", errCode);
+        return true;
+    }
+    return sqlite3_column_int64(checkStmt, 0) == 0; // get index start at 0, get 0 is data changed
+}
+
+void SqliteCloudKvExecutorUtils::MarkUploadSuccessInner(const FillGidParam &param,
+    const CloudSyncBatch &data, const std::string &user, size_t dataIndex)
+{
+    sqlite3_stmt *logStmt = nullptr;
+    int errCode = SQLiteUtils::GetStatement(param.first, MARK_UPLOAD_SUCCESS, logStmt);
+    ResFinalizer finalizerData([logStmt]() {
+        sqlite3_stmt *statement = logStmt;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("[SqliteCloudKvExecutorUtils] reset log stmt failed %d when mark upload success", ret);
+        }
+    });
+    int index = 1;
+    errCode = SQLiteUtils::BindBlobToStatement(logStmt, index++, data.hashKey[dataIndex]);
+    if (errCode != E_OK) {
+        LOGW("[SqliteCloudKvExecutorUtils] bind hashKey failed %d when mark upload success", errCode);
+        return;
+    }
+    errCode = SQLiteUtils::BindTextToStatement(logStmt, index++, user);
+    if (errCode != E_OK) {
+        LOGW("[SqliteCloudKvExecutorUtils] bind hashKey failed %d when mark upload success", errCode);
+        return;
+    }
+    errCode = SQLiteUtils::StepNext(logStmt);
+    if (errCode != E_OK && errCode != -E_FINISHED) {
+        LOGW("[SqliteCloudKvExecutorUtils] step failed %d when mark upload success", errCode);
+        return;
+    }
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.h
index a347c750a475b84f23c4ca3720e1c296afb18a61..00e7bc7269fe546944425870b04301b3edb2049f 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_executor_utils.h
@@ -18,6 +18,8 @@
 
 #include "cloud/cloud_db_types.h"
 
+#include "cloud/cloud_db_types.h"
+#include "cloud/cloud_upload_recorder.h"
 #include "data_transformer.h"
 #include "icloud_sync_storage_interface.h"
 #include "sqlite_single_ver_continue_token.h"
@@ -26,29 +28,37 @@
 namespace DistributedDB {
 class SqliteCloudKvExecutorUtils {
 public:
-    static int GetCloudData(const CloudSyncConfig &config, sqlite3 *db, bool isMemory,
+    using DBParam = std::pair<sqlite3 *, bool>;
+    using FillGidParam = std::pair<sqlite3 *, bool>;
+    static int GetCloudData(const CloudSyncConfig &config, const DBParam &param, const CloudUploadRecorder &recorder,
         SQLiteSingleVerContinueToken &token, CloudSyncData &data);
 
     static std::pair<int, DataInfoWithLog> GetLogInfo(sqlite3 *db, bool isMemory, const VBucket &cloudData);
 
     static int PutCloudData(sqlite3 *db, bool isMemory, DownloadData &downloadData);
 
-    static int FillCloudLog(sqlite3 *db, OpType opType, const CloudSyncData &data, const std::string &user,
-        bool ignoreEmptyGid);
+    static int FillCloudLog(const FillGidParam &param, OpType opType, const CloudSyncData &data,
+        const std::string &user, CloudUploadRecorder &recorder);
 
     static std::pair<int, int64_t> CountCloudData(sqlite3 *db, bool isMemory, const Timestamp &timestamp,
         const std::string &user, bool forcePush);
 
-    static std::pair<int, int64_t> CountAllCloudData(sqlite3 *db, bool isMemory,
-        const std::vector<Timestamp> &timestampVec, const std::string &user, bool forcePush);
+    static std::pair<int, int64_t> CountAllCloudData(const DBParam &param, const std::vector<Timestamp> &timestampVec,
+        const std::string &user, bool forcePush, QuerySyncObject &querySyncObject);
 
     static std::pair<int, CloudSyncData> GetLocalCloudVersion(sqlite3 *db, bool isMemory, const std::string &user);
 
     static int GetCloudVersionFromCloud(sqlite3 *db, bool isMemory, const std::string &user,
         const std::string &device, std::vector<VBucket> &dataVector);
+
+    static int GetWaitCompensatedSyncDataPk(sqlite3 *db, bool isMemory, std::vector<VBucket> &data);
+
+    static int QueryCloudGid(sqlite3 *db, bool isMemory, const std::string &user, QuerySyncObject &querySyncObject,
+        std::vector<std::string> &cloudGid);
 private:
-    static int GetCloudDataForSync(const CloudSyncConfig &config, sqlite3_stmt *statement,
-        CloudSyncData &cloudDataResult, uint32_t &stepNum, uint32_t &totalSize);
+    using UploadDetail = std::pair<uint32_t, uint32_t>;
+    static int GetCloudDataForSync(const CloudSyncConfig &config, const CloudUploadRecorder &recorder,
+        sqlite3_stmt *statement, CloudSyncData &cloudDataResult, UploadDetail &detail);
 
     static void GetCloudLog(sqlite3_stmt *stmt, VBucket &logInfo, uint32_t &totalSize);
 
@@ -59,8 +69,6 @@ private:
     static int GetCloudKvBlobData(const std::string &keyStr, int index, sqlite3_stmt *stmt,
         VBucket &data, uint32_t &totalSize);
 
-    static int CheckIgnoreData(const CloudSyncConfig &config, VBucket &data, VBucket &flags);
-
     static std::pair<int, sqlite3_stmt*> GetLogInfoStmt(sqlite3 *db, const VBucket &cloudData, bool existKey);
 
     static std::pair<int, DataInfoWithLog> GetLogInfoInner(sqlite3_stmt *stmt, bool isMemory, const std::string &gid,
@@ -78,6 +86,10 @@ private:
 
     static std::string GetOperateLogSql(OpType opType);
 
+    static OpType TransToOpType(const CloudWaterType type);
+
+    static int BindOnlyUpdateLogStmt(sqlite3_stmt *logStmt, const std::string &user, const DataItem &dataItem);
+
     static int BindStmt(sqlite3_stmt *logStmt, sqlite3_stmt *dataStmt, int index, OpType opType,
         DownloadData &downloadData);
 
@@ -111,7 +123,8 @@ private:
 
     static int BindUpdateTimestampStmt(sqlite3_stmt *dataStmt, int index, DownloadData &downloadData);
 
-    static int FillCloudGid(sqlite3 *db, const CloudSyncBatch &data, const std::string &user, bool ignoreEmptyGid);
+    static int FillCloudGid(const FillGidParam &param, const CloudSyncBatch &data, const std::string &user,
+        const CloudWaterType &type, CloudUploadRecorder &recorder);
 
     static std::pair<int, DataItem> GetDataItem(int index, DownloadData &downloadData);
 
@@ -134,6 +147,17 @@ private:
     static Timestamp GetMaxTimeStamp(std::vector<VBucket> &dataExtend);
 
     static bool UpdateBeginTimeForMemoryDB(SQLiteSingleVerContinueToken &token, CloudSyncData &data);
+
+    static int BindFillGidLogStmt(sqlite3_stmt *logStmt, const std::string &user,
+        const DataItem &dataItem, const VBucket &uploadExtend, const CloudWaterType &type);
+private:
+    static void MarkUploadSuccess(const FillGidParam &param, const CloudSyncBatch &data, const std::string &user,
+        size_t dataIndex);
+
+    static bool CheckDataChanged(const FillGidParam &param, const CloudSyncBatch &data, size_t dataIndex);
+
+    static void MarkUploadSuccessInner(const FillGidParam &param, const CloudSyncBatch &data, const std::string &user,
+        size_t dataIndex);
 };
 }
 #endif // SQLITE_CLOUD_KV_EXECUTOR_UTILS_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.cpp
index f02f389e4c8de09fa1b21c30d583b5d34d68887d..71d27673f78582d3367b49e00525fe9a8a2b0e48 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.cpp
@@ -16,6 +16,9 @@
 
 #include "cloud/cloud_db_constant.h"
 #include "cloud/cloud_storage_utils.h"
+#include "db_base64_utils.h"
+#include "db_common.h"
+#include "query_utils.h"
 #include "runtime_context.h"
 #include "sqlite_cloud_kv_executor_utils.h"
 #include "sqlite_single_ver_continue_token.h"
@@ -69,7 +72,7 @@ int SqliteCloudKvStore::GetCloudTableSchema(const TableName &tableName,
     std::lock_guard<std::mutex> autoLock(schemaMutex_);
     if (schema_.find(user_) == schema_.end()) {
         LOGE("[SqliteCloudKvStore] not set cloud schema");
-        return -E_NOT_FOUND;
+        return -E_SCHEMA_MISMATCH;
     }
     auto it = std::find_if(schema_[user_].tables.begin(), schema_[user_].tables.end(), [&](const auto &table) {
         return table.name == tableName;
@@ -157,7 +160,7 @@ int SqliteCloudKvStore::GetUploadCount([[gnu::unused]] const QuerySyncObject &qu
     return errCode;
 }
 
-int SqliteCloudKvStore::GetAllUploadCount([[gnu::unused]] const QuerySyncObject &query,
+int SqliteCloudKvStore::GetAllUploadCount(const QuerySyncObject &query,
     const std::vector<Timestamp> &timestampVec, bool isCloudForcePush, [[gnu::unused]] bool isCompensatedTask,
     int64_t &count)
 {
@@ -167,8 +170,9 @@ int SqliteCloudKvStore::GetAllUploadCount([[gnu::unused]] const QuerySyncObject
         return -E_INTERNAL_ERROR;
     }
     int errCode = E_OK;
-    std::tie(errCode, count) = SqliteCloudKvExecutorUtils::CountAllCloudData(db, isMemory, timestampVec, user_,
-        isCloudForcePush);
+    QuerySyncObject queryObj = query;
+    std::tie(errCode, count) = SqliteCloudKvExecutorUtils::CountAllCloudData({ db, isMemory }, timestampVec, user_,
+        isCloudForcePush, queryObj);
     return errCode;
 }
 
@@ -176,13 +180,16 @@ int SqliteCloudKvStore::GetCloudData(const TableSchema &tableSchema, const Query
     const Timestamp &beginTime, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult)
 {
     SyncTimeRange timeRange;
-    timeRange.beginTime = beginTime;
+    // memory db use watermark
+    timeRange.beginTime = GetTransactionDbHandleAndMemoryStatus().second ? beginTime : 0;
     auto token = new (std::nothrow) SQLiteSingleVerContinueToken(timeRange, object);
     if (token == nullptr) {
         LOGE("[SqliteCloudKvStore] create token failed");
         return -E_OUT_OF_MEMORY;
     }
     token->SetUser(user_);
+    recorder_.SetUser(user_);
+    cloudDataResult.tableName = CloudDbConstant::CLOUD_KV_TABLE_NAME;
     continueStmtToken = static_cast<ContinueToken>(token);
     return GetCloudDataNext(continueStmtToken, cloudDataResult);
 }
@@ -204,7 +211,8 @@ int SqliteCloudKvStore::GetCloudDataNext(ContinueToken &continueStmtToken, Cloud
         ReleaseCloudDataToken(continueStmtToken);
         return -E_INTERNAL_ERROR;
     }
-    int errCode = SqliteCloudKvExecutorUtils::GetCloudData(GetCloudSyncConfig(), db, isMemory, *token, cloudDataResult);
+    int errCode = SqliteCloudKvExecutorUtils::GetCloudData(GetCloudSyncConfig(), {db, isMemory}, recorder_, *token,
+        cloudDataResult);
     if (errCode != -E_UNFINISHED) {
         ReleaseCloudDataToken(continueStmtToken);
     } else {
@@ -270,7 +278,7 @@ int SqliteCloudKvStore::FillCloudLogAndAsset(OpType opType, const CloudSyncData
     }
     sqlite3 *db = nullptr;
     (void)handle->GetDbHandle(db);
-    errCode = SqliteCloudKvExecutorUtils::FillCloudLog(db, opType, data, user_, ignoreEmptyGid);
+    errCode = SqliteCloudKvExecutorUtils::FillCloudLog({db, ignoreEmptyGid}, opType, data, user_, recorder_);
     int ret = E_OK;
     if (handle->IsMemory()) {
         ret = StartTransaction(TransactType::DEFERRED);
@@ -340,7 +348,20 @@ std::string SqliteCloudKvStore::GetIdentify() const
 int SqliteCloudKvStore::GetCloudGid(const TableSchema &tableSchema, const QuerySyncObject &querySyncObject,
     bool isCloudForcePush, bool isCompensatedTask, std::vector<std::string> &cloudGid)
 {
-    return E_OK;
+    auto[errCode, handle] = storageHandle_->GetStorageExecutor(false);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvStore] get handle failed %d", errCode);
+        return errCode;
+    }
+    sqlite3 *db = nullptr;
+    (void)handle->GetDbHandle(db);
+    QuerySyncObject query = querySyncObject;
+    errCode = SqliteCloudKvExecutorUtils::QueryCloudGid(db, handle->IsMemory(), user_, query, cloudGid);
+    storageHandle_->RecycleStorageExecutor(handle);
+    if (errCode != E_OK) {
+        LOGE("[SqliteCloudKvStore] Query cloud gid failed %d", errCode);
+    }
+    return errCode;
 }
 
 int SqliteCloudKvStore::FillCloudAssetForDownload(const std::string &tableName, VBucket &asset, bool isDownloadSuccess)
@@ -408,12 +429,12 @@ int SqliteCloudKvStore::GetCloudVersion(const std::string &device, std::map<std:
         return errCode;
     }
     for (VBucket &data : dataVector) {
-        auto res = CloudStorageUtils::GetDataItemFromCloudVersionData(data);
-        auto &[errCodeNext, dataItem] = res;
+        auto [errCodeNext, dataItem] = CloudStorageUtils::GetDataItemFromCloudVersionData(data);
         if (errCodeNext != E_OK) {
             LOGE("[SqliteCloudKvStore] get dataItem failed %d", errCodeNext);
             return errCodeNext;
         }
+        dataItem.dev = DBBase64Utils::DecodeIfNeed(dataItem.dev);
         std::vector<uint8_t> blob = dataItem.value;
         std::string version = std::string(blob.begin(), blob.end());
         std::pair<std::string, std::string> versionPair = std::pair<std::string, std::string>(dataItem.dev, version);
@@ -486,8 +507,7 @@ bool SqliteCloudKvStore::CheckSchema(std::map<std::string, DataBaseSchema> schem
         }
         for (uint32_t i = 0; i < actualTable.fields.size(); i++) {
             Field actualField = actualTable.fields[i];
-            auto it = std::find(expectFields.begin(), expectFields.end(), actualField);
-            if (it == expectFields.end()) {
+            if (std::find(expectFields.begin(), expectFields.end(), actualField) == expectFields.end()) {
                 LOGE("[SqliteCloudKvStore] check fields failed.");
                 return false;
             }
@@ -513,4 +533,74 @@ std::map<std::string, DataBaseSchema> SqliteCloudKvStore::GetDataBaseSchemas()
     std::lock_guard<std::mutex> autoLock(schemaMutex_);
     return schema_;
 }
+
+void SqliteCloudKvStore::ReleaseUploadRecord(const std::string &tableName, const CloudWaterType &type,
+    Timestamp localMark)
+{
+    recorder_.ReleaseUploadRecord(tableName, type, localMark);
+}
+
+bool SqliteCloudKvStore::IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo)
+{
+    std::string device;
+    if (RuntimeContext::GetInstance()->GetLocalIdentity(device) != E_OK) {
+        LOGE("[SqliteCloudKvStore] GetLocalIdentity device failed.");
+        return false;
+    }
+    device = DBCommon::TransferHashString(device);
+    std::string localInfoDev = localInfo.device;
+    std::string cloudInfoDev;
+    auto decodeCloudInfoDev = DBBase64Utils::Decode(cloudInfo.device);
+    if (!decodeCloudInfoDev.empty()) {
+        cloudInfoDev = std::string(decodeCloudInfoDev.begin(), decodeCloudInfoDev.end());
+    }
+    bool isLocal = (localInfo.flag & static_cast<uint32_t>(LogInfoFlag::FLAG_LOCAL)) ==
+        static_cast<uint32_t>(LogInfoFlag::FLAG_LOCAL);
+    bool isLocalDelete = (localInfo.flag & static_cast<uint32_t>(LogInfoFlag::FLAG_DELETE)) ==
+        static_cast<uint32_t>(LogInfoFlag::FLAG_DELETE);
+    if (cloudInfoDev.empty()) {
+        return !isLocal;
+    } else if (isLocalDelete) {
+        return cloudInfoDev != device;
+    }
+    return localInfoDev == cloudInfoDev && localInfoDev != device;
+}
+
+int SqliteCloudKvStore::GetCompensatedSyncQuery(std::vector<QuerySyncObject> &syncQuery)
+{
+    std::shared_ptr<DataBaseSchema> cloudSchema;
+    (void)GetCloudDbSchema(cloudSchema);
+    if (cloudSchema == nullptr) {
+        return -E_INVALID_SCHEMA;
+    }
+    if (cloudSchema->tables.empty()) {
+        return E_OK;
+    }
+    int ret = StartTransaction(TransactType::DEFERRED);
+    if (ret != E_OK) {
+        return ret;
+    }
+    sqlite3 *db = nullptr;
+    (void)transactionHandle_->GetDbHandle(db);
+    for (const auto &table: cloudSchema->tables) {
+        std::vector<VBucket> syncDataPk;
+        int errCode = SqliteCloudKvExecutorUtils::GetWaitCompensatedSyncDataPk(db, transactionHandle_->IsMemory(),
+            syncDataPk);
+        if (errCode != E_OK) {
+            LOGW("[SqliteCloudKvStore] Get wait compensated sync date failed, continue! errCode=%d", errCode);
+            continue;
+        }
+        if (syncDataPk.empty()) {
+            continue;
+        }
+        QuerySyncObject syncObject;
+        errCode = CloudStorageUtils::GetSyncQueryByPk(table.name, syncDataPk, true, syncObject);
+        if (errCode != E_OK) {
+            LOGW("[SqliteCloudKvStore] Get compensated sync query happen error, ignore it! errCode = %d", errCode);
+            continue;
+        }
+        syncQuery.push_back(syncObject);
+    }
+    return Commit();
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.h
index 9f905e31fbeee2f14b60fe411bff9dc415e811de..b0b2284974e0801aacae6569324fdda5b5a147b6 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_cloud_kv_store.h
@@ -16,6 +16,7 @@
 #define SQLITE_CLOUD_STORE_H
 
 #include "icloud_sync_storage_interface.h"
+#include "cloud/cloud_upload_recorder.h"
 #include "kv_storage_handle.h"
 
 namespace DistributedDB {
@@ -94,6 +95,13 @@ public:
     CloudSyncConfig GetCloudSyncConfig() const override;
 
     std::map<std::string, DataBaseSchema> GetDataBaseSchemas();
+
+    void ReleaseUploadRecord(const std::string &tableName, const CloudWaterType &type, Timestamp localMark) override;
+
+    bool IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo) override;
+
+    int GetCompensatedSyncQuery(std::vector<QuerySyncObject> &syncQuery) override;
+
 private:
     std::pair<sqlite3 *, bool> GetTransactionDbHandleAndMemoryStatus();
 
@@ -118,6 +126,8 @@ private:
 
     mutable std::mutex configMutex_;
     CloudSyncConfig config_;
+
+    CloudUploadRecorder recorder_;
 };
 }
 #endif // SQLITE_CLOUD_STORE_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_local_storage_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_local_storage_executor.cpp
index c6bbc76400808f7e1063c5ba15c38d7894c2a877..56c10e75ec170d99446d66e3586e22cdcce97ab5 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_local_storage_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_local_storage_executor.cpp
@@ -48,17 +48,17 @@ int SQLiteLocalStorageExecutor::Get(const Key &key, Value &value) const
 {
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_SQL, statement);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return CheckCorruptedStatus(errCode);
     }
 
     errCode = SQLiteUtils::BindBlobToStatement(statement, SELECT_BIND_KEY_INDEX, key, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         goto END;
     }
 
     errCode = SQLiteUtils::StepWithRetry(statement);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
         errCode = -E_NOT_FOUND;
         goto END;
     } else if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
@@ -83,13 +83,13 @@ int SQLiteLocalStorageExecutor::GetEntries(const Key &keyPrefix,
 {
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, SELECT_BATCH_SQL, statement);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return CheckCorruptedStatus(errCode);
     }
 
     Entry entry;
     errCode = SQLiteUtils::BindPrefixKey(statement, SELECT_BIND_KEY_INDEX, keyPrefix); // first arg is prefix key
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         goto END;
     }
 
@@ -97,12 +97,12 @@ int SQLiteLocalStorageExecutor::GetEntries(const Key &keyPrefix,
         errCode = SQLiteUtils::StepWithRetry(statement);
         if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
             errCode = SQLiteUtils::GetColumnBlobValue(statement, SELECT_RESULT_KEY_INDEX, entry.key);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 goto END;
             }
 
             errCode = SQLiteUtils::GetColumnBlobValue(statement, SELECT_RESULT_VAL_INDEX, entry.value);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 goto END;
             }
 
@@ -116,7 +116,7 @@ int SQLiteLocalStorageExecutor::GetEntries(const Key &keyPrefix,
     } while (true);
 
     // if select no result, return the -E_NOT_FOUND.
-    if (entries.empty()) {
+    if (entries.empty()) { // LCOV_EXCL_BR_LINE
         errCode = -E_NOT_FOUND;
     } else {
         errCode = E_OK;
@@ -129,14 +129,14 @@ END:
 
 int SQLiteLocalStorageExecutor::PutBatch(const std::vector<Entry> &entries)
 {
-    if (entries.empty()) {
+    if (entries.empty()) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     for (const auto &entry : entries) {
         // first argument is key and second argument is value.
         int errCode = Put(entry.key, entry.value);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("PutBatch failed: %d", errCode);
             return CheckCorruptedStatus(errCode);
         }
@@ -147,7 +147,7 @@ int SQLiteLocalStorageExecutor::PutBatch(const std::vector<Entry> &entries)
 
 int SQLiteLocalStorageExecutor::DeleteBatch(const std::vector<Key> &keys)
 {
-    if (keys.empty()) {
+    if (keys.empty()) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
@@ -155,15 +155,15 @@ int SQLiteLocalStorageExecutor::DeleteBatch(const std::vector<Key> &keys)
 
     for (const auto &key : keys) {
         int errCode = Delete(key);
-        if (errCode != E_OK && errCode != -E_NOT_FOUND) {
+        if (errCode != E_OK && errCode != -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             return CheckCorruptedStatus(errCode);
         }
-        if (errCode != -E_NOT_FOUND && isAllNoExisted == true) {
+        if (errCode != -E_NOT_FOUND && isAllNoExisted == true) { // LCOV_EXCL_BR_LINE
             isAllNoExisted = false;
         }
     }
 
-    if (isAllNoExisted) {
+    if (isAllNoExisted) { // LCOV_EXCL_BR_LINE
         return -E_NOT_FOUND;
     }
 
@@ -192,24 +192,24 @@ int SQLiteLocalStorageExecutor::Put(const Key &key, const Value &value)
 {
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, INSERT_SQL, statement);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return CheckCorruptedStatus(errCode);
     }
 
     errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KEY_INDEX, key, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Failed to bind the key.");
         goto END;
     }
 
     errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_VAL_INDEX, value, true);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Failed to bind the value");
         goto END;
     }
 
     errCode = SQLiteUtils::StepWithRetry(statement);
-    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
         errCode = E_OK;
     } else {
         errCode = SQLiteUtils::MapSQLiteErrno(errCode);
@@ -224,22 +224,22 @@ int SQLiteLocalStorageExecutor::Delete(const Key &key)
 {
     sqlite3_stmt *statement = nullptr;
     int errCode = SQLiteUtils::GetStatement(dbHandle_, DELETE_SQL, statement);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Failed to get the delete statememt.");
         return CheckCorruptedStatus(errCode);
     }
 
     errCode = SQLiteUtils::BindBlobToStatement(statement, BIND_KEY_INDEX, key, false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Bind key failed");
         goto END;
     }
 
     errCode = SQLiteUtils::StepWithRetry(statement);
-    if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+    if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) { // LCOV_EXCL_BR_LINE
         LOGE("Delete step error:%d", errCode);
     } else {
-        if (sqlite3_changes(dbHandle_) > 0) {
+        if (sqlite3_changes(dbHandle_) > 0) { // LCOV_EXCL_BR_LINE
             errCode = E_OK;
         } else {
             errCode = -E_NOT_FOUND;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.cpp
index 9acd7e0da329128063cf864eddd00cb9c1f23678..acac0f445813b061d5da1cbf5841246929e31085 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.cpp
@@ -86,6 +86,7 @@ int SqliteLogTableManager::CreateKvSyncLogTable(sqlite3 *db)
         "hash_key  BLOB NOT NULL," + \
         "cloud_gid TEXT," + \
         "version   TEXT," + \
+        "cloud_flag INT DEFAULT 0," + \
         primaryKey + ");";
     int errCode = SQLiteUtils::ExecuteRawSQL(db, createTableSql);
     if (errCode != E_OK) {
@@ -97,7 +98,7 @@ int SqliteLogTableManager::CreateKvSyncLogTable(sqlite3 *db)
     if (errCode != E_OK) {
         LOGE("[LogTableManager] execute create gid index failed, errCode=%d", errCode);
     }
-    return errCode;
+    return UpgradeKvSyncLogTable(tableName, db);
 }
 
 void SqliteLogTableManager::GetIndexSql(const TableInfo &table, std::vector<std::string> &schema)
@@ -117,4 +118,35 @@ std::string SqliteLogTableManager::GetLogTableName(const TableInfo &table) const
 {
     return DBConstant::RELATIONAL_PREFIX + table.GetTableName() + "_log";
 }
+
+int SqliteLogTableManager::UpgradeKvSyncLogTable(const std::string &tableName, sqlite3 *db)
+{
+    TableInfo tableInfo;
+    int errCode = SQLiteUtils::AnalysisSchemaFieldDefine(db, tableName, tableInfo);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    auto fields = tableInfo.GetFields();
+    if (fields.find("cloud_flag") != fields.end()) {
+        return CreateKvCloudFlagIndex(tableName, db);
+    }
+    std::string addFlagSql = "ALTER TABLE " + tableName + " ADD COLUMN cloud_flag INT DEFAULT 0";
+    errCode = SQLiteUtils::ExecuteRawSQL(db, addFlagSql);
+    if (errCode != E_OK) {
+        LOGE("[LogTableManager] add cloud_flag failed, errCode=%d", errCode);
+        return errCode;
+    }
+    return CreateKvCloudFlagIndex(tableName, db);
+}
+
+int SqliteLogTableManager::CreateKvCloudFlagIndex(const std::string &tableName, sqlite3 *db)
+{
+    std::string createIndexSql = "CREATE INDEX IF NOT EXISTS gid_hash_key_flag ON " + tableName +
+        "(cloud_gid, hash_key, cloud_flag)";
+    int errCode = SQLiteUtils::ExecuteRawSQL(db, createIndexSql);
+    if (errCode != E_OK) {
+        LOGE("[LogTableManager] add cloud_flag index failed, errCode=%d", errCode);
+    }
+    return errCode;
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.h
index 32d8e10e6465926a2f2d94f6c42ff0efcaf9f81e..6de55c1ce334df2def06e240af92f86fc4a14540 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_log_table_manager.h
@@ -45,6 +45,9 @@ private:
     virtual std::vector<std::string> GetDropTriggers(const TableInfo &table) = 0;
 
     virtual std::string GetPrimaryKeySql(const TableInfo &table) = 0;
+
+    static int UpgradeKvSyncLogTable(const std::string &tableName, sqlite3 *db);
+    static int CreateKvCloudFlagIndex(const std::string &tableName, sqlite3 *db);
 };
 }
 #endif // SQLITE_LOG_TABLE_MANAGER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
index 94e348664b13b5bef5d85f7e22ce19e2c00f7694..901d28859f6e832ccf503e739a1144fce91ed59b 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.cpp
@@ -16,7 +16,6 @@
 
 #include <iomanip>
 
-#include "cloud/cloud_storage_utils.h"
 #include "db_common.h"
 #include "db_constant.h"
 #include "db_errno.h"
@@ -24,12 +23,15 @@
 #include "macro_utils.h"
 #include "sqlite_utils.h"
 #include "sqlite_single_ver_storage_executor_sql.h"
+#include "cloud/cloud_storage_utils.h"
+#include "res_finalizer.h"
 
 namespace DistributedDB {
 using namespace TriggerMode;
 namespace {
 const std::string PRE_QUERY_KV_SQL = "SELECT key, value FROM sync_data ";
 const std::string PRE_QUERY_ITEM_SQL = "SELECT * FROM ";
+const std::string PRE_QUERY_COUNT_ITEM_SQL = "SELECT count(*) FROM ";
 const std::string PRE_QUERY_ROWID_SQL = "SELECT rowid FROM sync_data ";
 const std::string PRE_GET_COUNT_SQL = "SELECT count(*) FROM sync_data ";
 const std::string FILTER_NATIVE_DATA_SQL = "WHERE (flag&0x01=0) ";
@@ -513,7 +515,7 @@ int SqliteQueryHelper::GetCountSqlStatement(sqlite3 *dbHandle, sqlite3_stmt *&co
     return errCode;
 }
 
-int SqliteQueryHelper::GetSyncDataQuerySql(std::string &sql, bool hasSubQuery)
+int SqliteQueryHelper::GetSyncDataQuerySql(std::string &sql, bool hasSubQuery, bool isCount)
 {
     if (!isValid_) {
         return -E_INVALID_QUERY_FORMAT;
@@ -525,7 +527,8 @@ int SqliteQueryHelper::GetSyncDataQuerySql(std::string &sql, bool hasSubQuery)
         isNeedOrderbyKey_ = false; // Need order by timestamp.
     }
 
-    sql = AssembleSqlForSuggestIndex(PRE_QUERY_ITEM_SQL + tableName_ + " ", FILTER_REMOTE_QUERY);
+    sql = AssembleSqlForSuggestIndex(((isCount == true && hasSubQuery == false) ?
+        PRE_QUERY_COUNT_ITEM_SQL : PRE_QUERY_ITEM_SQL) + tableName_ + " ", FILTER_REMOTE_QUERY);
     sql = !hasPrefixKey_ ? sql : (sql + " AND (key>=? AND key<=?) ");
     sql = keys_.empty() ? sql : (sql + " AND " + MapKeysInToSql(keys_.size()));
     sql = hasSubQuery ? sql : (sql + " AND (timestamp>=? AND timestamp<?) ");
@@ -542,7 +545,8 @@ int SqliteQueryHelper::GetSyncDataQuerySql(std::string &sql, bool hasSubQuery)
         // The last timestamp in one query will be stored in continue token and used for next query.
         // Therefore all query data must be ordered by timestamp.
         // When there is limit in SQL, data should be ordered by key in sub query, and timestamp is ordered by outside.
-        sql = "SELECT * FROM ( " + sql + " ) WHERE (timestamp >= ? AND timestamp < ?) ORDER BY timestamp;";
+        std::string sqlHead = isCount ? PRE_QUERY_COUNT_ITEM_SQL : PRE_QUERY_ITEM_SQL;
+        sql = sqlHead + "( " + sql + " ) WHERE (timestamp >= ? AND timestamp < ?) ORDER BY timestamp;";
     }
     return errCode;
 }
@@ -577,7 +581,7 @@ int SqliteQueryHelper::BindObjNodes(sqlite3_stmt *&statement, int &index) const
 }
 
 int SqliteQueryHelper::GetQuerySyncStatement(sqlite3 *dbHandle, uint64_t beginTime, uint64_t endTime,
-    sqlite3_stmt *&statement)
+    sqlite3_stmt *&statement, bool isCount)
 {
     bool hasSubQuery = false;
     if (hasLimit_) {
@@ -586,7 +590,7 @@ int SqliteQueryHelper::GetQuerySyncStatement(sqlite3 *dbHandle, uint64_t beginTi
         isNeedOrderbyKey_ = false; // Need order by timestamp.
     }
     std::string sql;
-    int errCode = GetSyncDataQuerySql(sql, hasSubQuery);
+    int errCode = GetSyncDataQuerySql(sql, hasSubQuery, isCount);
     if (errCode != E_OK) {
         LOGE("[Query] Get SQL fail!");
         return -E_INVALID_QUERY_FORMAT;
@@ -1180,12 +1184,16 @@ void SqliteQueryHelper::AppendCloudQuery(bool isCloudForcePush, bool isCompensat
     sql += " WHERE ";
     if (isCompensatedTask && mode == CloudWaterType::DELETE) {
         // deleted data does not have primary key, requires gid to compensate sync
-        sql += "(b.status = 1 AND (b.flag & 0x01 = 0x01)) OR ";
+        sql += "(b.status = 1 AND (b.flag & 0x01 = 0x01) AND b.cloud_gid != '') OR ";
     } else if (queryObjNodes_.empty() && mode != CloudWaterType::INSERT) { // means unPriorityTask and not insert
         sql += "(b.status != 1) AND ";
     }
-    sql += isCloudForcePush ? " b.timestamp > ? AND (b.flag & 0x04 != 0x04)" :
-        " b.timestamp > ? AND (b.flag & 0x02 = 0x02)";
+    if (isCloudForcePush) {
+        sql += " (b.flag & 0x04 != 0x04)";
+    } else {
+        // local data and flag is not upload finished.
+        sql += "(b.flag & 0x02 = 0x02) AND (b.flag & 0x400 != 0x400)";
+    }
     sql += " AND (b.flag & 0x08 != 0x08) AND (b.cloud_gid != '' or"; // actually, b.cloud_gid will not be null.
     sql += " (b.cloud_gid == '' and (b.flag & 0x01 = 0))) ";
 }
@@ -1218,9 +1226,8 @@ void SqliteQueryHelper::AppendCloudGidQuery(bool isCloudForcePush, bool isCompen
         // deleted data does not have primary key, requires gid to compensate sync
         sql += " (b.status = 1 AND (b.flag & 0x01 = 0x01)) OR ";
     }
-    sql += isCloudForcePush ? " b.timestamp > ? AND (b.flag & 0x04 != 0x04)" :
-        " b.timestamp > ?";
-    sql += " AND (b.cloud_gid != '') "; // actually, b.cloud_gid will not be null.
+    // actually, b.cloud_gid will not be null.
+    sql += isCloudForcePush ? " (b.flag & 0x04 != 0x04) AND (b.cloud_gid != '') " : " (b.cloud_gid != '') ";
 }
 
 int SqliteQueryHelper::GetCloudQueryStatement(bool useTimestampAlias, sqlite3 *dbHandle, uint64_t beginTime,
@@ -1238,16 +1245,7 @@ int SqliteQueryHelper::GetCloudQueryStatement(bool useTimestampAlias, sqlite3 *d
         LOGE("[Query] Get statement fail!");
         return -E_INVALID_QUERY_FORMAT;
     }
-    errCode = SQLiteUtils::BindInt64ToStatement(statement, 1, static_cast<int64_t>(beginTime));
-    if (errCode != E_OK) {
-        int resetRet = E_OK;
-        SQLiteUtils::ResetStatement(statement, true, resetRet);
-        if (resetRet != E_OK) {
-            LOGW("[Query] reset statement failed %d", resetRet);
-        }
-        return errCode;
-    }
-    int index = 2;
+    int index = 1;
     errCode = BindObjNodes(statement, index);
     if (errCode != E_OK) {
         LOGE("[Query] BindObjNodes failed %d", errCode);
@@ -1261,15 +1259,39 @@ int SqliteQueryHelper::GetCloudQueryStatement(bool useTimestampAlias, sqlite3 *d
 }
 
 std::pair<int, sqlite3_stmt *> SqliteQueryHelper::GetKvCloudQueryStmt(sqlite3 *db, bool forcePush,
-    const CloudWaterType mode)
+    const CloudWaterType mode, int64_t timeStamp, const std::string &user)
 {
     std::pair<int, sqlite3_stmt *> res;
     sqlite3_stmt *&stmt = res.second;
     int &errCode = res.first;
     std::string sql = GetKvCloudQuerySql(false, forcePush);
     AppendCloudQueryToGetDiffData(sql, mode, true);
+    AppendKvQueryObjectOnSql(sql);
     sql += "order by modify_time asc";
     errCode = SQLiteUtils::GetStatement(db, sql, stmt);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Get kv cloud query stmt failed %d", errCode);
+        return res;
+    }
+    int ret = E_OK;
+    errCode = SQLiteUtils::BindTextToStatement(stmt, BIND_CLOUD_USER, user);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, ret);
+        LOGE("[SqliteQueryHelper] Bind user failed %d reset %d", errCode, ret);
+        return res;
+    }
+    errCode = SQLiteUtils::BindInt64ToStatement(stmt, BIND_CLOUD_TIMESTAMP, timeStamp);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, ret);
+        LOGE("[SqliteQueryHelper] Bind begin time failed %d reset %d", errCode, ret);
+        return res;
+    }
+    int index = BIND_CLOUD_TIMESTAMP + 1;
+    errCode = BindKeysToStmt(keys_, stmt, index);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, ret);
+        LOGE("[SqliteQueryHelper] Bind user failed %d reset %d", errCode, ret);
+    }
     return res;
 }
 
@@ -1286,6 +1308,9 @@ std::string SqliteQueryHelper::GetKvCloudQuerySql(bool countOnly, bool forcePush
     sql += " AND flag & 0x02 != 0 "; // get all data which is local
     if (forcePush) {
         sql += " AND flag & 0x04 != 0x04 "; // get all data which hasn't pushed
+    } else {
+        sql += " AND (cloud_flag is null OR cloud_flag & " +
+            std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_UPLOAD_FINISHED)) + " = 0) ";
     }
     return sql;
 }
@@ -1308,4 +1333,89 @@ std::string SqliteQueryHelper::GetCloudVersionRecordSql(bool isDeviceEmpty)
     }
     return sql;
 }
+
+int SqliteQueryHelper::GetAndBindGidKvCloudQueryStatement(const std::string &user, sqlite3 *dbHandle,
+    sqlite3_stmt *&stmt)
+{
+    std::string sql = SELECT_CLOUD_GID_SQL;
+    AppendKvQueryObjectOnSql(sql);
+    int errCode = SQLiteUtils::GetStatement(dbHandle, sql, stmt);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Get gid stmt failed %d", errCode);
+        return errCode;
+    }
+    int index = 1;
+    int ret = E_OK;
+    errCode = SQLiteUtils::BindTextToStatement(stmt, index++, user);
+    if (errCode != E_OK) {
+        SQLiteUtils::ResetStatement(stmt, true, ret);
+        LOGE("[SqliteQueryHelper] Bind user failed %d when query gid", errCode);
+        return errCode;
+    }
+    errCode = BindKeysToStmt(keys_, stmt, index);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Bind keys to query gid stmt failed %d", errCode);
+        SQLiteUtils::ResetStatement(stmt, true, ret);
+    }
+    return errCode;
+}
+
+int SqliteQueryHelper::GetCountKvCloudDataStatement(sqlite3 *db, bool forcePush, const CloudWaterType mode,
+    sqlite3_stmt *&stmt)
+{
+    std::string sql = SqliteQueryHelper::GetKvCloudQuerySql(true, forcePush);
+    SqliteQueryHelper::AppendCloudQueryToGetDiffData(sql, mode, true);
+    AppendKvQueryObjectOnSql(sql);
+    int errCode = SQLiteUtils::GetStatement(db, sql, stmt);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Count data stmt failed %d", errCode);
+    }
+    return errCode;
+}
+
+std::pair<int, int64_t> SqliteQueryHelper::BindCountKvCloudDataStatement(sqlite3 *db, bool isMemory,
+    const Timestamp &timestamp, const std::string &user, sqlite3_stmt *&stmt)
+{
+    ResFinalizer finalizer([stmt]() {
+        sqlite3_stmt *statement = stmt;
+        int ret = E_OK;
+        SQLiteUtils::ResetStatement(statement, true, ret);
+        if (ret != E_OK) {
+            LOGW("[SqliteCloudKvExecutorUtils] Reset log stmt failed %d when get upload count", ret);
+        }
+    });
+    std::pair<int, int64_t> res = { E_OK, 0 };
+    auto &[errCode, count] = res;
+    errCode = SQLiteUtils::BindTextToStatement(stmt, BIND_CLOUD_USER, user);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Bind user failed %d when get upload count", errCode);
+        return res;
+    }
+    errCode = SQLiteUtils::BindInt64ToStatement(stmt, BIND_CLOUD_TIMESTAMP, static_cast<int64_t>(timestamp));
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Bind begin time failed %d when get upload count", errCode);
+        return res;
+    }
+    int keysIndex = BIND_CLOUD_TIMESTAMP + 1;
+    errCode = BindKeysToStmt(keys_, stmt, keysIndex);
+    if (errCode != E_OK) {
+        LOGE("[SqliteQueryHelper] Bind keys failed %d when get upload count", errCode);
+        return res;
+    }
+    errCode = SQLiteUtils::StepNext(stmt, isMemory);
+    if (errCode == -E_FINISHED) {
+        count = 0;
+        return res;
+    }
+    count = sqlite3_column_int64(stmt, CLOUD_QUERY_COUNT_INDEX);
+    LOGD("[SqliteCloudKvExecutorUtils] Get total upload count %" PRId64, count);
+    return res;
+}
+
+void SqliteQueryHelper::AppendKvQueryObjectOnSql(std::string &sql)
+{
+    if (!keys_.empty()) {
+        sql += " AND " + MapKeysInToSql(keys_.size());
+    }
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.h
index 596ce743f47f81e26f33fc43d4ca1b954f8388ca..f4100cc917ee5424f8c490270620e59d005ffe8f 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_query_helper.h
@@ -76,7 +76,8 @@ public:
     int GetCountSqlStatement(sqlite3 *dbHandle, sqlite3_stmt *&countStmt);
 
     // For query Sync
-    int GetQuerySyncStatement(sqlite3 *dbHandle, uint64_t beginTime, uint64_t endTime, sqlite3_stmt *&statement);
+    int GetQuerySyncStatement(sqlite3 *dbHandle, uint64_t beginTime, uint64_t endTime, sqlite3_stmt *&statement,
+        bool isCount = false);
     int GetSyncDataCheckSql(std::string &sql);
     int BindSyncDataCheckStmt(sqlite3_stmt *statement, const Key &hashKey) const;
 
@@ -112,7 +113,17 @@ public:
     int GetCloudQueryStatement(bool useTimestampAlias, sqlite3 *dbHandle, uint64_t beginTime, std::string &sql,
         sqlite3_stmt *&statement);
 
-    static std::pair<int, sqlite3_stmt *> GetKvCloudQueryStmt(sqlite3 *db, bool forcePush, const CloudWaterType mode);
+    int GetAndBindGidKvCloudQueryStatement(const std::string &user, sqlite3 *dbHandle, sqlite3_stmt *&stmt);
+
+    int GetCountKvCloudDataStatement(sqlite3 *db, bool forcePush, const CloudWaterType mode, sqlite3_stmt *&stmt);
+
+    std::pair<int, int64_t> BindCountKvCloudDataStatement(sqlite3 *db, bool isMemory, const Timestamp &timestamp,
+        const std::string &user, sqlite3_stmt *&stmt);
+
+    void AppendKvQueryObjectOnSql(std::string &sql);
+
+    std::pair<int, sqlite3_stmt *> GetKvCloudQueryStmt(sqlite3 *db, bool forcePush, const CloudWaterType mode,
+        int64_t timeStamp, const std::string &user);
 
     static std::string GetKvCloudQuerySql(bool countOnly, bool forcePush);
 
@@ -137,7 +148,7 @@ private:
     bool FilterSymbolToAddBracketLink(std::string &querySql, bool isNeedLink = true) const;
     std::string AssembleSqlForSuggestIndex(const std::string &baseSql, const std::string &filter) const;
     std::string CheckAndFormatSuggestIndex() const;
-    int GetSyncDataQuerySql(std::string &sql, bool hasSubQuery);
+    int GetSyncDataQuerySql(std::string &sql, bool hasSubQuery, bool isCount);
     int ParseQueryObjNodeToSQL(bool isQueryForSync);
     int BindTimeRange(sqlite3_stmt *&statement, int &index, uint64_t beginTime, uint64_t endTime) const;
     int BindObjNodes(sqlite3_stmt *&statement, int &index) const;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_continue_token.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_continue_token.cpp
index 61b166a5209c99c7d2b1a89f5a90c0e1ae24ea6c..f2dc1ce98d6a80fa76bbbcc53d90be7f7a45e129 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_continue_token.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_continue_token.cpp
@@ -150,23 +150,12 @@ std::pair<int, sqlite3_stmt *> SQLiteSingleVerContinueToken::GetCloudQueryStmt(s
     std::pair<int, sqlite3_stmt *> res;
     int &errCode = res.first;
     sqlite3_stmt *&stmt = res.second;
-    std::tie(errCode, stmt) = SqliteQueryHelper::GetKvCloudQueryStmt(db, forcePush, mode);
+    SqliteQueryHelper helper = GetQuery().GetQueryHelper(errCode);
     if (errCode != E_OK) {
-        LOGE("[SQLiteSingleVerContinueToken] Get kv cloud query stmt failed %d", errCode);
         return res;
     }
-    errCode = SQLiteUtils::BindInt64ToStatement(stmt, BIND_CLOUD_TIMESTAMP, timeRanges_[""].first);
+    std::tie(errCode, stmt) = helper.GetKvCloudQueryStmt(db, forcePush, mode, timeRanges_[""].first, user_);
     if (errCode != E_OK) {
-        int ret = E_OK;
-        SQLiteUtils::ResetStatement(stmt, true, ret);
-        LOGE("[SQLiteSingleVerContinueToken] Bind begin time failed %d reset %d", errCode, ret);
-        return res;
-    }
-    errCode = SQLiteUtils::BindTextToStatement(stmt, BIND_CLOUD_USER, user_);
-    if (errCode != E_OK) {
-        int ret = E_OK;
-        SQLiteUtils::ResetStatement(stmt, true, ret);
-        LOGE("[SQLiteSingleVerContinueToken] Bind user failed %d reset %d", errCode, ret);
         return res;
     }
     queryDataStmt_ = stmt;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_database_upgrader.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_database_upgrader.cpp
index 3897c8b27c505e24a4b9d12e8689dab26fa11309..2e5f65dde364cc3b40cd0376da8176db95a2ef3b 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_database_upgrader.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_database_upgrader.cpp
@@ -288,17 +288,12 @@ int SQLiteSingleVerDatabaseUpgrader::SetPathSecOptWithCheck(const std::string &p
         if (!OS::CheckPathExistence(dbItemFilePath)) {
             continue;
         }
-        if (OS::CheckPathExistence(dbItemFilePath) && dbOpt.securityLabel == NOT_SET) {
+        if (OS::CheckPathExistence(dbItemFilePath) && dbOpt != secOption) {
             int errCode = RuntimeContext::GetInstance()->SetSecurityOption(dbItemFilePath, secOption);
             if (errCode != E_OK) {
                 LOGE("[SetPathSecOptWithCheck] SetSecurityOption failed.");
                 return errCode;
             }
-        } else if (dbOpt == secOption) {
-            LOGI("[SetPathSecOptWithCheck] already set secoption");
-        } else {
-            LOGE("[SetPathSecOptWithCheck] already set secoption,but different from early option.");
-            return -E_INVALID_ARGS;
         }
     }
     return E_OK;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
index 7fd9b73eb24e8021c32f2b60785f7ee8230e5794..45af660e5f82d029bef4bde271fc0e41669114c0 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.cpp
@@ -188,12 +188,12 @@ int SQLiteSingleVerNaturalStore::SetUserVer(const KvDBProperties &kvDBProp, int
     OpenDbProperties properties;
     properties.uri = GetDatabasePath(kvDBProp);
     bool isEncryptedDb = kvDBProp.GetBoolProp(KvDBProperties::ENCRYPTED_MODE, false);
-    if (isEncryptedDb) {
+    if (isEncryptedDb) { // LCOV_EXCL_BR_LINE
         kvDBProp.GetPassword(properties.cipherType, properties.passwd);
     }
 
     int errCode = SQLiteUtils::SetUserVer(properties, version);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Recover for open db failed in single version:%d", errCode);
     }
     return errCode;
@@ -225,7 +225,7 @@ int SQLiteSingleVerNaturalStore::RegisterLifeCycleCallback(const DatabaseLifeCyc
 
     if (lifeTimerId_ != 0) {
         errCode = StopLifeCycleTimer();
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Stop the life cycle timer failed:%d", errCode);
         }
     }
@@ -259,12 +259,12 @@ int SQLiteSingleVerNaturalStore::SetAutoLifeCycleTime(uint32_t time)
 int SQLiteSingleVerNaturalStore::GetSecurityOption(SecurityOption &option) const
 {
     bool isMemDb = GetDbProperties().GetBoolProp(KvDBProperties::MEMORY_MODE, false);
-    if (isMemDb) {
+    if (isMemDb) { // LCOV_EXCL_BR_LINE
         LOGI("[GetSecurityOption] MemDb, no need to get security option");
         option = SecurityOption();
         return -E_NOT_SUPPORT;
     }
-    if (!RuntimeContext::GetInstance()->IsProcessSystemApiAdapterValid()) {
+    if (!RuntimeContext::GetInstance()->IsProcessSystemApiAdapterValid()) { // LCOV_EXCL_BR_LINE
         LOGI("[GetSecurityOption] Not set api adapter");
         return -E_NOT_SUPPORT;
     }
@@ -305,7 +305,7 @@ int SQLiteSingleVerNaturalStore::CheckValueAndAmendIfNeed(ValueSource sourceType
         // Not a schema database, do not need to check more
         return E_OK;
     }
-    if (schemaObjRef.GetSchemaType() == SchemaType::JSON) {
+    if (schemaObjRef.GetSchemaType() == SchemaType::JSON) { // LCOV_EXCL_BR_LINE
         ValueObject valueObj;
         int errCode = valueObj.Parse(oriValue.data(), oriValue.data() + oriValue.size(), schemaObjRef.GetSkipSize());
         if (errCode != E_OK) {
@@ -332,7 +332,7 @@ int SQLiteSingleVerNaturalStore::CheckValueAndAmendIfNeed(ValueSource sourceType
         }
     } else {
         int errCode = schemaObjRef.VerifyValue(sourceType, oriValue);
-        if (errCode == E_OK) {
+        if (errCode == E_OK) { // LCOV_EXCL_BR_LINE
             useAmendValue = false;
             return E_OK;
         }
@@ -370,7 +370,7 @@ int SQLiteSingleVerNaturalStore::CheckDatabaseRecovery(const KvDBProperties &kvD
     const std::string identifierDir = kvDBProp.GetStringProp(KvDBProperties::IDENTIFIER_DIR, "");
     bool isCreate = kvDBProp.GetBoolProp(KvDBProperties::CREATE_IF_NECESSARY, true);
     bool isMemoryDb = kvDBProp.GetBoolProp(KvDBProperties::MEMORY_MODE, false);
-    if (!isMemoryDb) {
+    if (!isMemoryDb) { // LCOV_EXCL_BR_LINE
         errCode = DBCommon::CreateStoreDirectory(dataDir, identifierDir, DBConstant::SINGLE_SUB_DIR, isCreate);
         if (errCode != E_OK) {
             LOGE("Create single version natural store directory failed:%d", errCode);
@@ -391,7 +391,7 @@ int SQLiteSingleVerNaturalStore::GetAndInitStorageEngine(const KvDBProperties &k
         }
     }
 
-    if (storageEngine_->IsEngineCorrupted()) {
+    if (storageEngine_->IsEngineCorrupted()) { // LCOV_EXCL_BR_LINE
         LOGE("[SqlSinStore][GetAndInitStorageEngine] database engine is corrupted or invalid key, stop open!");
         return -E_INVALID_PASSWD_OR_CORRUPTED_DB;
     }
@@ -406,7 +406,7 @@ int SQLiteSingleVerNaturalStore::GetAndInitStorageEngine(const KvDBProperties &k
 int SQLiteSingleVerNaturalStore::Open(const KvDBProperties &kvDBProp)
 {
     std::lock_guard<std::mutex> lock(initialMutex_);
-    if (isInitialized_) {
+    if (isInitialized_) { // LCOV_EXCL_BR_LINE
         return E_OK; // avoid the reopen operation.
     }
 
@@ -845,6 +845,60 @@ int SQLiteSingleVerNaturalStore::GetSyncDataNext(std::vector<DataItem> &dataItem
     return errCode;
 }
 
+int SQLiteSingleVerNaturalStore::GetUnSyncTotal(Timestamp begin, Timestamp end, uint32_t &total) const
+{
+    if (begin >= end) {
+        return -E_INVALID_ARGS;
+    }
+
+    int errCode = E_OK;
+    SQLiteSingleVerStorageExecutor *handle = GetHandle(false, errCode);
+    if (handle == nullptr) {
+        return errCode;
+    }
+
+    errCode = handle->GetUnSyncTotalByTimestamp(begin, end, total);
+    ReleaseHandle(handle);
+    return errCode;
+}
+
+int SQLiteSingleVerNaturalStore::GetUnSyncTotal(QueryObject &query, const SyncTimeRange &timeRange,
+    uint32_t &total) const
+{
+    if (!timeRange.IsValid()) {
+        return -E_INVALID_ARGS;
+    }
+    int errCode = CheckReadDataControlled();
+    if (errCode != E_OK) {
+        LOGE("[GetEntries] Existed cache prevents the reading from query sync total[%d]!", errCode);
+        return errCode;
+    }
+
+    query.SetSchema(GetSchemaObject());
+    SQLiteSingleVerStorageExecutor *handle = GetHandle(false, errCode);
+    if (handle == nullptr) {
+        return -E_ALREADY_REGISTER;
+    }
+
+    uint32_t delTotal = 0u;
+    errCode = handle->GetSyncTotalWithQuery(query, std::make_pair(timeRange.beginTime, timeRange.endTime), total);
+    if (errCode != E_OK) {
+        LOGE("[SQLiteSingleVerNaturalStore][GetUnSyncTotal] Get query count failed.");
+        ReleaseHandle(handle);
+        return errCode;
+    }
+
+    errCode = handle->GetDeletedSyncTotalByTimestamp(timeRange.deleteBeginTime, timeRange.deleteEndTime, delTotal);
+    ReleaseHandle(handle);
+    if (errCode != E_OK) {
+        LOGE("[SQLiteSingleVerNaturalStore][GetUnSyncTotal] Get del count failed.");
+        return errCode;
+    }
+
+    total += delTotal;
+    return errCode;
+}
+
 void SQLiteSingleVerNaturalStore::ReleaseContinueToken(ContinueToken &continueStmtToken) const
 {
     auto token = static_cast<SQLiteSingleVerContinueToken *>(continueStmtToken);
@@ -953,7 +1007,7 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceData(const std::string &deviceName,
             hash = true;
         }
     } while (false);
-    if (!hash) {
+    if (!hash) { // LCOV_EXCL_BR_LINE
         hashDeviceId = DBCommon::TransferHashString(deviceName);
     }
 
@@ -963,22 +1017,16 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceData(const std::string &deviceName,
 // In sync procedure, call this function
 int SQLiteSingleVerNaturalStore::RemoveDeviceData(const std::string &deviceName, ClearMode mode)
 {
-    int errCode = RemoveDeviceDataInner(DBCommon::TransferHashString(deviceName), mode);
-    if (errCode == E_OK) {
-        CleanAllWaterMark();
-    }
-    return errCode;
+    CleanAllWaterMark();
+    return RemoveDeviceDataInner(DBCommon::TransferHashString(deviceName), mode);
 }
 
 // In sync procedure, call this function
 int SQLiteSingleVerNaturalStore::RemoveDeviceData(const std::string &deviceName, const std::string &user,
     ClearMode mode)
 {
-    int errCode = RemoveDeviceDataInner(DBCommon::TransferHashString(deviceName), user, mode);
-    if (errCode == E_OK) {
-        CleanAllWaterMark();
-    }
-    return errCode;
+    CleanAllWaterMark();
+    return RemoveDeviceDataInner(DBCommon::TransferHashString(deviceName), user, mode);
 }
 
 int SQLiteSingleVerNaturalStore::RemoveDeviceDataInCacheMode(const std::string &hashDev, bool isNeedNotify) const
@@ -1075,7 +1123,7 @@ SQLiteSingleVerStorageExecutor *SQLiteSingleVerNaturalStore::GetHandle(bool isWr
         return nullptr;
     }
     // Use for check database corrupted in Asynchronous task, like cache data migrate to main database
-    if (storageEngine_->IsEngineCorrupted()) {
+    if (storageEngine_->IsEngineCorrupted()) { // LCOV_EXCL_BR_LINE
         CorruptNotify();
         errCode = -E_INVALID_PASSWD_OR_CORRUPTED_DB;
         engineMutex_.unlock_shared(); // unlock when get handle failed.
@@ -1207,7 +1255,7 @@ int SQLiteSingleVerNaturalStore::SaveSyncDataItems(const QueryObject &query, std
             item.createTime = static_cast<Timestamp>(static_cast<int64_t>(item.writeTimestamp) - offset);
         }
     }
-    if (checkValueContent) {
+    if (checkValueContent) { // LCOV_EXCL_BR_LINE
         CheckAmendValueContentForSyncProcedure(dataItems);
     }
     QueryObject queryInner = query;
@@ -1263,7 +1311,6 @@ int SQLiteSingleVerNaturalStore::SaveSyncItems(const QueryObject &query, std::ve
         DBDfxAdapter::FinishTracing();
         return errCode;
     }
-    bool isPermitForceWrite = !(GetDbProperties().GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE, false));
     errCode = handle->CheckDataWithQuery(query, dataItems, deviceInfo);
     if (errCode != E_OK) {
         goto END;
@@ -1276,7 +1323,7 @@ int SQLiteSingleVerNaturalStore::SaveSyncItems(const QueryObject &query, std::ve
         if (item.neglect) { // Do not save this record if it is neglected
             continue;
         }
-        errCode = handle->SaveSyncDataItem(item, deviceInfo, maxTimestamp, commitData, isPermitForceWrite);
+        errCode = handle->SaveSyncDataItem(item, deviceInfo, maxTimestamp, commitData, true);
         if (errCode != E_OK && errCode != -E_NOT_FOUND) {
             break;
         }
@@ -1360,6 +1407,9 @@ int SQLiteSingleVerNaturalStore::InitStorageEngine(const KvDBProperties &kvDBPro
     }
 
     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
+    if (sqliteCloudKvStore_ != nullptr) {
+        return E_OK;
+    }
     sqliteCloudKvStore_ = new(std::nothrow) SqliteCloudKvStore(this);
     if (sqliteCloudKvStore_ == nullptr) {
         return E_OUT_OF_MEMORY;
@@ -1421,7 +1471,7 @@ int SQLiteSingleVerNaturalStore::Export(const std::string &filePath, const Ciphe
     if (storageEngine_ == nullptr) {
         return -E_INVALID_DB;
     }
-    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) {
+    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) { // LCOV_EXCL_BR_LINE
         return -E_NOT_SUPPORT;
     }
 
@@ -1465,7 +1515,7 @@ int SQLiteSingleVerNaturalStore::Import(const std::string &filePath, const Ciphe
     if (storageEngine_ == nullptr) {
         return -E_INVALID_DB;
     }
-    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) {
+    if (MyProp().GetBoolProp(KvDBProperties::MEMORY_MODE, false)) { // LCOV_EXCL_BR_LINE
         return -E_NOT_SUPPORT;
     }
 
@@ -1483,7 +1533,7 @@ int SQLiteSingleVerNaturalStore::Import(const std::string &filePath, const Ciphe
     if (errCode != E_OK) {
         return errCode;
     }
-    StopSyncer(true);
+    StopSyncer(true, true);
     std::this_thread::sleep_for(std::chrono::milliseconds(5)); // wait for 5 ms
     std::unique_ptr<SingleVerDatabaseOper> operation;
 
@@ -1552,20 +1602,20 @@ bool SQLiteSingleVerNaturalStore::CheckCompatible(const std::string &schema, uin
     // Here both are schema-db, check their compatibility mutually
     SchemaObject remoteSchema;
     int errCode = remoteSchema.ParseFromSchemaString(schema);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         // Consider: if the parse errCode is SchemaVersionNotSupport, we can consider allow sync if schemaType equal.
         LOGE("Parse remote schema fail, errCode=%d.", errCode);
         return false;
     }
     // First, Compare remoteSchema based on localSchema
     errCode = localSchema.CompareAgainstSchemaObject(remoteSchema);
-    if (errCode != -E_SCHEMA_UNEQUAL_INCOMPATIBLE) {
+    if (errCode != -E_SCHEMA_UNEQUAL_INCOMPATIBLE) { // LCOV_EXCL_BR_LINE
         LOGI("Remote(Maybe newer) compatible based on local, result=%d.", errCode);
         return true;
     }
     // Second, Compare localSchema based on remoteSchema
     errCode = remoteSchema.CompareAgainstSchemaObject(localSchema);
-    if (errCode != -E_SCHEMA_UNEQUAL_INCOMPATIBLE) {
+    if (errCode != -E_SCHEMA_UNEQUAL_INCOMPATIBLE) { // LCOV_EXCL_BR_LINE
         LOGI("Local(Newer) compatible based on remote, result=%d.", errCode);
         return true;
     }
@@ -1772,17 +1822,17 @@ int SQLiteSingleVerNaturalStore::SaveSyncItemsInCacheMode(SQLiteSingleVerStorage
 
     for (auto &item : dataItems) {
         errCode = handle->SaveSyncDataItemInCacheMode(item, deviceInfo, maxTimestamp, recordVersion, query);
-        if (errCode != E_OK && errCode != -E_NOT_FOUND) {
+        if (errCode != E_OK && errCode != -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
             break;
         }
     }
 
-    if (errCode == -E_NOT_FOUND) {
+    if (errCode == -E_NOT_FOUND) { // LCOV_EXCL_BR_LINE
         errCode = E_OK;
     }
 
     innerCode = handle->ResetForSavingCacheData(SingleVerDataType::SYNC_TYPE);
-    if (innerCode != E_OK) {
+    if (innerCode != E_OK) { // LCOV_EXCL_BR_LINE
         errCode = innerCode;
     }
 END:
@@ -1958,5 +2008,15 @@ std::map<std::string, DataBaseSchema> SQLiteSingleVerNaturalStore::GetDataBaseSc
     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
     return sqliteCloudKvStore_->GetDataBaseSchemas();
 }
+
+bool SQLiteSingleVerNaturalStore::CheckSchemaSupportForCloudSync() const
+{
+    auto schemaType = GetSchemaObject().GetSchemaType();
+    if (schemaType != SchemaType::NONE) {
+        LOGE("un support schema type %d for cloud sync", static_cast<int>(schemaType));
+        return false;
+    }
+    return true;
+}
 DEFINE_OBJECT_TAG_FACILITIES(SQLiteSingleVerNaturalStore)
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
index 6cd0ba57203deb5dd1936465821f2d4319bc2efc..bfe2f5c40adc39b3caecc8f17621561083de163b 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store.h
@@ -88,6 +88,10 @@ public:
 
     int GetSyncDataNext(std::vector<SingleVerKvEntry *> &entries, ContinueToken &continueStmtToken,
         const DataSizeSpecInfo &dataSizeInfo) const override;
+    
+    int GetUnSyncTotal(Timestamp begin, Timestamp end, uint32_t &total) const override;
+
+    int GetUnSyncTotal(QueryObject &query, const SyncTimeRange &timeRange, uint32_t &total) const override;
 
     void ReleaseContinueToken(ContinueToken &continueStmtToken) const override;
 
@@ -219,6 +223,12 @@ public:
     void SetReceiveDataInterceptor(const DataInterceptor &interceptor) override;
 
     int SetCloudSyncConfig(const CloudSyncConfig &config);
+
+    // for test mock
+    const SqliteCloudKvStore* GetCloudKvStore()
+    {
+        return sqliteCloudKvStore_;
+    }
 protected:
     void AsyncDataMigration(SQLiteSingleVerStorageEngine *storageEngine) const;
 
@@ -227,6 +237,8 @@ protected:
     ICloudSyncStorageInterface *GetICloudSyncInterface() const override;
 
     std::map<std::string, DataBaseSchema> GetDataBaseSchemas() override;
+
+    bool CheckSchemaSupportForCloudSync() const override;
 private:
 
     int CheckDatabaseRecovery(const KvDBProperties &kvDBProp);
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
index 5dd23d9ebacff44a654c2247fbd43fc1819875b8..6bb4cbc2b018222eeeab31ebbd357a61046a62e7 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_connection.cpp
@@ -1846,8 +1846,24 @@ int SQLiteSingleVerNaturalStoreConnection::SetCloudDbSchema(const std::map<std::
         LOGE("[Connection]::[UpdateKey] Get executor failed, errCode = [%d]", errCode);
         return errCode;
     }
+    errCode = handle->StartTransaction(TransactType::IMMEDIATE);
+    if (errCode != E_OK) {
+        ReleaseExecutor(handle);
+        return errCode;
+    }
     errCode = handle->CreateCloudLogTable();
+    if (errCode != E_OK) {
+        (void)handle->Rollback();
+        ReleaseExecutor(handle);
+        LOGE("[SingleVerConnection] create cloud log table failed, errCode = [%d]", errCode);
+        return errCode;
+    }
+    errCode = handle->Commit();
     ReleaseExecutor(handle);
+    if (errCode != E_OK) {
+        LOGE("[SingleVerConnection] commit create cloud log table failed, errCode = [%d]", errCode);
+        return errCode;
+    }
 
     auto naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
     if (naturalStore == nullptr) {
@@ -1880,32 +1896,32 @@ int SQLiteSingleVerNaturalStoreConnection::UnRegisterObserverAction(const KvStor
 
 int SQLiteSingleVerNaturalStoreConnection::RemoveDeviceData(const std::string &device, ClearMode mode)
 {
-    SQLiteSingleVerNaturalStore *naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
-    if (naturalStore == nullptr) {
-        return -E_INVALID_DB;
-    }
     if (device.length() > DBConstant::MAX_DEV_LENGTH) {
         return -E_INVALID_ARGS;
     }
     if (mode == ClearMode::CLEAR_SHARED_TABLE) {
         return -E_NOT_SUPPORT;
     }
+    SQLiteSingleVerNaturalStore *naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
+    if (naturalStore == nullptr) {
+        return -E_INVALID_DB;
+    }
     return naturalStore->RemoveDeviceData(device, mode);
 }
 
 int SQLiteSingleVerNaturalStoreConnection::RemoveDeviceData(const std::string &device, const std::string &user,
     ClearMode mode)
 {
-    SQLiteSingleVerNaturalStore *naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
-    if (naturalStore == nullptr) {
-        return -E_INVALID_DB;
-    }
     if (device.length() > DBConstant::MAX_DEV_LENGTH) {
         return -E_INVALID_ARGS;
     }
     if (mode == ClearMode::CLEAR_SHARED_TABLE) {
         return -E_NOT_SUPPORT;
     }
+    SQLiteSingleVerNaturalStore *naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
+    if (naturalStore == nullptr) {
+        return -E_INVALID_DB;
+    }
     return naturalStore->RemoveDeviceData(device, user, mode);
 }
 
@@ -1919,6 +1935,34 @@ int SQLiteSingleVerNaturalStoreConnection::GetCloudVersion(const std::string &de
     return naturalStore->GetCloudVersion(device, versionMap);
 }
 
+int SQLiteSingleVerNaturalStoreConnection::SetCloudSyncConfig(const CloudSyncConfig &config)
+{
+    auto naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
+    if (naturalStore == nullptr) {
+        LOGE("[SingleVerConnection] DB is null when set config");
+        return -E_INVALID_DB;
+    }
+    return naturalStore->SetCloudSyncConfig(config);
+}
+
+void SQLiteSingleVerNaturalStoreConnection::RecordTimeIntoDataItem(Timestamp existCreateTime, DataItem &dataItem,
+    SQLiteSingleVerNaturalStore &naturalStore)
+{
+    dataItem.timestamp = naturalStore.GetCurrentTimestamp();
+    if (currentMaxTimestamp_ > dataItem.timestamp) {
+        dataItem.timestamp = currentMaxTimestamp_;
+    }
+
+    auto currentRawTime = TimeHelper::GetSysCurrentTime();
+    if (existCreateTime != 0) {
+        dataItem.writeTimestamp = existCreateTime;
+    } else {
+        dataItem.writeTimestamp = dataItem.timestamp;
+    }
+    dataItem.createTime = currentRawTime;
+    dataItem.modifyTime = currentRawTime;
+}
+
 int SQLiteSingleVerNaturalStoreConnection::GetEntries(const std::string &device, std::vector<Entry> &entries) const
 {
     int errCode = CheckReadDataControlled();
@@ -1951,33 +1995,5 @@ int SQLiteSingleVerNaturalStoreConnection::GetEntries(const std::string &device,
     ReleaseExecutor(handle);
     return errCode;
 }
-
-int SQLiteSingleVerNaturalStoreConnection::SetCloudSyncConfig(const CloudSyncConfig &config)
-{
-    auto naturalStore = GetDB<SQLiteSingleVerNaturalStore>();
-    if (naturalStore == nullptr) {
-        LOGE("[SingleVerConnection] DB is null when set config");
-        return -E_INVALID_DB;
-    }
-    return naturalStore->SetCloudSyncConfig(config);
-}
-
-void SQLiteSingleVerNaturalStoreConnection::RecordTimeIntoDataItem(Timestamp existCreateTime, DataItem &dataItem,
-    SQLiteSingleVerNaturalStore &naturalStore)
-{
-    dataItem.timestamp = naturalStore.GetCurrentTimestamp();
-    if (currentMaxTimestamp_ > dataItem.timestamp) {
-        dataItem.timestamp = currentMaxTimestamp_;
-    }
-
-    auto currentRawTime = TimeHelper::GetSysCurrentTime();
-    if (existCreateTime != 0) {
-        dataItem.writeTimestamp = existCreateTime;
-    } else {
-        dataItem.writeTimestamp = dataItem.timestamp;
-    }
-    dataItem.createTime = currentRawTime;
-    dataItem.modifyTime = currentRawTime;
-}
 DEFINE_OBJECT_TAG_FACILITIES(SQLiteSingleVerNaturalStoreConnection)
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_extend.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_extend.cpp
index 665f02782d50135fef14edcb2c4915ec0288df17..5be85e44ab23f7cf5fd5a9ac510e4c7b0a5d81ce 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_extend.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_natural_store_extend.cpp
@@ -219,7 +219,7 @@ uint64_t SQLiteSingleVerNaturalStore::GetCacheRecordVersion() const
 uint64_t SQLiteSingleVerNaturalStore::GetAndIncreaseCacheRecordVersion() const
 {
     if (storageEngine_ == nullptr) {
-        LOGE("[SingleVerNStore] Get cache version storage engine is invalid.");
+        LOGE("[SingleVerNStore] Get and increase cache version storage engine is invalid.");
         return 0;
     }
     return storageEngine_->GetAndIncreaseCacheRecordVersion();
@@ -494,6 +494,7 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDe
         }
     }
 
+    CleanAllWaterMark();
     if (IsExtendedCacheDBMode()) {
         errCode = RemoveDeviceDataInCacheMode(hashDev, isNeedNotify);
     } else {
@@ -511,10 +512,25 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDe
     int errCode = E_OK;
     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
     if (handle == nullptr) {
-        LOGE("[SingleVerNStore] RemoveDeviceData get handle failed:%d", errCode);
+        LOGE("[SingleVerNStore] RemoveDeviceData with mode get handle failed:%d", errCode);
+        return errCode;
+    }
+    errCode = handle->StartTransaction(TransactType::IMMEDIATE);
+    if (errCode != E_OK) {
+        LOGE("Start transaction failed %d in RemoveDeviceData.", errCode);
+        ReleaseHandle(handle);
         return errCode;
     }
     errCode = handle->RemoveDeviceData(hashDev, mode);
+    if (errCode != E_OK) {
+        LOGE("RemoveDeviceData failed: %d", errCode);
+        (void)handle->Rollback();
+    } else {
+        errCode = handle->Commit();
+        if (errCode != E_OK) {
+            LOGE("Transaction commit failed %d in RemoveDeviceData.", errCode);
+        }
+    }
     ReleaseHandle(handle);
     return errCode;
 }
@@ -525,10 +541,25 @@ int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDe
     int errCode = E_OK;
     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
     if (handle == nullptr) {
-        LOGE("[SingleVerNStore] RemoveDeviceData get handle failed:%d", errCode);
+        LOGE("[SingleVerNStore] RemoveDeviceData with user and mode get handle failed:%d", errCode);
+        return errCode;
+    }
+    errCode = handle->StartTransaction(TransactType::IMMEDIATE);
+    if (errCode != E_OK) {
+        LOGE("Start transaction failed %d in RemoveDeviceData.", errCode);
+        ReleaseHandle(handle);
         return errCode;
     }
     errCode = handle->RemoveDeviceData(hashDev, user, mode);
+    if (errCode != E_OK) {
+        LOGE("RemoveDeviceData failed: %d", errCode);
+        (void)handle->Rollback();
+    } else {
+        errCode = handle->Commit();
+        if (errCode != E_OK) {
+            LOGE("Transaction commit failed %d in RemoveDeviceData.", errCode);
+        }
+    }
     ReleaseHandle(handle);
     return errCode;
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
index a8996fcfff20441a441013269b7709704e6a83a0..f1b65dd5f84e8fddf58ec4d9f27b7ddb52d484a5 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_engine.cpp
@@ -50,12 +50,12 @@ int SQLiteSingleVerStorageEngine::MigrateLocalData(SQLiteSingleVerStorageExecuto
 int SQLiteSingleVerStorageEngine::EraseDeviceWaterMark(const std::set<std::string> &removeDevices, bool isNeedHash)
 {
     auto kvdbManager = KvDBManager::GetInstance();
-    if (kvdbManager == nullptr) {
+    if (kvdbManager == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_DB;
     }
     auto identifier = GetIdentifier();
     auto kvdb = kvdbManager->FindKvDB(identifier);
-    if (kvdb == nullptr) {
+    if (kvdb == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("[SingleVerEngine::EraseWaterMark] kvdb is null.");
         return -E_INVALID_DB;
     }
@@ -63,7 +63,7 @@ int SQLiteSingleVerStorageEngine::EraseDeviceWaterMark(const std::set<std::strin
     auto kvStore = static_cast<SQLiteSingleVerNaturalStore *>(kvdb);
     for (const auto &devId : removeDevices) {
         int errCode = kvStore->EraseDeviceWaterMark(devId, isNeedHash);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             RefObject::DecObjRef(kvdb);
             return errCode;
         }
@@ -76,13 +76,14 @@ int SQLiteSingleVerStorageEngine::EraseDeviceWaterMark(const std::set<std::strin
 int SQLiteSingleVerStorageEngine::GetRemoveDataDevices(SQLiteSingleVerStorageExecutor *handle, const DataItem &item,
     std::set<std::string> &removeDevices, bool &isNeedHash) const
 {
-    if (handle == nullptr) {
+    if (handle == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_DB;
     }
     if (item.value.empty()) { // Device ID has been set to value in cache db
         // Empty means remove all device data, get device id from meta key
+        // LCOV_EXCL_BR_LINE
         int errCode = handle->GetExistsDevicesFromMeta(removeDevices);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Get remove devices list from meta failed. err=%d", errCode);
             return errCode;
         }
@@ -105,27 +106,27 @@ int SQLiteSingleVerStorageEngine::EraseDeviceWaterMark(SQLiteSingleVerStorageExe
             bool isNeedHash = true;
             std::set<std::string> removeDevices;
             errCode = GetRemoveDataDevices(handle, dataItem, removeDevices, isNeedHash);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("Get remove device id failed. err=%d", errCode);
                 return errCode;
             }
 
             // sync module will use handle to fix watermark, if fix fail then migrate fail, not need hold write handle
             errCode = ReleaseExecutor(handle);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("release executor for erase water mark! errCode = [%d]", errCode);
                 return errCode;
             }
 
             errCode = EraseDeviceWaterMark(removeDevices, isNeedHash);
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("EraseDeviceWaterMark failed when migrating, errCode = [%d]", errCode);
                 return errCode;
             }
 
             handle = static_cast<SQLiteSingleVerStorageExecutor *>(FindExecutor(true, OperatePerm::NORMAL_PERM,
                 errCode));
-            if (errCode != E_OK) {
+            if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
                 LOGE("Migrate sync data fail, Can not get available executor, errCode = [%d]", errCode);
                 return errCode;
             }
@@ -212,17 +213,17 @@ int SQLiteSingleVerStorageEngine::AddSubscribeToMainDBInMigrate()
 {
     LOGD("Add subscribe to mainDB from cache. %d", GetEngineState());
     std::lock_guard<std::mutex> lock(subscribeMutex_);
-    if (subscribeQuery_.empty()) {
+    if (subscribeQuery_.empty()) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
     int errCode = E_OK;
     auto handle = static_cast<SQLiteSingleVerStorageExecutor *>(FindExecutor(true, OperatePerm::NORMAL_PERM, errCode));
-    if (errCode != E_OK || handle == nullptr) {
+    if (errCode != E_OK || handle == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("Get available executor for add subscribe failed. %d", errCode);
         return errCode;
     }
     errCode = handle->StartTransaction(TransactType::IMMEDIATE);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         goto END;
     }
     for (auto item : subscribeQuery_) {
@@ -324,7 +325,7 @@ int SQLiteSingleVerStorageEngine::AttachMainDbAndCacheDb(sqlite3 *dbHandle, Engi
     // Judge the file corresponding to db by the engine status and attach it to another file
     int errCode = E_OK;
     std::string attachAbsPath;
-    if (stateBeforeMigrate == EngineState::MAINDB) {
+    if (stateBeforeMigrate == EngineState::MAINDB) { // LCOV_EXCL_BR_LINE
         attachAbsPath = GetDbDir(option_.subdir, DbType::CACHE) + "/" + DBConstant::SINGLE_VER_CACHE_STORE +
             DBConstant::DB_EXTENSION;
         errCode = SQLiteUtils::AttachNewDatabase(dbHandle, option_.cipherType, option_.passwd, attachAbsPath, "cache");
@@ -335,7 +336,7 @@ int SQLiteSingleVerStorageEngine::AttachMainDbAndCacheDb(sqlite3 *dbHandle, Engi
     } else {
         return -E_NOT_SUPPORT;
     }
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Attached database failed, errCode = [%d] engine state = [%d]", errCode, stateBeforeMigrate);
         return errCode;
     }
@@ -369,11 +370,11 @@ int SQLiteSingleVerStorageEngine::FinishMigrateData(SQLiteSingleVerStorageExecut
 {
     LOGI("Begin to finish migrate and reinit db state!");
     int errCode;
-    if (handle == nullptr) {
+    if (handle == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
-    if (stateBeforeMigrate == EngineState::MAINDB) {
+    if (stateBeforeMigrate == EngineState::MAINDB) { // LCOV_EXCL_BR_LINE
         sqlite3 *dbHandle = nullptr;
         errCode = handle->GetDbHandle(dbHandle); // use executor get sqlite3 handle to operating database
         if (errCode != E_OK) {
@@ -382,13 +383,13 @@ int SQLiteSingleVerStorageEngine::FinishMigrateData(SQLiteSingleVerStorageExecut
         }
 
         errCode = SQLiteUtils::ExecuteRawSQL(dbHandle, "DETACH 'cache'");
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Execute the SQLite detach failed:%d", errCode);
             return errCode;
         }
         // delete cachedb
         errCode = DBCommon::RemoveAllFilesOfDirectory(GetDbDir(option_.subdir, DbType::CACHE), false);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Remove files of cache database after detach:%d", errCode);
         }
 
@@ -397,7 +398,7 @@ int SQLiteSingleVerStorageEngine::FinishMigrateData(SQLiteSingleVerStorageExecut
     }
 
     errCode = ReleaseExecutor(handle);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Release executor for reopen database! errCode = [%d]", errCode);
         return errCode;
     }
@@ -407,14 +408,14 @@ int SQLiteSingleVerStorageEngine::FinishMigrateData(SQLiteSingleVerStorageExecut
 
     // delete cache db
     errCode = DBCommon::RemoveAllFilesOfDirectory(GetDbDir(option_.subdir, DbType::CACHE), false);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Remove files of cache database after release current db:%d", errCode);
         return errCode;
     }
 
     // reInit, it will reset engine state
     errCode = ReInit();
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Reinit failed when finish migrate data! please try reopen kvstore! errCode = [%d]", errCode);
         return errCode;
     }
@@ -609,7 +610,7 @@ int SQLiteSingleVerStorageEngine::GetDbHandle(bool isWrite, const SecurityOption
 {
     int errCode = TryToOpenMainDatabase(isWrite, dbHandle);
     LOGD("Finish to open the main database, write[%d], label[%d], flag[%d], id[%.6s], errCode[%d]",  isWrite,
-        secOpt.securityLabel, secOpt.securityFlag, DBCommon::TransferStringToHex(identifier_).c_str(), errCode);
+        secOpt.securityLabel, secOpt.securityFlag, hashIdentifier_.c_str(), errCode);
     if (!(ParamCheckUtils::IsS3SECEOpt(secOpt) && errCode == -E_EKEYREVOKED)) {
         return errCode;
     }
@@ -690,7 +691,7 @@ int SQLiteSingleVerStorageEngine::GetCacheDbHandle(sqlite3 *&db)
 
 int SQLiteSingleVerStorageEngine::CheckDatabaseSecOpt(const SecurityOption &secOption) const
 {
-    if (!(secOption == option_.securityOpt) &&
+    if (!(secOption == option_.securityOpt) && (secOption.securityLabel > option_.securityOpt.securityLabel) &&
         secOption.securityLabel != SecurityLabel::NOT_SET &&
         option_.securityOpt.securityLabel != SecurityLabel::NOT_SET) {
         LOGE("[SQLiteSingleVerStorageEngine] SecurityOption mismatch, existed:[%d-%d] vs input:[%d-%d]",
@@ -730,9 +731,15 @@ int SQLiteSingleVerStorageEngine::PreCreateExecutor(bool isWrite)
         return E_OK;
     }
 
+    // check sqlite open ok
+    int errCode = CheckStoreStatus(option_);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+
     // Get the existed database secure option.
     SecurityOption existedSecOpt;
-    int errCode = GetExistedSecOption(existedSecOpt);
+    errCode = GetExistedSecOption(existedSecOpt);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -860,6 +867,8 @@ int SQLiteSingleVerStorageEngine::CreateNewExecutor(bool isWrite, StorageExecuto
 int SQLiteSingleVerStorageEngine::Upgrade(sqlite3 *db)
 {
     if (isUpdated_ || GetEngineState() == EngineState::CACHEDB) {
+        LOGI("Storage engine [%.6s] is in cache status or has been upgraded[%d]!",
+            DBCommon::TransferStringToHex(identifier_).c_str(), isUpdated_);
         return E_OK;
     }
 
@@ -1000,7 +1009,12 @@ void SQLiteSingleVerStorageEngine::InitConflictNotifiedFlag(SingleVerNaturalStor
         return;
     }
     auto identifier = GetIdentifier();
-    auto kvdb = KvDBManager::GetInstance()->FindKvDB(identifier);
+    auto kvDBManager = KvDBManager::GetInstance();
+    if (kvDBManager == nullptr) {
+        LOGE("[SQLiteSingleVerStorageEngine::InitConflictNotifiedFlag] kvDBManager is null.");
+        return;
+    }
+    auto kvdb = kvDBManager->FindKvDB(identifier);
     if (kvdb == nullptr) {
         LOGE("[SQLiteSingleVerStorageEngine::InitConflictNotifiedFlag] kvdb is null.");
         return;
@@ -1031,8 +1045,8 @@ void SQLiteSingleVerStorageEngine::CommitNotifyForMigrateCache(NotifyMigrateSync
     auto &entries = syncData.entries;
 
     // Put data. Including insert, update and delete.
-    if (!isRemoveDeviceData) {
-        if (committedData != nullptr) {
+    if (!isRemoveDeviceData) { // LCOV_EXCL_BR_LINE
+        if (committedData != nullptr) { // LCOV_EXCL_BR_LINE
             int eventType = static_cast<int>(isRemote ?
                 SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_SYNC_EVENT :
                 SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_PUT_EVENT);
@@ -1042,24 +1056,25 @@ void SQLiteSingleVerStorageEngine::CommitNotifyForMigrateCache(NotifyMigrateSync
     }
 
     // Remove device data.
-    if (entries.empty() || entries.size() > MAX_TOTAL_NOTIFY_ITEM_SIZE) {
+    if (entries.empty() || entries.size() > MAX_TOTAL_NOTIFY_ITEM_SIZE) { // LCOV_EXCL_BR_LINE
         return;
     }
     size_t totalSize = 0;
     for (auto iter = entries.begin(); iter != entries.end();) {
         auto &entry = *iter;
-        if (committedData == nullptr) {
+        if (committedData == nullptr) { // LCOV_EXCL_BR_LINE
             committedData = new (std::nothrow) SingleVerNaturalStoreCommitNotifyData();
-            if (committedData == nullptr) {
+            if (committedData == nullptr) { // LCOV_EXCL_BR_LINE
                 LOGE("Alloc committed notify data failed.");
                 return;
             }
         }
-        if (entry.key.size() > DBConstant::MAX_KEY_SIZE || entry.value.size() > DBConstant::MAX_VALUE_SIZE) {
+        if (entry.key.size() > DBConstant::MAX_KEY_SIZE || entry.value.size() >
+            DBConstant::MAX_VALUE_SIZE) { // LCOV_EXCL_BR_LINE
             iter++;
             continue;
         }
-        if (entry.key.size() + entry.value.size() + totalSize > MAX_TOTAL_NOTIFY_DATA_SIZE) {
+        if (entry.key.size() + entry.value.size() + totalSize > MAX_TOTAL_NOTIFY_DATA_SIZE) { // LCOV_EXCL_BR_LINE
             CommitAndReleaseNotifyData(committedData,
                 static_cast<int>(SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_SYNC_EVENT));
             totalSize = 0;
@@ -1069,7 +1084,7 @@ void SQLiteSingleVerStorageEngine::CommitNotifyForMigrateCache(NotifyMigrateSync
         committedData->InsertCommittedData(std::move(entry), DataType::DELETE, false);
         iter++;
     }
-    if (committedData != nullptr) {
+    if (committedData != nullptr) { // LCOV_EXCL_BR_LINE
         CommitAndReleaseNotifyData(committedData,
             static_cast<int>(SQLiteGeneralNSNotificationEventType::SQLITE_GENERAL_NS_SYNC_EVENT));
     }
@@ -1092,6 +1107,9 @@ bool SQLiteSingleVerStorageEngine::IsUseExistedSecOption(const SecurityOption &e
         existedSecOpt.securityLabel == SecurityLabel::NOT_SET) {
         return false;
     }
+    if (existedSecOpt.securityLabel < openSecOpt.securityLabel) {
+        return false;
+    }
     return true;
 }
 
@@ -1105,7 +1123,7 @@ int SQLiteSingleVerStorageEngine::UpgradeLocalMetaData()
             isSchemaChanged_ = false;
         }
     }
-    if (schemaChangedFunc) {
+    if (schemaChangedFunc != nullptr) {
         return schemaChangedFunc();
     }
     return E_OK;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
index c12c9930f596f7a213f06a40d81e952d1ff796e5..1e567ce327b4597471f839136046bb7557ec800a 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.cpp
@@ -21,13 +21,13 @@
 #include "db_constant.h"
 #include "db_common.h"
 #include "db_errno.h"
+#include "log_print.h"
+#include "log_table_manager_factory.h"
 #include "parcel.h"
 #include "platform_specific.h"
 #include "runtime_context.h"
 #include "sqlite_meta_executor.h"
 #include "sqlite_single_ver_storage_executor_sql.h"
-#include "log_print.h"
-#include "log_table_manager_factory.h"
 
 namespace DistributedDB {
 namespace {
@@ -1220,6 +1220,9 @@ int SQLiteSingleVerStorageExecutor::SaveSyncDataToDatabase(const DataItem &dataI
     if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
         errCode = E_OK;
     }
+    if (errCode == E_OK) {
+        errCode = RemoveCloudUploadFlag(hashKey);
+    }
     return errCode;
 }
 
@@ -1364,7 +1367,7 @@ int SQLiteSingleVerStorageExecutor::SaveSyncDataItem(DataItem &dataItem, const D
 
     PutConflictData(dataItem, notify.getData, deviceInfo, notify.dataStatus, committedData);
     if (notify.dataStatus.isDefeated) {
-        LOGD("Data status is defeated:%d", errCode);
+        LOGE("Data status is defeated:%d", errCode);
         return ResetSaveSyncStatements(errCode);
     }
 
@@ -1700,36 +1703,20 @@ END:
 int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceName)
 {
     int errCode = E_OK;
-    sqlite3_stmt *statement = nullptr;
+    bool isCreate = false;
+    int ret = SQLiteUtils::CheckTableExists(dbHandle_, NATURALBASE_KV_AUX_SYNC_DATA_LOG_TABLE_NAME, isCreate);
+    bool isTableExists = (ret == E_OK && isCreate);
     if (deviceName.empty()) {
-        errCode = SQLiteUtils::GetStatement(dbHandle_, REMOVE_ALL_DEV_DATA_SQL, statement);
-        if (errCode != E_OK) {
-            goto ERROR;
+        if (isTableExists) {
+            CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_ALL_LOG_DATA_SQL, "", "");
         }
+        errCode = CloudExcuteRemoveOrUpdate(REMOVE_ALL_DEV_DATA_SQL, "", "");
     } else {
-        // device name always hash string.
-        std::vector<uint8_t> devVect(deviceName.begin(), deviceName.end());
-        errCode = SQLiteUtils::GetStatement(dbHandle_, REMOVE_DEV_DATA_SQL, statement);
-        if (errCode != E_OK) {
-            goto ERROR;
-        }
-
-        errCode = SQLiteUtils::BindBlobToStatement(statement, 1, devVect, true); // only one arg.
-        if (errCode != E_OK) {
-            LOGE("Failed to bind the removed device:%d", errCode);
-            goto ERROR;
+        if (isTableExists) {
+            CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_LOG_DATA_BY_DEVID_SQL, deviceName, "");
         }
+        errCode = CloudExcuteRemoveOrUpdate(REMOVE_DEV_DATA_SQL, deviceName, "");
     }
-
-    errCode = SQLiteUtils::StepWithRetry(statement, isMemDb_);
-    if (errCode != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
-        LOGE("Failed to execute rm the device synced data:%d", errCode);
-    } else {
-        errCode = E_OK;
-    }
-
-ERROR:
-    SQLiteUtils::ResetStatement(statement, true, errCode);
     return CheckCorruptedStatus(errCode);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
index 69f87fd7eddf89cbba59237f71be162c75e48c48..139b4a558821e09995885c57e7f3e4a46c605228 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor.h
@@ -80,6 +80,13 @@ public:
         Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const;
     int GetDeletedSyncDataByTimestamp(std::vector<DataItem> &dataItems, size_t appendLength, Timestamp begin,
         Timestamp end, const DataSizeSpecInfo &dataSizeInfo) const;
+    
+    int GetUnSyncTotalByTimestamp(Timestamp begin, Timestamp end, uint32_t &total) const;
+
+    int GetDeletedSyncTotalByTimestamp(Timestamp begin, Timestamp end, uint32_t &total) const;
+
+    int GetSyncTotalWithQuery(QueryObject &query, const std::pair<Timestamp, Timestamp> &timeRange,
+        uint32_t &total) const;
 
     int GetDeviceIdentifier(PragmaEntryDeviceIdentifier *identifier);
 
@@ -241,6 +248,11 @@ private:
 
     int PrepareForSyncDataByTime(Timestamp begin, Timestamp end, sqlite3_stmt *&statement, bool getDeletedData = false)
         const;
+    
+    int PrepareForUnSyncTotalByTime(Timestamp begin, Timestamp end, sqlite3_stmt *&statement,
+        bool getDeletedData = false) const;
+    
+    int GetCountValue(sqlite3_stmt *&countStatement, uint32_t &total) const;
 
     int StepForResultEntries(bool isGetValue, sqlite3_stmt *statement, std::vector<Entry> &entries) const;
 
@@ -363,6 +375,8 @@ private:
     int RemoveDeviceDataWithUserInner(const std::string &user, ClearMode mode);
 
     int RemoveDeviceDataWithUserInner(const std::string &deviceName, const std::string &user, ClearMode mode);
+
+    int RemoveCloudUploadFlag(const std::vector<uint8_t> &hashKey);
     sqlite3_stmt *getSyncStatement_;
     sqlite3_stmt *getResultRowIdStatement_;
     sqlite3_stmt *getResultEntryStatement_;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_cache.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_cache.cpp
index 0939a372372aef51e9291d9e1c4a53d4b60a9365..5c28b663d9a70c34c975e976e461770d91472922 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_cache.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_cache.cpp
@@ -268,7 +268,7 @@ int SQLiteSingleVerStorageExecutor::MigrateDataItem(DataItem &dataItem, const No
     }
     // after solving conflict, the item should not be saved into mainDB
     if (notify.dataStatus.isDefeated) {
-        LOGD("Data status is defeated:%d", errCode);
+        LOGE("Data status is defeated:%d", errCode);
         return errCode;
     }
     bool isUpdate = notify.dataStatus.preStatus != DataStatus::NOEXISTED;
@@ -769,7 +769,7 @@ int SQLiteSingleVerStorageExecutor::PutIntoConflictAndCommitForMigrateCache(Data
 
     PutConflictData(dataItem, notify.getData, deviceInfo, notify.dataStatus, notify.committedData);
     if (notify.dataStatus.isDefeated) {
-        LOGD("Data status is defeated:%d", errCode);
+        LOGE("Data status is defeated:%d", errCode);
         return ResetForMigrateCacheData();
     }
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_extend.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_extend.cpp
index c149945af9f8ddeb27599ef430bb4d85eb89b267..ffab813098d9491b9cab974ee245055133105af5 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_extend.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_extend.cpp
@@ -18,12 +18,13 @@
 #include <algorithm>
 
 #include "cloud/cloud_store_types.h"
+#include "data_transformer.h"
 #include "db_constant.h"
 #include "db_common.h"
 #include "db_errno.h"
-#include "res_finalizer.h"
 #include "parcel.h"
 #include "platform_specific.h"
+#include "res_finalizer.h"
 #include "runtime_context.h"
 #include "sqlite_meta_executor.h"
 #include "sqlite_single_ver_storage_executor_sql.h"
@@ -46,6 +47,7 @@ int SQLiteSingleVerStorageExecutor::CloudExcuteRemoveOrUpdate(const std::string
     }
     // device name always hash string.
     int bindIndex = 1; // 1 is the first index for blob to bind.
+    int ret = E_OK;
     if (!user.empty()) {
         if (isUserBlobType) {
             std::vector<uint8_t> useVect(user.begin(), user.end());
@@ -55,7 +57,7 @@ int SQLiteSingleVerStorageExecutor::CloudExcuteRemoveOrUpdate(const std::string
         }
         if (errCode != E_OK) {
             LOGE("Failed to bind the removed device:%d", errCode);
-            SQLiteUtils::ResetStatement(statement, true, errCode);
+            SQLiteUtils::ResetStatement(statement, true, ret);
             return errCode;
         }
         bindIndex++;
@@ -65,7 +67,7 @@ int SQLiteSingleVerStorageExecutor::CloudExcuteRemoveOrUpdate(const std::string
         errCode = SQLiteUtils::BindBlobToStatement(statement, bindIndex, devVect, true); // only one arg.
         if (errCode != E_OK) {
             LOGE("Failed to bind the removed device:%d", errCode);
-            SQLiteUtils::ResetStatement(statement, true, errCode);
+            SQLiteUtils::ResetStatement(statement, true, ret);
             return errCode;
         }
     }
@@ -75,8 +77,8 @@ int SQLiteSingleVerStorageExecutor::CloudExcuteRemoveOrUpdate(const std::string
     } else {
         errCode = E_OK;
     }
-    SQLiteUtils::ResetStatement(statement, true, errCode);
-    return errCode;
+    SQLiteUtils::ResetStatement(statement, true, ret);
+    return errCode != E_OK ? errCode : ret;
 }
 
 int SQLiteSingleVerStorageExecutor::CloudCheckDataExist(const std::string &sql, const std::string &deviceName,
@@ -89,11 +91,12 @@ int SQLiteSingleVerStorageExecutor::CloudCheckDataExist(const std::string &sql,
         return errCode;
     }
     int bindIndex = 1; // 1 is the first index for blob to bind.
+    int ret = E_OK;
     if (!user.empty()) {
         errCode = SQLiteUtils::BindTextToStatement(statement, bindIndex, user); // only one arg.
         if (errCode != E_OK) {
             LOGE("Failed to bind the removed device:%d", errCode);
-            SQLiteUtils::ResetStatement(statement, true, errCode);
+            SQLiteUtils::ResetStatement(statement, true, ret);
             return errCode;
         }
         bindIndex++;
@@ -101,7 +104,7 @@ int SQLiteSingleVerStorageExecutor::CloudCheckDataExist(const std::string &sql,
             errCode = SQLiteUtils::BindTextToStatement(statement, bindIndex, user); // only one arg.
             if (errCode != E_OK) {
                 LOGE("Failed to bind the removed device:%d", errCode);
-                SQLiteUtils::ResetStatement(statement, true, errCode);
+                SQLiteUtils::ResetStatement(statement, true, ret);
                 return errCode;
             }
         }
@@ -111,7 +114,7 @@ int SQLiteSingleVerStorageExecutor::CloudCheckDataExist(const std::string &sql,
         errCode = SQLiteUtils::BindBlobToStatement(statement, bindIndex, devVect, true); // only one arg.
         if (errCode != E_OK) {
             LOGE("Failed to bind the removed device:%d", errCode);
-            SQLiteUtils::ResetStatement(statement, true, errCode);
+            SQLiteUtils::ResetStatement(statement, true, ret);
             return errCode;
         }
     }
@@ -122,15 +125,18 @@ int SQLiteSingleVerStorageExecutor::CloudCheckDataExist(const std::string &sql,
         if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) { // means deviceId can be matched in log table
             isExist = true;
         }
-        SQLiteUtils::ResetStatement(statement, true, errCode);
+        SQLiteUtils::ResetStatement(statement, true, ret);
         return E_OK;
     }
-    SQLiteUtils::ResetStatement(statement, true, errCode);
-    return errCode;
+    SQLiteUtils::ResetStatement(statement, true, ret);
+    return errCode != E_OK ? errCode : ret;
 }
 
 int SQLiteSingleVerStorageExecutor::RemoveDeviceDataInner(ClearMode mode)
 {
+    if (mode == ClearMode::DEFAULT) {
+        return CloudExcuteRemoveOrUpdate(REMOVE_ALL_DEV_SYNC_DATA_SQL, "", "");
+    }
     int errCode = CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_ALL_HWM_DATA_SQL, "", "", true);
     if (errCode != E_OK) {
         return errCode;
@@ -141,14 +147,15 @@ int SQLiteSingleVerStorageExecutor::RemoveDeviceDataInner(ClearMode mode)
     }
     if (mode == FLAG_AND_DATA) {
         return CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_ALL_DEV_DATA_SQL, "", "");
-    } else {
-        return CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_ALL_DEV_DATA_SQL, "", "");
     }
-    return errCode;
+    return CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_ALL_DEV_DATA_SQL, "", "");
 }
 
 int SQLiteSingleVerStorageExecutor::RemoveDeviceDataInner(const std::string &deviceName, ClearMode mode)
 {
+    if (mode == ClearMode::DEFAULT) {
+        return CloudExcuteRemoveOrUpdate(REMOVE_DEV_SYNC_DATA_BY_DEV_ID_SQL, deviceName, "");
+    }
     int errCode = CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_ALL_HWM_DATA_SQL, "", "", true);
     if (errCode != E_OK) {
         return errCode;
@@ -159,10 +166,13 @@ int SQLiteSingleVerStorageExecutor::RemoveDeviceDataInner(const std::string &dev
     }
     if (mode == FLAG_AND_DATA) {
         return CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_DEV_DATA_BY_DEVID_SQL, deviceName, "");
-    } else {
-        return CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_DEV_DATA_BY_DEVID_SQL, deviceName, "");
+    } else if (mode == FLAG_ONLY) {
+        errCode = CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_DEV_DATA_VERSION_BY_DEVID_SQL, deviceName, "");
+        if (errCode != E_OK) {
+            return errCode;
+        }
     }
-    return errCode;
+    return CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_DEV_DATA_BY_DEVID_SQL, deviceName, "");
 }
 
 int SQLiteSingleVerStorageExecutor::RemoveDeviceDataWithUserInner(const std::string &user, ClearMode mode)
@@ -215,22 +225,18 @@ int SQLiteSingleVerStorageExecutor::RemoveDeviceDataWithUserInner(const std::str
             return CloudExcuteRemoveOrUpdate(REMOVE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL, deviceName, "");
         }
     }
-    errCode = CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL, deviceName, "");
-    if (errCode != E_OK) {
-        return errCode;
-    }
-    return E_OK;
+    return CloudExcuteRemoveOrUpdate(UPDATE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL, deviceName, "");
 }
 
 int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceName, ClearMode mode)
 {
-    int errCode = E_OK;
     if (deviceName.empty()) {
         return CheckCorruptedStatus(RemoveDeviceDataInner(mode));
     }
     bool isDataExist = false;
-    errCode = CloudCheckDataExist(SELECT_CLOUD_LOG_DATA_BY_DEVID_SQL, deviceName, "", isDataExist);
-    if (!isDataExist || errCode != E_OK) { // means deviceId can not be matched in log table
+    int errCode = CloudCheckDataExist(SELECT_CLOUD_LOG_DATA_BY_DEVID_SQL, deviceName, "", isDataExist);
+    // means deviceId can not be matched in log table
+    if (mode != ClearMode::DEFAULT && (!isDataExist || errCode != E_OK)) {
         return CheckCorruptedStatus(errCode);
     }
     return CheckCorruptedStatus(RemoveDeviceDataInner(deviceName, mode));
@@ -239,6 +245,10 @@ int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceNa
 int SQLiteSingleVerStorageExecutor::RemoveDeviceData(const std::string &deviceName, const std::string &user,
     ClearMode mode)
 {
+    if (mode == ClearMode::DEFAULT) {
+        return CheckCorruptedStatus(deviceName.empty() ?
+            RemoveDeviceDataInner(deviceName, mode) : RemoveDeviceDataInner(mode));
+    }
     int errCode = E_OK;
     bool isDataExist = false;
     if (deviceName.empty()) {
@@ -287,4 +297,124 @@ int SQLiteSingleVerStorageExecutor::GetEntries(const std::string &device, std::v
     LOGD("[SQLiteSingleVerStorageExecutor] Get %zu entries by device", entries.size());
     return errCode;
 }
+
+int SQLiteSingleVerStorageExecutor::PrepareForUnSyncTotalByTime(Timestamp begin, Timestamp end,
+    sqlite3_stmt *&statement, bool getDeletedData) const
+{
+    if (dbHandle_ == nullptr) {
+        return -E_INVALID_DB;
+    }
+
+    const std::string sql = (getDeletedData ? COUNT_SYNC_DELETED_ENTRIES_SQL : COUNT_SYNC_ENTRIES_SQL);
+    int errCode = SQLiteUtils::GetStatement(dbHandle_, sql, statement);
+    if (errCode != E_OK) {
+        LOGE("Prepare the sync num entries statement error:%d", errCode);
+        return errCode;
+    }
+
+    errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_BEGIN_STAMP_INDEX, begin);
+    if (errCode != E_OK) {
+        LOGE("Bind the timestamp for getting sync num error:%d", errCode);
+        SQLiteUtils::ResetStatement(statement, true, errCode);
+        return CheckCorruptedStatus(errCode);
+    }
+
+    errCode = SQLiteUtils::BindInt64ToStatement(statement, BIND_END_STAMP_INDEX, end);
+    return CheckCorruptedStatus(errCode);
+}
+
+int SQLiteSingleVerStorageExecutor::GetCountValue(sqlite3_stmt *&countStatement, uint32_t &total) const
+{
+    int errCode = SQLiteUtils::StepWithRetry(countStatement, isMemDb_);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+        uint64_t readCount = static_cast<uint64_t>(sqlite3_column_int64(countStatement, 0));
+        if (readCount > UINT32_MAX) {
+            LOGW("ReadCount is beyond UINT32_MAX");
+            total = 0;
+            errCode = -E_UNEXPECTED_DATA;
+        } else {
+            total = static_cast<uint32_t>(readCount);
+            errCode = E_OK;
+        }
+        LOGD("[GetCountValue]Entry count in this result set is %" PRIu32 "", total);
+    } else {
+        errCode = -E_UNEXPECTED_DATA;
+    }
+    SQLiteUtils::ResetStatement(countStatement, true, errCode);
+    return CheckCorruptedStatus(errCode);
+}
+
+int SQLiteSingleVerStorageExecutor::GetUnSyncTotalByTimestamp(Timestamp begin, Timestamp end, uint32_t &total) const
+{
+    sqlite3_stmt *countStatement = nullptr;
+    int errCode = PrepareForUnSyncTotalByTime(begin, end, countStatement);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    return GetCountValue(countStatement, total);
+}
+
+int SQLiteSingleVerStorageExecutor::GetDeletedSyncTotalByTimestamp(Timestamp begin, Timestamp end,
+    uint32_t &total) const
+{
+    sqlite3_stmt *countStatement = nullptr;
+    int errCode = PrepareForUnSyncTotalByTime(begin, end, countStatement, true);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    return GetCountValue(countStatement, total);
+}
+
+int SQLiteSingleVerStorageExecutor::GetSyncTotalWithQuery(QueryObject &query,
+    const std::pair<Timestamp, Timestamp> &timeRange, uint32_t &total) const
+{
+    int errCode = E_OK;
+    SqliteQueryHelper helper = query.GetQueryHelper(errCode);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    sqlite3_stmt *queryStmt = nullptr;
+    errCode = helper.GetQuerySyncStatement(dbHandle_, timeRange.first, timeRange.second, queryStmt, true);
+    if (errCode != E_OK) {
+        LOGE("Get query sync num statement failed. %d", errCode);
+        return errCode;
+    }
+    return GetCountValue(queryStmt, total);
+}
+
+int SQLiteSingleVerStorageExecutor::RemoveCloudUploadFlag(const std::vector<uint8_t> &hashKey)
+{
+    const std::string tableName = "naturalbase_kv_aux_sync_data_log";
+    bool isCreate = false;
+    int errCode = SQLiteUtils::CheckTableExists(dbHandle_, tableName, isCreate);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    if (!isCreate) {
+        return E_OK;
+    }
+    std::string removeSql = "UPDATE " + tableName + " SET cloud_flag=cloud_flag&(~" +
+        std::to_string(static_cast<uint32_t>(LogInfoFlag::FLAG_UPLOAD_FINISHED)) + ") WHERE hash_key=?";
+    sqlite3_stmt *stmt = nullptr;
+    errCode = SQLiteUtils::GetStatement(dbHandle_, removeSql, stmt);
+    if (errCode != E_OK) {
+        LOGE("[SQLiteSingleVerStorageExecutor] Remove cloud flag get stmt failed %d", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::BindBlobToStatement(stmt, BIND_HASH_KEY_INDEX, hashKey);
+    if (errCode != E_OK) {
+        LOGE("[SQLiteSingleVerStorageExecutor] Remove cloud flag bind hashKey failed %d", errCode);
+        return errCode;
+    }
+    errCode = SQLiteUtils::StepWithRetry(stmt, isMemDb_);
+    if (errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW) || errCode == SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        errCode = E_OK;
+    }
+    int ret = E_OK;
+    SQLiteUtils::ResetStatement(stmt, true, ret);
+    if (ret != E_OK) {
+        LOGW("[SQLiteSingleVerStorageExecutor] Finalize stmt failed %d", ret);
+    }
+    return errCode == E_OK ? ret : errCode;
+}
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
index 4d00502100eb24aef8c080ba50600e29cc067058..ae72424da9bcf04de2cad726301290c49a60f8b8 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_single_ver_storage_executor_sql.h
@@ -22,283 +22,301 @@
 
 namespace DistributedDB {
     //  cache.sync_data is design for migrating action after process restart
-    const std::string INSERT_LOCAL_SQL =
+    constexpr const char *INSERT_LOCAL_SQL =
         "INSERT OR REPLACE INTO local_data VALUES(?,?,?,?);";
-    const std::string INSERT_LOCAL_SQL_FROM_CACHEHANDLE =
+    constexpr const char *INSERT_LOCAL_SQL_FROM_CACHEHANDLE =
         "INSERT OR REPLACE INTO maindb.local_data VALUES(?,?,?,?);";
 
-    const std::string INSERT_CACHE_LOCAL_SQL =
+    constexpr const char *INSERT_CACHE_LOCAL_SQL =
         "INSERT OR REPLACE INTO local_data VALUES(?,?,?,?,?);";
 
-    const std::string UPDATE_LOCAL_SQL_FROM_CACHEHANDLE =
+    constexpr const char *UPDATE_LOCAL_SQL_FROM_CACHEHANDLE =
         "UPDATE maindb.local_data SET key=?,value=?,timestamp=? where hash_key=?";
 
-    const std::string UPDATE_CACHE_LOCAL_SQL =
+    constexpr const char *UPDATE_CACHE_LOCAL_SQL =
         "UPDATE local_data SET key=?,value=?,timestamp=? where hash_key=?";
 
-    const std::string INSERT_META_SQL =
+    constexpr const char *INSERT_META_SQL =
         "INSERT OR REPLACE INTO meta_data VALUES(?,?);";
 
-    const std::string INSERT_ATTACH_META_SQL =
+    constexpr const char *INSERT_ATTACH_META_SQL =
         "INSERT OR REPLACE INTO meta.meta_data VALUES(?,?);";
 
-    const std::string INSERT_SYNC_SQL =
+    constexpr const char *INSERT_SYNC_SQL =
         "INSERT OR REPLACE INTO sync_data VALUES(?,?,?,?,?,?,?,?,?,?);";
 
-    const std::string UPDATE_SYNC_SQL =
+    constexpr const char *UPDATE_SYNC_SQL =
         "UPDATE sync_data SET key=?,value=?,timestamp=?,flag=?,device=?,ori_device=?,w_timestamp=?," \
         "modify_time=?,create_time=? WHERE hash_key=?;";
 
-    const std::string INSERT_CACHE_SYNC_SQL =
+    constexpr const char *INSERT_CACHE_SYNC_SQL =
         "INSERT OR REPLACE INTO sync_data VALUES(?,?,?,?,?,?,?,?,?);";
-    const std::string INSERT_CACHE_SYNC_SQL_FROM_MAINHANDLE =
+    constexpr const char *INSERT_CACHE_SYNC_SQL_FROM_MAINHANDLE =
         "INSERT OR REPLACE INTO cache.sync_data VALUES(?,?,?,?,?,?,?,?,?);";
 
-    const std::string UPDATE_CACHE_SYNC_SQL =
+    constexpr const char *UPDATE_CACHE_SYNC_SQL =
         "UPDATE sync_data SET key=?,value=?,timestamp=?,flag=?,device=?,ori_device=?,w_timestamp=? WHERE hash_key=?;";
 
-    const std::string UPDATE_CACHE_SYNC_SQL_FROM_MAINHANDLE =
+    constexpr const char *UPDATE_CACHE_SYNC_SQL_FROM_MAINHANDLE =
         "UPDATE cache.sync_data SET key=?,value=?,timestamp=?,flag=?,device=?,ori_device=?,w_timestamp=? "
         "WHERE hash_key=?;";
 
-    const std::string DELETE_LOCAL_SQL =
+    constexpr const char *DELETE_LOCAL_SQL =
         "DELETE FROM local_data WHERE key=?;";
-    const std::string DELETE_LOCAL_SQL_FROM_CACHEHANDLE =
+    constexpr const char *DELETE_LOCAL_SQL_FROM_CACHEHANDLE =
         "DELETE FROM maindb.local_data WHERE key=?;";
 
-    const std::string SELECT_ALL_META_KEYS =
+    constexpr const char *SELECT_ALL_META_KEYS =
         "SELECT key FROM meta_data;";
 
-    const std::string SELECT_ATTACH_ALL_META_KEYS =
+    constexpr const char *SELECT_ATTACH_ALL_META_KEYS =
         "SELECT key FROM meta.meta_data;";
 
-    const std::string SELECT_META_KEYS_BY_PREFIX =
+    constexpr const char *SELECT_META_KEYS_BY_PREFIX =
         "SELECT key FROM meta_data where key like ?;";
 
-    const std::string SELECT_ATTACH_META_KEYS_BY_PREFIX =
+    constexpr const char *SELECT_ATTACH_META_KEYS_BY_PREFIX =
         "SELECT key FROM meta.meta_data where key like ?;";
 
-    const std::string SELECT_ALL_SYNC_ENTRIES_BY_DEV =
+    constexpr const char *SELECT_ALL_SYNC_ENTRIES_BY_DEV =
         "SELECT key, value FROM sync_data WHERE device=? AND (flag&0x03=0);";
 
-    const std::string SELECT_ALL_SYNC_ENTRIES =
+    constexpr const char *SELECT_ALL_SYNC_ENTRIES =
         "SELECT key, value FROM sync_data WHERE (flag&0x03=0);";
 
-    const std::string SELECT_ALL_SYNC_ENTRIES_BY_DEV_FROM_CACHEHANDLE =
+    constexpr const char *SELECT_ALL_SYNC_ENTRIES_BY_DEV_FROM_CACHEHANDLE =
         "SELECT key, value FROM maindb.sync_data WHERE device=? AND (flag&0x03=0);";
 
-    const std::string SELECT_ALL_SYNC_ENTRIES_FROM_CACHEHANDLE =
+    constexpr const char *SELECT_ALL_SYNC_ENTRIES_FROM_CACHEHANDLE =
         "SELECT key, value FROM maindb.sync_data WHERE (flag&0x03=0);";
 
-    const std::string SELECT_LOCAL_VALUE_TIMESTAMP_SQL =
+    constexpr const char *SELECT_LOCAL_VALUE_TIMESTAMP_SQL =
         "SELECT value, timestamp FROM local_data WHERE key=?;";
 
-    const std::string SELECT_SYNC_SQL =
+    constexpr const char *SELECT_SYNC_SQL =
         "SELECT * FROM sync_data WHERE key=?;";
 
-    const std::string SELECT_SYNC_VALUE_WTIMESTAMP_SQL =
+    constexpr const char *SELECT_SYNC_VALUE_WTIMESTAMP_SQL =
         "SELECT value, w_timestamp FROM sync_data WHERE key=? AND (flag&0x200=0);";
 
-    const std::string SELECT_SYNC_HASH_SQL =
+    constexpr const char *SELECT_SYNC_HASH_SQL =
         "SELECT * FROM sync_data WHERE hash_key=?;";
 
-    const std::string SELECT_CACHE_SYNC_HASH_SQL =
+    constexpr const char *SELECT_CACHE_SYNC_HASH_SQL =
         "SELECT * FROM sync_data WHERE hash_key=? AND version=?;";
-    const std::string SELECT_CACHE_SYNC_HASH_SQL_FROM_MAINHANDLE =
+    constexpr const char *SELECT_CACHE_SYNC_HASH_SQL_FROM_MAINHANDLE =
         "SELECT * FROM cache.sync_data WHERE hash_key=? AND version=?;";
 
-    const std::string SELECT_LOCAL_HASH_SQL =
+    constexpr const char *SELECT_LOCAL_HASH_SQL =
         "SELECT * FROM local_data WHERE hash_key=?;";
 
-    const std::string SELECT_CACHE_LOCAL_HASH_SQL =
+    constexpr const char *SELECT_CACHE_LOCAL_HASH_SQL =
         "SELECT * FROM local_data WHERE hash_key=?;";
 
-    const std::string SELECT_META_VALUE_SQL =
+    constexpr const char *SELECT_META_VALUE_SQL =
         "SELECT value FROM meta_data WHERE key=?;";
 
-    const std::string SELECT_ATTACH_META_VALUE_SQL =
+    constexpr const char *SELECT_ATTACH_META_VALUE_SQL =
         "SELECT value FROM meta.meta_data WHERE key=?;";
 
-    const std::string SELECT_MAX_TIMESTAMP_SQL =
+    constexpr const char *SELECT_MAX_TIMESTAMP_SQL =
         "SELECT MAX(timestamp) FROM sync_data;";
-    const std::string SELECT_MAX_TIMESTAMP_SQL_FROM_CACHEHANDLE =
+    constexpr const char *SELECT_MAX_TIMESTAMP_SQL_FROM_CACHEHANDLE =
         "SELECT MAX(timestamp) FROM maindb.sync_data;";
 
-    const std::string SELECT_NATIVE_MIN_TIMESTAMP_IN_CACHE_SYNC_DATA_SQL =
+    constexpr const char *SELECT_NATIVE_MIN_TIMESTAMP_IN_CACHE_SYNC_DATA_SQL =
         "SELECT MIN(timestamp) FROM sync_data WHERE flag&0x02=0x02;";
-    const std::string SELECT_NATIVE_MIN_TIMESTAMP_IN_CACHE_SYNC_DATA_SQL_FROM_MAINHANDLE =
+    constexpr const char *SELECT_NATIVE_MIN_TIMESTAMP_IN_CACHE_SYNC_DATA_SQL_FROM_MAINHANDLE =
         "SELECT MIN(timestamp) FROM cache.sync_data WHERE flag&0x02=0x02;";
 
-    const std::string SELECT_SYNC_ENTRIES_SQL =
+    constexpr const char *SELECT_SYNC_ENTRIES_SQL =
         "SELECT * FROM sync_data WHERE timestamp >= ? AND timestamp < ? AND (flag&0x02=0x02) AND (flag&0x200=0) "
         "ORDER BY timestamp ASC;";
 
-    const std::string SELECT_SYNC_DELETED_ENTRIES_SQL =
+    constexpr const char *SELECT_SYNC_DELETED_ENTRIES_SQL =
         "SELECT * FROM sync_data WHERE timestamp >= ? AND timestamp < ? AND (flag&0x03=0x03) AND (flag&0x200=0) "
         "ORDER BY timestamp ASC;";
-
-    const std::string SELECT_SYNC_MODIFY_SQL =
+    
+    constexpr const char *COUNT_SYNC_ENTRIES_SQL =
+        "SELECT count(key) FROM sync_data WHERE timestamp >= ? AND timestamp < ? AND (flag&0x02=0x02) "
+        "AND (flag&0x200=0);";
+    
+    constexpr const char *COUNT_SYNC_DELETED_ENTRIES_SQL =
+        "SELECT count(key) FROM sync_data WHERE timestamp >= ? AND timestamp < ? AND (flag&0x03=0x03) "
+        "AND (flag&0x200=0);";
+
+    constexpr const char *SELECT_SYNC_MODIFY_SQL =
         "SELECT * FROM sync_data WHERE timestamp >= ? AND timestamp < ? AND (flag&0x03=0x02) AND (flag&0x200=0) "
         "ORDER BY timestamp ASC;";
 
-    const std::string SELECT_SYNC_PREFIX_SQL =
+    constexpr const char *SELECT_SYNC_PREFIX_SQL =
         "SELECT key, value FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) AND (flag&0x200=0) "
         "ORDER BY key ASC;";
 
-    const std::string SELECT_SYNC_KEY_PREFIX_SQL =
+    constexpr const char *SELECT_SYNC_KEY_PREFIX_SQL =
         "SELECT key FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) AND (flag&0x200=0) ORDER BY key ASC;";
 
-    const std::string SELECT_SYNC_ROWID_PREFIX_SQL =
+    constexpr const char *SELECT_SYNC_ROWID_PREFIX_SQL =
         "SELECT rowid FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) AND (flag&0x200=0) ORDER BY key ASC;";
 
-    const std::string SELECT_SYNC_DATA_BY_ROWID_SQL =
+    constexpr const char *SELECT_SYNC_DATA_BY_ROWID_SQL =
         "SELECT key, value FROM sync_data WHERE rowid=?;";
 
-    const std::string SELECT_LOCAL_PREFIX_SQL =
+    constexpr const char *SELECT_LOCAL_PREFIX_SQL =
         "SELECT key, value FROM local_data WHERE key>=? AND key<=? ORDER BY key ASC;";
 
-    const std::string SELECT_COUNT_SYNC_PREFIX_SQL =
+    constexpr const char *SELECT_COUNT_SYNC_PREFIX_SQL =
         "SELECT count(key) FROM sync_data WHERE key>=? AND key<=? AND (flag&0x01=0) AND (flag&0x200=0);";
 
-    const std::string REMOVE_DEV_DATA_SQL =
-        "DELETE FROM sync_data WHERE device=? AND (flag&0x02=0) AND (flag&0x100=0);";
+    constexpr const char *REMOVE_DEV_DATA_SQL =
+        "DELETE FROM sync_data WHERE device=? AND (flag&0x02=0);";
 
-    const std::string REMOVE_ALL_DEV_DATA_SQL =
-        "DELETE FROM sync_data WHERE (flag&0x02=0) AND (flag&0x100=0);";
+    constexpr const char *REMOVE_ALL_DEV_DATA_SQL =
+        "DELETE FROM sync_data WHERE (flag&0x02=0);";
 
-    const std::string REMOVE_DEV_DATA_SQL_FROM_CACHEHANDLE =
+    constexpr const char *REMOVE_DEV_DATA_SQL_FROM_CACHEHANDLE =
         "DELETE FROM maindb.sync_data WHERE device=? AND (flag&0x02=0);";
 
-    const std::string REMOVE_ALL_DEV_DATA_SQL_FROM_CACHEHANDLE =
+    constexpr const char *REMOVE_ALL_DEV_DATA_SQL_FROM_CACHEHANDLE =
         "DELETE FROM maindb.sync_data WHERE (flag&0x02=0);";
 
-    const std::string SELECT_ENTRY_DEVICE =
+    constexpr const char *SELECT_ENTRY_DEVICE =
         "SELECT ori_device, device FROM sync_data WHERE key=?;";
 
     // sql for migrating data
-    const std::string MIGRATE_LOCAL_SQL_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_LOCAL_SQL_FROM_CACHEHANDLE =
         "INSERT OR REPLACE INTO maindb.local_data select key, value, timestamp, hash_key from main.local_data;";
-    const std::string MIGRATE_LOCAL_SQL_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_LOCAL_SQL_FROM_MAINHANDLE =
         "INSERT OR REPLACE INTO main.local_data select key, value, timestamp, hash_key from cache.local_data;";
 
-    const std::string MIGRATE_VACUUM_LOCAL_SQL_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_VACUUM_LOCAL_SQL_FROM_CACHEHANDLE =
         "DELETE FROM maindb.local_data where hash_key in (select hash_key FROM maindb.local_data where key is null);";
-    const std::string MIGRATE_VACUUM_LOCAL_SQL_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_VACUUM_LOCAL_SQL_FROM_MAINHANDLE =
         "DELETE FROM main.local_data where hash_key in (select hash_key FROM main.local_data where key is null);";
 
     // version is index, order by better than MIN()
-    const std::string MIGRATE_SELECT_MIN_VER_CACHEDATA_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_SELECT_MIN_VER_CACHEDATA_FROM_CACHEHANDLE =
         "SELECT * FROM sync_data where version = (select version from sync_data order by version limit 1);";
-    const std::string MIGRATE_SELECT_MIN_VER_CACHEDATA_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_SELECT_MIN_VER_CACHEDATA_FROM_MAINHANDLE =
         "SELECT * FROM cache.sync_data where version = (select version from cache.sync_data order by version limit 1);";
 
-    const std::string GET_MAX_VER_CACHEDATA_FROM_CACHEHANDLE =
+    constexpr const char *GET_MAX_VER_CACHEDATA_FROM_CACHEHANDLE =
         "select version from sync_data order by version DESC limit 1;";
-    const std::string GET_MAX_VER_CACHEDATA_FROM_MAINHANDLE =
+    constexpr const char *GET_MAX_VER_CACHEDATA_FROM_MAINHANDLE =
         "select version from cache.sync_data order by version DESC limit 1;";
 
-    const std::string MIGRATE_INSERT_DATA_TO_MAINDB_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_INSERT_DATA_TO_MAINDB_FROM_CACHEHANDLE =
         "INSERT INTO maindb.sync_data VALUES(?,?,?,?,?,?,?,?,?,?);";
-    const std::string MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_CACHEHANDLE =
         "UPDATE maindb.sync_data SET key=?,value=?,timestamp=?,flag=?,device=?,ori_device=?,w_timestamp=?,"
         "modify_time=?,create_time=? WHERE hash_key=?;";
 
-    const std::string MIGRATE_INSERT_DATA_TO_MAINDB_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_INSERT_DATA_TO_MAINDB_FROM_MAINHANDLE =
         "INSERT INTO sync_data VALUES(?,?,?,?,?,?,?,?,?,?);";
-    const std::string MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_UPDATE_DATA_TO_MAINDB_FROM_MAINHANDLE =
         "UPDATE sync_data SET key=?,value=?,timestamp=?,flag=?,device=?,ori_device=?,w_timestamp=?,"
         "modify_time=?,create_time=? WHERE hash_key=?;";
 
-    const std::string MIGRATE_DEL_DATA_BY_VERSION_FROM_CACHEHANDLE =
+    constexpr const char *MIGRATE_DEL_DATA_BY_VERSION_FROM_CACHEHANDLE =
         "DELETE FROM sync_data WHERE version=?;";
-    const std::string MIGRATE_DEL_DATA_BY_VERSION_FROM_MAINHANDLE =
+    constexpr const char *MIGRATE_DEL_DATA_BY_VERSION_FROM_MAINHANDLE =
         "DELETE FROM cache.sync_data WHERE version=?;";
 
-    const std::string SELECT_MAIN_SYNC_HASH_SQL_FROM_CACHEHANDLE = "SELECT * FROM maindb.sync_data WHERE hash_key=?;";
+    constexpr const char *SELECT_MAIN_SYNC_HASH_SQL_FROM_CACHEHANDLE =
+        "SELECT * FROM maindb.sync_data WHERE hash_key=?;";
 
-    const std::string REMOVE_META_VALUE_SQL =
+    constexpr const char *REMOVE_META_VALUE_SQL =
         "DELETE FROM meta_data WHERE key=?;";
-    const std::string REMOVE_ATTACH_META_VALUE_SQL =
+    constexpr const char *REMOVE_ATTACH_META_VALUE_SQL =
         "DELETE FROM meta.meta_data WHERE key=?;";
 
-    const std::string CHECK_DB_INTEGRITY_SQL = "PRAGMA integrity_check;";
+    constexpr const char *CHECK_DB_INTEGRITY_SQL = "PRAGMA integrity_check;";
 
-    const std::string REMOVE_META_VALUE_BY_KEY_PREFIX_SQL =
+    constexpr const char *REMOVE_META_VALUE_BY_KEY_PREFIX_SQL =
         "DELETE FROM meta_data WHERE key>=? AND key<=?;";
-    const std::string REMOVE_ATTACH_META_VALUE_BY_KEY_PREFIX_SQL =
+    constexpr const char *REMOVE_ATTACH_META_VALUE_BY_KEY_PREFIX_SQL =
         "DELETE FROM meta.meta_data WHERE key>=? AND key<=?;";
 
-    const std::string DELETE_SYNC_DATA_WITH_HASHKEY = "DELETE FROM sync_data where hash_key = ?;";
+    constexpr const char *DELETE_SYNC_DATA_WITH_HASHKEY = "DELETE FROM sync_data where hash_key = ?;";
 
-    const std::string DELETE_SYNC_DATA_WITH_HASHKEY_FROM_CACHEHANDLE =
+    constexpr const char *DELETE_SYNC_DATA_WITH_HASHKEY_FROM_CACHEHANDLE =
         "DELETE FROM maindb.sync_data where hash_key = ?;";
 
-    const std::string GET_SYNC_DATA_TIRGGER_SQL =
+    constexpr const char *GET_SYNC_DATA_TIRGGER_SQL =
         "SELECT name FROM SQLITE_MASTER WHERE TYPE = 'trigger' AND TBL_NAME = 'sync_data' AND name like ?;";
 
-    const std::string REMOVE_CLOUD_ALL_LOG_DATA_SQL =
+    constexpr const char *REMOVE_CLOUD_ALL_LOG_DATA_SQL =
         "DELETE FROM naturalbase_kv_aux_sync_data_log;";
 
-    const std::string REMOVE_CLOUD_ALL_DEV_DATA_SQL =
+    constexpr const char *REMOVE_ALL_DEV_SYNC_DATA_SQL =
+        "DELETE FROM sync_data WHERE (flag&0x02=0) AND (flag&0x100=0);";
+
+    constexpr const char *REMOVE_DEV_SYNC_DATA_BY_DEV_ID_SQL =
+        "DELETE FROM sync_data WHERE device=? AND (flag&0x02=0) AND (flag&0x100=0);";
+
+    constexpr const char *REMOVE_CLOUD_ALL_DEV_DATA_SQL =
         "DELETE FROM sync_data WHERE (flag&0x100!=0);";
 
-    const std::string UPDATE_CLOUD_ALL_DEV_DATA_SQL =
+    constexpr const char *UPDATE_CLOUD_ALL_DEV_DATA_SQL =
         "UPDATE sync_data SET flag=(flag|0x02)&(~0x100) WHERE (flag&0x100!=0);";
 
-    const std::string REMOVE_CLOUD_DEV_DATA_BY_DEVID_SQL =
+    constexpr const char *REMOVE_CLOUD_DEV_DATA_BY_DEVID_SQL =
         "DELETE FROM sync_data WHERE device=? AND (flag&0x100!=0);";
 
-    const std::string UPDATE_CLOUD_DEV_DATA_BY_DEVID_SQL =
+    constexpr const char *REMOVE_CLOUD_DEV_DATA_VERSION_BY_DEVID_SQL =
+        "DELETE FROM sync_data WHERE device=? AND key LIKE 'naturalbase_cloud_version_%';";
+
+    constexpr const char *UPDATE_CLOUD_DEV_DATA_BY_DEVID_SQL =
         "UPDATE sync_data SET flag=(flag|0x02)&(~0x100) WHERE device=? AND (flag&0x100!=0);";
 
-    const std::string REMOVE_CLOUD_DEV_DATA_BY_USERID_SQL =
+    constexpr const char *REMOVE_CLOUD_DEV_DATA_BY_USERID_SQL =
         "DELETE FROM sync_data WHERE (flag&0x100!=0) AND hash_key IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log WHERE userid =?);";
 
-    const std::string UPDATE_CLOUD_DEV_DATA_BY_USERID_SQL =
+    constexpr const char *UPDATE_CLOUD_DEV_DATA_BY_USERID_SQL =
         "UPDATE sync_data SET flag=(flag|0x02)&(~0x100) WHERE (flag&0x100!=0) AND hash_key IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log WHERE userid =?);";
 
-    const std::string REMOVE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL =
+    constexpr const char *REMOVE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL =
         "DELETE FROM sync_data WHERE device=? AND (flag&0x100!=0) AND hash_key NOT IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log);";
 
-    const std::string UPDATE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL =
+    constexpr const char *UPDATE_CLOUD_DEV_DATA_BY_DEVID_HASHKEY_NOTIN_SQL =
         "UPDATE sync_data SET flag=(flag|0x02)&(~0x100) WHERE device=? AND (flag&0x100!=0) AND hash_key NOT IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log);";
 
-    const std::string REMOVE_CLOUD_LOG_DATA_BY_DEVID_SQL =
+    constexpr const char *REMOVE_CLOUD_LOG_DATA_BY_DEVID_SQL =
         "DELETE FROM naturalbase_kv_aux_sync_data_log WHERE hash_key IN" \
             "(SELECT hash_key FROM sync_data WHERE device =?);";
 
-    const std::string REMOVE_CLOUD_LOG_DATA_BY_USERID_SQL =
+    constexpr const char *REMOVE_CLOUD_LOG_DATA_BY_USERID_SQL =
         "DELETE FROM naturalbase_kv_aux_sync_data_log WHERE userid =?;";
 
-    const std::string REMOVE_CLOUD_LOG_DATA_BY_USERID_DEVID_SQL =
+    constexpr const char *REMOVE_CLOUD_LOG_DATA_BY_USERID_DEVID_SQL =
         "DELETE FROM naturalbase_kv_aux_sync_data_log WHERE userid =? AND hash_key IN" \
             "(SELECT hash_key FROM sync_data WHERE device =?);";
 
-    const std::string SELECT_CLOUD_LOG_DATA_BY_DEVID_SQL =
+    constexpr const char *SELECT_CLOUD_LOG_DATA_BY_DEVID_SQL =
         "SELECT * FROM naturalbase_kv_aux_sync_data_log WHERE hash_key IN" \
             "(SELECT hash_key FROM sync_data WHERE device =?);";
 
-    const std::string SELECT_CLOUD_LOG_DATA_BY_USERID_DEVID_SQL =
+    constexpr const char *SELECT_CLOUD_LOG_DATA_BY_USERID_DEVID_SQL =
         "SELECT * FROM naturalbase_kv_aux_sync_data_log WHERE userid =? AND hash_key IN" \
             "(SELECT hash_key FROM sync_data WHERE device =?);";
 
     // Check whether the hashKey is the same but the userId is different
-    const std::string SELECT_CLOUD_LOG_DATA_BY_USERID_HASHKEY_SQL =
+    constexpr const char *SELECT_CLOUD_LOG_DATA_BY_USERID_HASHKEY_SQL =
         "SELECT * FROM naturalbase_kv_aux_sync_data_log WHERE userid =? AND hash_key IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log WHERE userid !=?);";
 
-    const std::string SELECT_CLOUD_DEV_DATA_BY_USERID_SQL =
+    constexpr const char *SELECT_CLOUD_DEV_DATA_BY_USERID_SQL =
         "SELECT * FROM sync_data WHERE (flag&0x100!=0) AND hash_key IN" \
             "(SELECT hash_key FROM naturalbase_kv_aux_sync_data_log WHERE userid =?);";
 
-    const std::string REMOVE_CLOUD_ALL_HWM_DATA_SQL =
+    constexpr const char *REMOVE_CLOUD_ALL_HWM_DATA_SQL =
         "DELETE FROM meta_data WHERE KEY LIKE 'naturalbase_cloud_meta_sync_data_%';";
 
-    const std::string REMOVE_CLOUD_HWM_DATA_BY_USERID_SQL =
+    constexpr const char *REMOVE_CLOUD_HWM_DATA_BY_USERID_SQL =
         "DELETE FROM meta_data WHERE KEY =?;";
 
     constexpr const char *UPDATE_SYNC_DATA_KEY_SQL =
@@ -311,10 +329,10 @@ namespace DistributedDB {
     constexpr const char *QUERY_COUNT_HEAD = "SELECT count(1) ";
 
     constexpr const char *QUERY_CLOUD_SYNC_DATA_HEAD = "SELECT key, value, flag, device, ori_device, "
-        "sync_data.hash_key, w_timestamp, modify_time, create_time, cloud_gid, version, sync_data.rowid ";
+        "sync_data.hash_key, w_timestamp, modify_time, create_time, cloud_gid, version, sync_data.rowid, cloud_flag ";
 
     constexpr const char *QUERY_CLOUD_SYNC_DATA_DETAIL = "FROM sync_data LEFT JOIN "
-        "(SELECT userid, cloud_gid, version, hash_key FROM naturalbase_kv_aux_sync_data_log WHERE userid=?)"
+        "(SELECT userid, cloud_gid, version, hash_key, cloud_flag FROM naturalbase_kv_aux_sync_data_log WHERE userid=?)"
         " AS log_table ON sync_data.hash_key = log_table.hash_key ";
 
     constexpr const char *QUERY_CLOUD_SYNC_DATA_CONDITION =
@@ -324,7 +342,7 @@ namespace DistributedDB {
     constexpr const char *QUERY_CLOUD_VERSION_RECORD_CONDITION = "WHERE key = ? AND flag & 0x200 != 0";
 
     constexpr const char *QUERY_CLOUD_SYNC_DATA_LOG = "SELECT sync_data.rowid, flag, device, ori_device, "
-        "modify_time, create_time, cloud_gid, sync_data.hash_key, sync_data.key, version FROM "
+        "modify_time, create_time, cloud_gid, sync_data.hash_key, sync_data.key, version, cloud_flag FROM "
         "sync_data LEFT JOIN naturalbase_kv_aux_sync_data_log ON "
         "sync_data.hash_key = naturalbase_kv_aux_sync_data_log.hash_key ";
 
@@ -336,10 +354,12 @@ namespace DistributedDB {
     constexpr const char *QUERY_CLOUD_VERSION_RECORD_SQL_EMPTY_DEVICE_CONDITION = "AND flag&0x200 != 0";
 
     constexpr const char *INSERT_CLOUD_SYNC_DATA_LOG = "INSERT OR REPLACE INTO naturalbase_kv_aux_sync_data_log "
-        "VALUES(?,?,?,?)";
+        "VALUES(?,?,?,?,?)";
+    constexpr const char *UPSERT_CLOUD_SYNC_DATA_LOG = "INSERT INTO naturalbase_kv_aux_sync_data_log VALUES(?,?,?,?,0)"
+        "ON CONFLICT(userid, hash_key) DO UPDATE SET cloud_gid=?, version=?";
 
     constexpr const char *UPDATE_CLOUD_SYNC_DATA_LOG = "UPDATE naturalbase_kv_aux_sync_data_log SET cloud_gid=?, "
-        "version=? WHERE userid=? AND hash_key=?";
+        "version=?,cloud_flag=? WHERE userid=? AND hash_key=?";
 
     constexpr const char *SET_SYNC_DATA_NO_FORCE_PUSH = "UPDATE sync_data SET flag=flag|0x40 WHERE hash_key=?";
 
@@ -350,6 +370,23 @@ namespace DistributedDB {
     constexpr const char *SELECT_SYNC_ENTRIES_BY_DEVICE_SQL =
         "SELECT key,value FROM sync_data WHERE device=? AND flag&0x200=0";
 
+    constexpr const char *SELECT_COMPENSATE_SYNC_KEY_SQL =
+        "SELECT key FROM sync_data left join naturalbase_kv_aux_sync_data_log as log_table on sync_data.hash_key"
+        "= log_table.hash_key WHERE log_table.cloud_flag=log_table.cloud_flag|0x10";
+
+    constexpr const char *SELECT_CLOUD_GID_SQL =
+        "SELECT cloud_gid FROM sync_data left join naturalbase_kv_aux_sync_data_log as log_table"
+        " on sync_data.hash_key = log_table.hash_key WHERE log_table.userid=?";
+
+    constexpr const char *MARK_UPLOAD_SUCCESS =
+        "UPDATE naturalbase_kv_aux_sync_data_log SET cloud_flag=cloud_flag|0x400 "
+        "WHERE hash_key=? AND userid=? ";
+
+    constexpr const char *CHECK_DATA_CHANGED =
+        "SELECT COUNT(1) FROM sync_data WHERE modify_time=? AND hash_key=?";
+    
+    constexpr const char *NATURALBASE_KV_AUX_SYNC_DATA_LOG_TABLE_NAME = "naturalbase_kv_aux_sync_data_log";
+
     const int BIND_KV_KEY_INDEX = 1;
     const int BIND_KV_VAL_INDEX = 2;
     const int BIND_LOCAL_TIMESTAMP_INDEX = 3;
@@ -426,6 +463,7 @@ namespace DistributedDB {
     constexpr int CLOUD_QUERY_CLOUD_GID_INDEX = 9;
     constexpr int CLOUD_QUERY_VERSION_INDEX = 10;
     constexpr int CLOUD_QUERY_ROW_ID_INDEX = 11;
+    constexpr int CLOUD_QUERY_CLOUD_FLAG_INDEX = 12;
 
     constexpr int CLOUD_QUERY_COUNT_INDEX = 0;
 
@@ -434,7 +472,16 @@ namespace DistributedDB {
 
     constexpr int BIND_CLOUD_VERSION_DEVICE_INDEX = 1;
 
+    constexpr int BIND_INSERT_USER_INDEX = 1;
+    constexpr int BIND_INSERT_HASH_KEY_INDEX = 2;
+    constexpr int BIND_INSERT_CLOUD_GID_INDEX = 3;
+    constexpr int BIND_INSERT_VERSION_INDEX = 4;
+    constexpr int BIND_INSERT_CLOUD_FLAG_INDEX = 5;
+
+    // use in get entries by device sql
     constexpr int BIND_GET_ENTRIES_DEVICE_INDEX = 1;
+    // use in remove cloud flag
+    constexpr int BIND_HASH_KEY_INDEX = 1;
     const Key REMOVE_DEVICE_DATA_KEY = {'r', 'e', 'm', 'o', 'v', 'e'};
 } // namespace DistributedDB
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_storage_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_storage_engine.cpp
index a63dcde736ba482116c799b1f52adbd7e778f256..e9ee5affed337dc86aa05b9d197b5b003e0ec698 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_storage_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_storage_engine.cpp
@@ -15,6 +15,7 @@
 
 #include "sqlite_storage_engine.h"
 
+#include "db_common.h"
 #include "db_errno.h"
 #include "log_print.h"
 #include "sqlite_storage_executor.h"
@@ -38,6 +39,7 @@ int SQLiteStorageEngine::InitSQLiteStorageEngine(const StorageEngineAttr &poolSi
     engineAttr_ = poolSize;
     option_ = option;
     identifier_ = identifier;
+    hashIdentifier_ = DBCommon::TransferStringToHex(identifier_);
     if (GetEngineState() == EngineState::CACHEDB) {
         LOGI("Is alive! not need to create executor, only fix option.");
         return E_OK;
@@ -71,13 +73,13 @@ int SQLiteStorageEngine::CreateNewExecutor(bool isWrite, StorageExecutor *&handl
 {
     sqlite3 *dbHandle = nullptr;
     int errCode = SQLiteUtils::OpenDatabase(option_, dbHandle);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
     bool isMemDb = option_.isMemDb;
-    if (!isUpdated_) {
+    if (!isUpdated_) { // LCOV_EXCL_BR_LINE
         errCode = Upgrade(dbHandle);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             (void)sqlite3_close_v2(dbHandle);
             dbHandle = nullptr;
             return errCode;
@@ -87,7 +89,7 @@ int SQLiteStorageEngine::CreateNewExecutor(bool isWrite, StorageExecutor *&handl
     }
 
     handle = NewSQLiteStorageExecutor(dbHandle, isWrite, isMemDb);
-    if (handle == nullptr) {
+    if (handle == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("New SQLiteStorageExecutor[%d] for the pool failed.", isWrite);
         (void)sqlite3_close_v2(dbHandle);
         dbHandle = nullptr;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
index 4ae58476b5dfbd1e0b5611cfdcea899f47729a2a..de8da22e611583d61946b4a4a6d8c37567cb2cae 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sqlite/sqlite_utils.cpp
@@ -187,7 +187,6 @@ int SQLiteUtils::OpenDatabase(const OpenDbProperties &properties, sqlite3 *&db,
         std::lock_guard<std::mutex> lock(logMutex_);
         if (!g_configLog) {
             sqlite3_config(SQLITE_CONFIG_LOG, &SqliteLogCallback, &properties.createIfNecessary);
-            sqlite3_config(SQLITE_CONFIG_LOOKASIDE, 0, 0);
             g_configLog = true;
         }
     }
@@ -630,16 +629,15 @@ int SQLiteUtils::CreateMetaDatabase(const std::string &metaDbPath)
     OpenDbProperties metaProperties {metaDbPath, true, false};
     sqlite3 *db = nullptr;
     int errCode = SQLiteUtils::OpenDatabase(metaProperties, db);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[CreateMetaDatabase] Failed to create the meta database[%d]", errCode);
     }
-    if (db != nullptr) {
+    if (db != nullptr) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_close_v2(db);
         db = nullptr;
     }
     return errCode;
 }
-
 int SQLiteUtils::CheckIntegrity(sqlite3 *db, const std::string &sql)
 {
     sqlite3_stmt *statement = nullptr;
@@ -996,7 +994,7 @@ int SQLiteUtils::Rekey(sqlite3 *db, const CipherPassword &passwd)
 
 int SQLiteUtils::GetVersion(const OpenDbProperties &properties, int &version)
 {
-    if (properties.uri.empty()) {
+    if (properties.uri.empty()) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
@@ -1004,16 +1002,16 @@ int SQLiteUtils::GetVersion(const OpenDbProperties &properties, int &version)
     // Please make sure the database file exists and is working properly
     std::string fileUrl = DBConstant::SQLITE_URL_PRE + properties.uri;
     int errCode = sqlite3_open_v2(fileUrl.c_str(), &dbTemp, SQLITE_OPEN_URI | SQLITE_OPEN_READONLY, nullptr);
-    if (errCode != SQLITE_OK) {
+    if (errCode != SQLITE_OK) { // LCOV_EXCL_BR_LINE
         errCode = SQLiteUtils::MapSQLiteErrno(errCode);
         LOGE("Open database failed: %d, sys:%d", errCode, errno);
         goto END;
     }
     // in memory mode no need cipher
-    if (!properties.isMemDb) {
+    if (!properties.isMemDb) { // LCOV_EXCL_BR_LINE
         errCode = SQLiteUtils::SetKey(dbTemp, properties.cipherType, properties.passwd, false,
             properties.iterTimes);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("Set key failed: %d", errCode);
             goto END;
         }
@@ -1022,7 +1020,7 @@ int SQLiteUtils::GetVersion(const OpenDbProperties &properties, int &version)
     errCode = GetVersion(dbTemp, version);
 
 END:
-    if (dbTemp != nullptr) {
+    if (dbTemp != nullptr) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_close_v2(dbTemp);
         dbTemp = nullptr;
     }
@@ -1082,26 +1080,26 @@ int SQLiteUtils::GetJournalMode(sqlite3 *db, std::string &mode)
 
 int SQLiteUtils::SetUserVer(const OpenDbProperties &properties, int version)
 {
-    if (properties.uri.empty()) {
+    if (properties.uri.empty()) { // LCOV_EXCL_BR_LINE
         return -E_INVALID_ARGS;
     }
 
     // Please make sure the database file exists and is working properly
     sqlite3 *db = nullptr;
     int errCode = SQLiteUtils::OpenDatabase(properties, db);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         return errCode;
     }
 
     // Set user version
     errCode = SQLiteUtils::SetUserVer(db, version);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("Set user version fail: %d", errCode);
         goto END;
     }
 
 END:
-    if (db != nullptr) {
+    if (db != nullptr) { // LCOV_EXCL_BR_LINE
         (void)sqlite3_close_v2(db);
         db = nullptr;
     }
@@ -1143,6 +1141,8 @@ int SQLiteUtils::MapSQLiteErrno(int errCode)
             return -E_DENIED_SQL;
         case SQLITE_CONSTRAINT:
             return -E_CONSTRAINT;
+        case SQLITE_CANTOPEN:
+            return -E_SQLITE_CANT_OPEN;
         default:
             break;
     }
@@ -1319,12 +1319,12 @@ int SQLiteUtils::ChangeIndex(sqlite3 *db, const IndexName &name, const IndexInfo
 {
     // Currently we change index by drop it then create it, SQLite "REINDEX" may be used in the future
     int errCode = DecreaseIndex(db, name);
-    if (errCode != OK) {
+    if (errCode != E_OK) {
         LOGE("[ChangeIndex] Decrease fail=%d.", errCode);
         return errCode;
     }
     errCode = IncreaseIndex(db, name, info, type, skipSize);
-    if (errCode != OK) {
+    if (errCode != E_OK) {
         LOGE("[ChangeIndex] Increase fail=%d.", errCode);
         return errCode;
     }
@@ -1413,7 +1413,7 @@ void SQLiteUtils::GetRawSysTime(sqlite3_context *ctx, int argc, sqlite3_value **
 
 void SQLiteUtils::GetLastTime(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
-    if (ctx == nullptr || argc != 0 || argv == nullptr) {
+    if (ctx == nullptr || argc != 0 || argv == nullptr) { // LCOV_EXCL_BR_LINE
         LOGE("Parameter does not meet restrictions.");
         return;
     }
@@ -1932,7 +1932,8 @@ void SQLiteUtils::FlatBufferExtractByPath(sqlite3_context *ctx, int argc, sqlite
         return;
     }
     auto schema = static_cast<SchemaObject *>(sqlite3_user_data(ctx));
-    if (schema == nullptr || !schema->IsSchemaValid() || (schema->GetSchemaType() != SchemaType::FLATBUFFER)) {
+    if (schema == nullptr || !schema->IsSchemaValid() ||
+        (schema->GetSchemaType() != SchemaType::FLATBUFFER)) { // LCOV_EXCL_BR_LINE
         sqlite3_result_error(ctx, "[FlatBufferExtract] No SchemaObject or invalid.", USING_STR_LEN);
         LOGE("[FlatBufferExtract] No SchemaObject or invalid.");
         return;
@@ -1940,7 +1941,7 @@ void SQLiteUtils::FlatBufferExtractByPath(sqlite3_context *ctx, int argc, sqlite
     // Get information from argv
     auto valueBlob = static_cast<const uint8_t *>(sqlite3_value_blob(argv[0]));
     int valueBlobLen = sqlite3_value_bytes(argv[0]);
-    if (IsDeleteRecord(valueBlob, valueBlobLen)) {
+    if (IsDeleteRecord(valueBlob, valueBlobLen)) { // LCOV_EXCL_BR_LINE
         // Currently delete records are filtered out of query and create-index sql, so not allowed here.
         sqlite3_result_error(ctx, "[FlatBufferExtract] Delete record not allowed.", USING_STR_LEN);
         LOGE("[FlatBufferExtract] Delete record not allowed.");
@@ -1948,7 +1949,8 @@ void SQLiteUtils::FlatBufferExtractByPath(sqlite3_context *ctx, int argc, sqlite
     }
     auto path = reinterpret_cast<const char *>(sqlite3_value_text(argv[1]));
     int offset = sqlite3_value_int(argv[2]); // index 2 is the third parameter
-    if ((path == nullptr) || (offset < 0) || (static_cast<uint32_t>(offset) != schema->GetSkipSize())) {
+    if ((path == nullptr) || (offset < 0) ||
+        (static_cast<uint32_t>(offset) != schema->GetSkipSize())) { // LCOV_EXCL_BR_LINE
         sqlite3_result_error(ctx, "[FlatBufferExtract] Path null or offset invalid.", USING_STR_LEN);
         LOGE("[FlatBufferExtract] Path null or offset=%d(skipsize=%u) invalid.", offset, schema->GetSkipSize());
         return;
@@ -1970,10 +1972,10 @@ void SQLiteUtils::FlatBufferExtractInnerFunc(sqlite3_context *ctx, const SchemaO
     RawString inPath)
 {
     // All parameter had already been check inside FlatBufferExtractByPath, only called by FlatBufferExtractByPath
-    if (schema.GetSkipSize() % SchemaConstant::SECURE_BYTE_ALIGN == 0) {
+    if (schema.GetSkipSize() % SchemaConstant::SECURE_BYTE_ALIGN == 0) { // LCOV_EXCL_BR_LINE
         TypeValue outExtract;
         int errCode = schema.ExtractValue(ValueSource::FROM_DBFILE, inPath, inValue, outExtract, nullptr);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             sqlite3_result_error(ctx, "[FlatBufferExtract] ExtractValue fail.", USING_STR_LEN);
             LOGE("[FlatBufferExtract] ExtractValue fail, errCode=%d.", errCode);
             return;
@@ -1983,7 +1985,7 @@ void SQLiteUtils::FlatBufferExtractInnerFunc(sqlite3_context *ctx, const SchemaO
     }
     // Not byte-align secure, we have to make a cache for copy. Check whether cache had already exist.
     auto cached = static_cast<std::vector<uint8_t> *>(sqlite3_get_auxdata(ctx, VALUE_CACHE_ID)); // Share the same id
-    if (cached == nullptr) {
+    if (cached == nullptr) { // LCOV_EXCL_BR_LINE
         // Make the cache
         auto newCache = new (std::nothrow) std::vector<uint8_t>;
         if (newCache == nullptr) {
@@ -2000,12 +2002,12 @@ void SQLiteUtils::FlatBufferExtractInnerFunc(sqlite3_context *ctx, const SchemaO
         // See sqlite.org for more information.
         cached = static_cast<std::vector<uint8_t> *>(sqlite3_get_auxdata(ctx, VALUE_CACHE_ID));
     }
-    if (cached == nullptr) {
+    if (cached == nullptr) { // LCOV_EXCL_BR_LINE
         LOGW("[FlatBufferExtract] Something wrong with Auxdata, but it is no matter without cache.");
     }
     TypeValue outExtract;
     int errCode = schema.ExtractValue(ValueSource::FROM_DBFILE, inPath, inValue, outExtract, cached);
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         sqlite3_result_error(ctx, "[FlatBufferExtract] ExtractValue fail.", USING_STR_LEN);
         LOGE("[FlatBufferExtract] ExtractValue fail, errCode=%d.", errCode);
         return;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.cpp
index e25015b8840e666af7400fb7a686daa08944c5e0..698074a21a98630e3c57131c270d1de80f4d08a4 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.cpp
@@ -44,6 +44,21 @@ StorageEngine::~StorageEngine()
     CloseExecutor();
 }
 
+void StorageEngine::CloseAllExecutor()
+{
+    CloseExecutor();
+}
+
+int StorageEngine::InitAllReadWriteExecutor()
+{
+    return InitReadWriteExecutors();
+}
+
+OpenDbProperties StorageEngine::GetOption()
+{
+    return option_;
+}
+
 int StorageEngine::InitReadWriteExecutors()
 {
     int errCode = E_OK;
@@ -219,15 +234,13 @@ void StorageEngine::Recycle(StorageExecutor *&handle)
     if (handle == nullptr) {
         return;
     }
-    std::string id = DBCommon::TransferStringToHex(identifier_);
-    LOGD("Recycle executor[%d] for id[%.6s]", handle->GetWritable(), id.c_str());
+    LOGD("Recycle executor[%d] for id[%.6s]", handle->GetWritable(), hashIdentifier_.c_str());
     if (handle->GetWritable()) {
         std::unique_lock<std::mutex> lock(writeMutex_);
         auto iter = std::find(writeUsingList_.begin(), writeUsingList_.end(), handle);
         if (iter != writeUsingList_.end()) {
             writeUsingList_.remove(handle);
             if (writeIdleList_.size() >= 1) {
-                LOGD("[Recycle] delete handle");
                 delete handle;
                 handle = nullptr;
                 return;
@@ -349,6 +362,7 @@ EngineState StorageEngine::GetEngineState() const
 
 void StorageEngine::SetEngineState(EngineState state)
 {
+    LOGI("Storage engine state to [%d]!", state);
     engineState_ = state;
 }
 
@@ -398,7 +412,6 @@ void StorageEngine::CloseExecutor()
         std::lock_guard<std::mutex> lock(writeMutex_);
         for (auto &item : writeIdleList_) {
             if (item != nullptr) {
-                LOGD("[CloseExecutor] delete item");
                 delete item;
                 item = nullptr;
             }
@@ -441,8 +454,7 @@ StorageExecutor *StorageEngine::FetchStorageExecutor(bool isWrite, std::list<Sto
     auto item = idleList.front();
     usingList.push_back(item);
     idleList.remove(item);
-    LOGD("Get executor[%d] from [%.3s]", isWrite,
-        DBCommon::TransferStringToHex(identifier_).c_str());
+    LOGD("Get executor[%d] from [%.3s]", isWrite, hashIdentifier_.c_str());
     errCode = E_OK;
     return item;
 }
@@ -463,14 +475,13 @@ bool StorageEngine::IsMigrating() const
 void StorageEngine::WaitWriteHandleIdle()
 {
     std::unique_lock<std::mutex> autoLock(idleMutex_);
-    LOGD("Wait wHandle release id[%s]. write[%zu-%zu-%" PRIu32 "]", DBCommon::TransferStringToHex(identifier_).c_str(),
+    LOGD("Wait wHandle release id[%s]. write[%zu-%zu-%" PRIu32 "]", hashIdentifier_.c_str(),
         writeIdleList_.size(), writeUsingList_.size(), engineAttr_.maxWriteNum);
     idleCondition_.wait(autoLock, [this]() {
         return writeUsingList_.empty();
     });
     LOGD("Wait wHandle release finish id[%s]. write[%zu-%zu-%" PRIu32 "]",
-        DBCommon::TransferStringToHex(identifier_).c_str(), writeIdleList_.size(), writeUsingList_.size(),
-        engineAttr_.maxWriteNum);
+        hashIdentifier_.c_str(), writeIdleList_.size(), writeUsingList_.size(), engineAttr_.maxWriteNum);
 }
 
 void StorageEngine::IncreaseCacheRecordVersion()
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.h b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.h
index 096a311e1de52f0c15fdcc5644f32b063dfc3711..ba119ebbab2f100c87ee066eedc26188b2990cbd 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine.h
@@ -89,6 +89,12 @@ public:
 
     virtual void SetSchemaChangedCallback(const std::function<int(void)> &callback);
 
+    void CloseAllExecutor();
+
+    int InitAllReadWriteExecutor();
+
+    OpenDbProperties GetOption();
+
 protected:
     virtual int CreateNewExecutor(bool isWrite, StorageExecutor *&handle) = 0;
 
@@ -106,6 +112,7 @@ protected:
     bool isUpdated_;
     std::atomic<bool> isMigrating_;
     std::string identifier_;
+    std::string hashIdentifier_;
 
     // Mutex for commitNotifyFunc_.
     mutable std::shared_mutex notifyMutex_;
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine_manager.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine_manager.cpp
index c6a35b2beec089a5fc01cbb6f4c6edf791e77d57..474b348bfa47add8301ad3f6f6b2a9fa91f73625 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/storage_engine_manager.cpp
@@ -173,7 +173,7 @@ int StorageEngineManager::RegisterLockStatusListener()
                 return;
             }
             int taskErrCode = RuntimeContext::GetInstance()->ScheduleTask(
-                std::bind(&StorageEngineManager::LockStatusNotifier, this, isLocked));
+                [this, isLocked] { LockStatusNotifier(isLocked); });
             if (taskErrCode != E_OK) {
                 LOGE("[StorageEngineManager] LockStatusNotifier ScheduleTask failed : %d", taskErrCode);
             }
@@ -202,6 +202,7 @@ StorageEngine *CreateSingleVerStorageEngine(int databaseType)
     }
     return nullptr;
 }
+
 StorageEngine *StorageEngineManager::CreateStorageEngine(const KvDBProperties &property, int &errCode)
 {
     int databaseType = GetDatabaseType(property);
@@ -266,7 +267,7 @@ void StorageEngineManager::ReleaseResources(const std::string &identifier)
 
     if (storageEngine != nullptr) {
         LOGI("[StorageEngineManager] Release storage engine");
-        delete storageEngine;
+        RefObject::KillAndDecObjRef(storageEngine);
     }
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp
index 80f6606541aa76ef46187f4c97850e27b8e4a4a1..e6455d83b9b66cfc06cc41a75df3147aac1b4621 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/storage_proxy.cpp
@@ -65,7 +65,7 @@ int StorageProxy::GetLocalWaterMark(const std::string &tableName, Timestamp &loc
     return cloudMetaData_->GetLocalWaterMark(AppendWithUserIfNeed(tableName), localMark);
 }
 
-int StorageProxy::GetLocalWaterMarkByMode(const std::string &tableName, Timestamp &localMark, CloudWaterType mode)
+int StorageProxy::GetLocalWaterMarkByMode(const std::string &tableName, CloudWaterType mode, Timestamp &localMark)
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (cloudMetaData_ == nullptr) {
@@ -91,7 +91,7 @@ int StorageProxy::PutLocalWaterMark(const std::string &tableName, Timestamp &loc
     return cloudMetaData_->SetLocalWaterMark(AppendWithUserIfNeed(tableName), localMark);
 }
 
-int StorageProxy::PutWaterMarkByMode(const std::string &tableName, Timestamp &localMark, CloudWaterType mode)
+int StorageProxy::PutWaterMarkByMode(const std::string &tableName, CloudWaterType mode, Timestamp &localMark)
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (cloudMetaData_ == nullptr) {
@@ -186,11 +186,7 @@ int StorageProxy::GetUploadCount(const QuerySyncObject &query, const bool isClou
         }
         timeStampVec.push_back(tmpMark);
     }
-    int errCode = store_->GetAllUploadCount(query, timeStampVec, isCloudForcePush, isCompensatedTask, count);
-    if (errCode != E_OK) {
-        return errCode;
-    }
-    return E_OK;
+    return store_->GetAllUploadCount(query, timeStampVec, isCloudForcePush, isCompensatedTask, count);
 }
 
 int StorageProxy::GetUploadCount(const std::string &tableName, const Timestamp &localMark,
@@ -559,7 +555,7 @@ int StorageProxy::SetIAssetLoader(const std::shared_ptr<IAssetLoader> &loader)
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (store_ == nullptr) {
-        return E_INVALID_DB;
+        return -E_INVALID_DB;
     }
     return store_->SetIAssetLoader(loader);
 }
@@ -568,7 +564,7 @@ int StorageProxy::UpdateRecordFlag(const std::string &tableName, bool recordConf
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (store_ == nullptr) {
-        return E_INVALID_DB;
+        return -E_INVALID_DB;
     }
     return store_->UpdateRecordFlag(tableName, recordConflict, logInfo);
 }
@@ -577,7 +573,7 @@ int StorageProxy::GetCompensatedSyncQuery(std::vector<QuerySyncObject> &syncQuer
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (store_ == nullptr) {
-        return E_INVALID_DB;
+        return -E_INVALID_DB;
     }
     return store_->GetCompensatedSyncQuery(syncQuery);
 }
@@ -587,7 +583,7 @@ int StorageProxy::MarkFlagAsConsistent(const std::string &tableName, const Downl
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (store_ == nullptr) {
-        return E_INVALID_DB;
+        return -E_INVALID_DB;
     }
     return store_->MarkFlagAsConsistent(tableName, downloadData, gidFilters);
 }
@@ -627,7 +623,7 @@ int StorageProxy::GetCloudDbSchema(std::shared_ptr<DataBaseSchema> &cloudSchema)
 {
     std::shared_lock<std::shared_mutex> readLock(storeMutex_);
     if (store_ == nullptr) {
-        return E_INVALID_DB;
+        return -E_INVALID_DB;
     }
     return store_->GetCloudDbSchema(cloudSchema);
 }
@@ -658,4 +654,30 @@ bool StorageProxy::IsTableExistReference(const std::string &table)
     }
     return store_->IsTableExistReference(table);
 }
+
+bool StorageProxy::IsTableExistReferenceOrReferenceBy(const std::string &table)
+{
+    std::shared_lock<std::shared_mutex> readLock(storeMutex_);
+    if (store_ == nullptr) {
+        return false;
+    }
+    return store_->IsTableExistReferenceOrReferenceBy(table);
+}
+
+void StorageProxy::ReleaseUploadRecord(const std::string &table, const CloudWaterType &type, Timestamp localWaterMark)
+{
+    std::shared_lock<std::shared_mutex> readLock(storeMutex_);
+    if (store_ == nullptr) {
+        return;
+    }
+    store_->ReleaseUploadRecord(table, type, localWaterMark);
+}
+
+bool StorageProxy::IsSameCloudLocalDeviceAndNotLocal(const LogInfo &localInfo, const LogInfo &cloudInfo)
+{
+    if (store_ == nullptr) {
+        return false;
+    }
+    return store_->IsSameCloudLocalDeviceAndNotLocal(localInfo, cloudInfo);
+}
 }
diff --git a/kv_store/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp b/kv_store/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
index ab0717c55dd8d30ef4361a247b887933951cd1a2..620302ddd7d222532bbffdc43372d90ebc98a99f 100644
--- a/kv_store/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/storage/src/sync_able_engine.cpp
@@ -120,13 +120,13 @@ int SyncAbleEngine::StartSyncerWithNoLock(bool isCheckSyncActive, bool isNeedAct
     if (isSyncDualTupleMode && isCheckSyncActive && !isNeedActive && (userChangeListener_ == nullptr)) {
         // active to non_active
         userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-            std::bind(&SyncAbleEngine::ChangeUserListener, this), UserChangeMonitor::USER_ACTIVE_TO_NON_ACTIVE_EVENT);
+            [this](void *) { ChangeUserListener(); }, UserChangeMonitor::USER_ACTIVE_TO_NON_ACTIVE_EVENT);
         LOGI("[StartSyncerWithNoLock] [%.3s] After RegisterUserChangedListener", label.c_str());
     } else if (isSyncDualTupleMode && (userChangeListener_ == nullptr)) {
         EventType event = isNeedActive ?
             UserChangeMonitor::USER_ACTIVE_EVENT : UserChangeMonitor::USER_NON_ACTIVE_EVENT;
         userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-            std::bind(&SyncAbleEngine::UserChangeHandle, this), event);
+            [this](void *) { UserChangeHandle(); }, event);
         LOGI("[StartSyncerWithNoLock] [%.3s] After RegisterUserChangedListener event=%d", label.c_str(), event);
     }
     return errCode;
@@ -197,7 +197,7 @@ void SyncAbleEngine::ChangeUserListener()
         userChangeListener_ = nullptr;
     }
     userChangeListener_ = RuntimeContext::GetInstance()->RegisterUserChangedListener(
-        std::bind(&SyncAbleEngine::UserChangeHandle, this), UserChangeMonitor::USER_NON_ACTIVE_EVENT);
+        [this](void *) { UserChangeHandle(); }, UserChangeMonitor::USER_NON_ACTIVE_EVENT);
     std::string label = store_->GetDbProperties().GetStringProp(DBProperties::IDENTIFIER_DATA, "");
     LOGI("[ChangeUserListener] [%.3s] After RegisterUserChangedListener", label.c_str());
 }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/include/isyncer.h b/kv_store/frameworks/libs/distributeddb/syncer/include/isyncer.h
index 8b87b3ec847a818e7ac7cf27bb7c7fe6f5ec97e1..61e0c44c45d67af9056ab480c021ef6501b2d4bb 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/include/isyncer.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/include/isyncer.h
@@ -44,6 +44,7 @@ public:
         bool wait = false;
         bool isQuerySync = false;
         QuerySyncObject syncQuery;
+        DeviceSyncProcessCallback onSyncProcess;
     };
 
     virtual ~ISyncer() {};
@@ -67,6 +68,9 @@ public:
     // Sync function. use SyncParma to reduce parameter.
     virtual int Sync(const SyncParma &param, uint64_t connectionId) = 0;
 
+    // Cancel sync function.
+    virtual int CancelSync(uint32_t syncId) = 0;
+
     // Remove the operation, with the given syncId, used to clean resource if sync finished or failed.
     virtual int RemoveSyncOperation(int syncId) = 0;
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h b/kv_store/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
index e1a4b33d98979bbfc125e5154a84bb1beec16643..0f6d5bc7dd7d471e03e6a019a4407b0d9adffbba 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/include/syncer_proxy.h
@@ -48,6 +48,9 @@ public:
     // Sync function. use SyncParma to reduce parameter.
     int Sync(const SyncParma &param, uint64_t connectionId) override;
 
+    // Cancel sync function.
+    int CancelSync(uint32_t syncId) override;
+
     // Remove the operation, with the given syncId, used to clean resource if sync finished or failed.
     int RemoveSyncOperation(int syncId) override;
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp
index 89215ff5e9440f5bba8f302d7b44e1bfd79e326f..3632ff4e56b60173a27f0a6d5f8e3143c4f508db 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 #include "cloud_db_proxy.h"
+#include "cloud/cloud_db_constant.h"
+#include "db_common.h"
 #include "db_errno.h"
 #include "log_print.h"
 
@@ -33,6 +35,12 @@ void CloudDBProxy::SetCloudDB(const std::shared_ptr<ICloudDb> &cloudDB)
 int CloudDBProxy::SetCloudDB(const std::map<std::string, std::shared_ptr<ICloudDb>> &cloudDBs)
 {
     std::unique_lock<std::shared_mutex> writeLock(cloudMutex_);
+    for (const auto &item : cloudDBs) {
+        if (item.second == nullptr) {
+            LOGE("[CloudDBProxy] User %s setCloudDB with nullptr", item.first.c_str());
+            return -E_INVALID_ARGS;
+        }
+    }
     cloudDbs_ = cloudDBs;
     return E_OK;
 }
@@ -121,6 +129,15 @@ int CloudDBProxy::Query(const std::string &tableName, VBucket &extend, std::vect
     context->SetTableName(tableName);
     int errCode = InnerAction(context, cloudDb, QUERY);
     context->MoveOutQueryExtendAndData(extend, data);
+    for (auto &item : data) {
+        for (auto &row : item) {
+            auto assets = std::get_if<Assets>(&row.second);
+            if (assets == nullptr) {
+                continue;
+            }
+            DBCommon::RemoveDuplicateAssetsData(*assets);
+        }
+    }
     return errCode;
 }
 
@@ -156,11 +173,10 @@ int CloudDBProxy::Close()
     std::vector<std::shared_ptr<ICloudDb>> waitForClose;
     {
         std::unique_lock<std::shared_mutex> writeLock(cloudMutex_);
-        if (iCloudDb_ == nullptr) {
-            return E_OK;
+        if (iCloudDb_ != nullptr) {
+            iCloudDb = iCloudDb_;
+            iCloudDb_ = nullptr;
         }
-        iCloudDb = iCloudDb_;
-        iCloudDb_ = nullptr;
         for (const auto &item : cloudDbs_) {
             if (iCloudDb == item.second) {
                 iCloudDb = nullptr;
@@ -178,6 +194,9 @@ int CloudDBProxy::Close()
         DBStatus ret = item->Close();
         status = (status == OK ? ret : status);
     }
+    if (status != OK) {
+        LOGW("[CloudDBProxy] cloud db close failed %d", static_cast<int>(status));
+    }
     waitForClose.clear();
     LOGD("[CloudDBProxy] call cloudDb close end");
     return status == OK ? E_OK : -E_CLOUD_ERROR;
@@ -204,14 +223,14 @@ bool CloudDBProxy::IsNotExistCloudDB() const
 int CloudDBProxy::Download(const std::string &tableName, const std::string &gid, const Type &prefix,
     std::map<std::string, Assets> &assets)
 {
+    if (assets.empty()) {
+        return E_OK;
+    }
     std::shared_lock<std::shared_mutex> readLock(assetLoaderMutex_);
     if (iAssetLoader_ == nullptr) {
         LOGE("Asset loader has not been set %d", -E_NOT_SET);
         return -E_NOT_SET;
     }
-    if (assets.empty()) {
-        return E_OK;
-    }
     DBStatus status = iAssetLoader_->Download(tableName, gid, prefix, assets);
     if (status != OK) {
         LOGW("[CloudDBProxy] download asset failed %d", static_cast<int>(status));
@@ -221,12 +240,34 @@ int CloudDBProxy::Download(const std::string &tableName, const std::string &gid,
 
 int CloudDBProxy::RemoveLocalAssets(const std::vector<Asset> &assets)
 {
+    if (assets.empty()) {
+        return E_OK;
+    }
+    std::shared_lock<std::shared_mutex> readLock(assetLoaderMutex_);
+    if (iAssetLoader_ == nullptr) {
+        LOGW("Asset loader has not been set");
+        return E_OK;
+    }
+    DBStatus status = iAssetLoader_->RemoveLocalAssets(assets);
+    if (status != OK) {
+        LOGE("[CloudDBProxy] remove local asset failed %d", static_cast<int>(status));
+        return -E_REMOVE_ASSETS_FAILED;
+    }
+    return E_OK;
+}
+
+int CloudDBProxy::RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix,
+    std::map<std::string, Assets> &assets)
+{
+    if (assets.empty()) {
+        return E_OK;
+    }
     std::shared_lock<std::shared_mutex> readLock(assetLoaderMutex_);
     if (iAssetLoader_ == nullptr) {
         LOGE("Asset loader has not been set %d", -E_NOT_SET);
         return -E_NOT_SET;
     }
-    DBStatus status = iAssetLoader_->RemoveLocalAssets(assets);
+    DBStatus status = iAssetLoader_->RemoveLocalAssets(tableName, gid, prefix, assets);
     if (status != OK) {
         LOGE("[CloudDBProxy] remove local asset failed %d", static_cast<int>(status));
         return -E_REMOVE_ASSETS_FAILED;
@@ -267,22 +308,24 @@ DBStatus CloudDBProxy::DMLActionTask(const std::shared_ptr<CloudActionContext> &
     std::vector<VBucket> record;
     std::vector<VBucket> extend;
     context->MoveOutRecordAndExtend(record, extend);
-    size_t dataSize = extend.size();
 
     switch (action) {
         case INSERT: {
             status = cloudDb->BatchInsert(context->GetTableName(), std::move(record), extend);
-            context->MoveInExtend(extend);
+            context->MoveInRecordAndExtend(record, extend);
+            context->SetInfo(CloudWaterType::INSERT, status);
             break;
         }
         case UPDATE: {
             status = cloudDb->BatchUpdate(context->GetTableName(), std::move(record), extend);
-            context->MoveInExtend(extend);
+            context->MoveInRecordAndExtend(record, extend);
+            context->SetInfo(CloudWaterType::UPDATE, status);
             break;
         }
         case DELETE: {
             status = cloudDb->BatchDelete(context->GetTableName(), extend);
-            context->MoveInExtend(extend);
+            context->MoveInRecordAndExtend(record, extend);
+            context->SetInfo(CloudWaterType::DELETE, status);
             break;
         }
         default: {
@@ -290,15 +333,10 @@ DBStatus CloudDBProxy::DMLActionTask(const std::shared_ptr<CloudActionContext> &
             return INVALID_ARGS;
         }
     }
-    if (status == OK) {
-        context->SetInfo(dataSize, dataSize, 0u);
-    } else {
-        if (status == CLOUD_VERSION_CONFLICT) {
-            LOGI("[CloudSyncer] Version conflict during cloud batch upload.");
-        } else {
-            LOGE("[CloudSyncer] Cloud BATCH UPLOAD failed.");
-        }
-        context->SetInfo(dataSize, 0u, dataSize);
+    if (status == CLOUD_VERSION_CONFLICT) {
+        LOGI("[CloudSyncer] Version conflict during cloud batch upload.");
+    } else if (status != OK) {
+        LOGE("[CloudSyncer] Cloud BATCH UPLOAD failed.");
     }
     return status;
 }
@@ -381,6 +419,9 @@ DBStatus CloudDBProxy::InnerActionGetEmptyCursor(const std::shared_ptr<CloudActi
 
 int CloudDBProxy::GetInnerErrorCode(DBStatus status)
 {
+    if (status < DB_ERROR || status >= BUTT_STATUS) {
+        return static_cast<int>(status);
+    }
     switch (status) {
         case OK:
             return E_OK;
@@ -517,12 +558,64 @@ Info CloudDBProxy::CloudActionContext::GetInfo()
     return info;
 }
 
-void CloudDBProxy::CloudActionContext::SetInfo(uint32_t totalCount,
-    uint32_t successCount, uint32_t failedCount)
+bool CloudDBProxy::CloudActionContext::IsEmptyAssetId(const Assets &assets)
 {
-    totalCount_ = totalCount;
-    successCount_ = successCount;
-    failedCount_ = failedCount;
+    for (auto &asset : assets) {
+        if (asset.assetId.empty()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool CloudDBProxy::CloudActionContext::IsRecordActionFail(const VBucket &extend, bool isInsert, DBStatus status)
+{
+    if (extend.count(CloudDbConstant::GID_FIELD) == 0) {
+        return true;
+    }
+    if (status != OK) {
+        if (DBCommon::IsRecordError(extend) ||
+            (!DBCommon::IsRecordSuccess(extend) && !DBCommon::IsRecordIgnored(extend) &&
+            !DBCommon::IsRecordVersionConflict(extend))) {
+            return true;
+        }
+    }
+    auto gid = std::get_if<std::string>(&extend.at(CloudDbConstant::GID_FIELD));
+    if (gid == nullptr || (isInsert && (*gid).empty())) {
+        return true;
+    }
+    for (auto &entry : extend) {
+        auto asset = std::get_if<Asset>(&entry.second);
+        if (asset != nullptr && (*asset).assetId.empty()) {
+            return true;
+        }
+        auto assets = std::get_if<Assets>(&entry.second);
+        if (assets != nullptr && IsEmptyAssetId(*assets)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void CloudDBProxy::CloudActionContext::SetInfo(const CloudWaterType &type, DBStatus status)
+{
+    totalCount_ = record_.size();
+
+    // records_ size should be equal to extend_ or batch data failed.
+    if (record_.size() != extend_.size()) {
+        failedCount_ += record_.size();
+        return;
+    }
+    for (auto &extend : extend_) {
+        if (DBCommon::IsNeedCompensatedForUpload(extend, type)) {
+            continue;
+        }
+        if (IsRecordActionFail(extend, type == CloudWaterType::INSERT, status)) {
+            failedCount_++;
+        } else {
+            successCount_++;
+        }
+    }
 }
 
 void CloudDBProxy::CloudActionContext::SetTableName(const std::string &tableName)
@@ -565,4 +658,4 @@ std::pair<int, std::string> CloudDBProxy::GetCloudVersion(const std::string &ori
     LOGI("[CloudDBProxy] End get cloud version");
     return {E_OK, version};
 }
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h
index 56a65fef3f05deee0a06bf1ed75ac16d085559cc..c1a306e172ac0a132eb8519e6e1de0fc8c5ae8c8 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_db_proxy.h
@@ -19,6 +19,8 @@
 #include <condition_variable>
 #include <mutex>
 #include <shared_mutex>
+#include "cloud/cloud_db_types.h"
+#include "cloud/cloud_db_types.h"
 #include "cloud/icloud_db.h"
 #include "cloud/iAssetLoader.h"
 
@@ -66,6 +68,9 @@ public:
 
     int RemoveLocalAssets(const std::vector<Asset> &assets);
 
+    int RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix,
+        std::map<std::string, Assets> &assets);
+
     void SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback);
 
     bool IsExistCloudVersionCallback() const;
@@ -103,12 +108,16 @@ protected:
 
         Info GetInfo();
 
-        void SetInfo(uint32_t totalCount, uint32_t successCount, uint32_t failedCount);
+        void SetInfo(const CloudWaterType &type, DBStatus status);
 
         void SetTableName(const std::string &tableName);
 
         std::string GetTableName();
     private:
+        static bool IsEmptyAssetId(const Assets &assets);
+
+        static bool IsRecordActionFail(const VBucket &extend, bool isInsert, DBStatus status);
+
         std::mutex actionMutex_;
         std::condition_variable actionCv_;
         bool actionFinished_;
@@ -137,13 +146,13 @@ protected:
         // add action code before INVALID_ACTION
         INVALID_ACTION
     };
-    int InnerAction(const std::shared_ptr<CloudActionContext> &context,
+    static int InnerAction(const std::shared_ptr<CloudActionContext> &context,
         const std::shared_ptr<ICloudDb> &cloudDb, InnerActionCode action);
 
     static DBStatus DMLActionTask(const std::shared_ptr<CloudActionContext> &context,
         const std::shared_ptr<ICloudDb> &cloudDb, InnerActionCode action);
 
-    void InnerActionTask(const std::shared_ptr<CloudActionContext> &context,
+    static void InnerActionTask(const std::shared_ptr<CloudActionContext> &context,
         const std::shared_ptr<ICloudDb> &cloudDb, InnerActionCode action);
 
     static DBStatus InnerActionLock(const std::shared_ptr<CloudActionContext> &context,
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.cpp
index d5959e709c0a462b79bc7df9a264aaf630ec2e2b..1a5f0981cd1dd4e08c4a61954634a7662106843e 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.cpp
@@ -17,7 +17,8 @@
 
 namespace DistributedDB {
 
-OpType CloudForcePullStrategy::TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo)
+OpType CloudForcePullStrategy::TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+    const LogInfo &cloudInfo)
 {
     if (CloudStorageUtils::IsDataLocked(localInfo.status)) {
         return OpType::LOCKED_NOT_HANDLE;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.h
index 66f5fcd2128835e1a15d31ebb1c610eef2a1939e..225befd47ddb5fdcf7bd7ed2fa8d1e119a4b010c 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_pull_strategy.h
@@ -19,7 +19,8 @@
 namespace DistributedDB {
 class CloudForcePullStrategy : public CloudSyncStrategy {
 public:
-    OpType TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo) override;
+    OpType TagSyncDataStatus(bool existInLocal, bool isSameDeviceNotLocal, const LogInfo &localInfo,
+        const LogInfo &cloudInfo) override;
 
     bool JudgeUpdateCursor() override;
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.cpp
index ca99cedd0f399ece996a699d934e9262c6c9631c..b5b503cf23e1e559d44ab2c0da193dac007734d0 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.cpp
@@ -17,7 +17,8 @@
 
 namespace DistributedDB {
 const std::string cloud_device_name = "cloud";
-OpType CloudForcePushStrategy::TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo)
+OpType CloudForcePushStrategy::TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+    const LogInfo &cloudInfo)
 {
     if (CloudStorageUtils::IsDataLocked(localInfo.status)) {
         return OpType::LOCKED_NOT_HANDLE;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.h
index 8543d3f9a3dc95b5a815aee5fe68666eb5680e6d..8064b3c301d4c0f9bf7c888e44afc64f72751b65 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_force_push_strategy.h
@@ -19,7 +19,8 @@
 namespace DistributedDB {
 class CloudForcePushStrategy : public CloudSyncStrategy {
 public:
-    OpType TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo) override;
+    OpType TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+        const LogInfo &cloudInfo) override;
 
     bool JudgeUpdateCursor() override;
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.cpp
index cdb4a481117ef7509b83101ddb44a902edeaee8b..978a55ca87da52061c20e6fcb9df7b2c585f724e 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.cpp
@@ -17,24 +17,25 @@
 
 namespace DistributedDB {
 
-OpType CloudMergeStrategy::TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo)
+OpType CloudMergeStrategy::TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+    const LogInfo &cloudInfo)
 {
+    bool isCloudDelete = IsDelete(cloudInfo);
+    bool isLocalDelete = IsDelete(localInfo);
+    if (isSameCurDevice) {
+        return TagCloudUpdateLocal(localInfo, cloudInfo, isCloudDelete, isLocalDelete);
+    }
     if (CloudStorageUtils::IsDataLocked(localInfo.status)) {
         return OpType::LOCKED_NOT_HANDLE;
     }
-    bool isCloudDelete = IsDelete(cloudInfo);
-    bool isLocalDelete = IsDelete(localInfo);
     if (!existInLocal) {
-        // when cloud data is deleted, we think it is different data
-        if (isCloudDelete) {
-            return OpType::NOT_HANDLE;
-        }
-        return OpType::INSERT;
+        return TagLocalNotExist(isCloudDelete);
     }
     if (IsIgnoreUpdate(localInfo)) {
         return OpType::NOT_HANDLE;
     }
-    if (localInfo.timestamp > cloudInfo.timestamp) {
+    if ((localInfo.flag & static_cast<uint64_t>(LogInfoFlag::FLAG_LOCAL)) != 0 &&
+        localInfo.timestamp > cloudInfo.timestamp) {
         return TagLocallyNewer(localInfo, cloudInfo, isCloudDelete, isLocalDelete);
     }
     if (isCloudDelete) {
@@ -49,6 +50,9 @@ OpType CloudMergeStrategy::TagSyncDataStatus(bool existInLocal, const LogInfo &l
     if (isTimeSame && (localInfo.cloudGid.empty() || cloudInfo.sharingResource != localInfo.sharingResource)) {
         return OpType::ONLY_UPDATE_GID;
     }
+    if (!localInfo.isNeedUpdateAsset && IsSameRecord(cloudInfo, localInfo)) {
+        return OpType::NOT_HANDLE;
+    }
     return TagUpdateLocal(cloudInfo, localInfo);
 }
 
@@ -76,4 +80,25 @@ OpType CloudMergeStrategy::TagLocallyNewer(const LogInfo &localInfo, const LogIn
     }
     return OpType::NOT_HANDLE;
 }
+
+OpType CloudMergeStrategy::TagCloudUpdateLocal(const LogInfo &localInfo, const LogInfo &cloudInfo,
+    bool isCloudDelete, bool isLocalDelete)
+{
+    if (isCloudDelete) {
+        return isLocalDelete ? OpType::UPDATE_TIMESTAMP : OpType::DELETE;
+    }
+    if (isLocalDelete) {
+        return OpType::INSERT;
+    }
+    return TagUpdateLocal(cloudInfo, localInfo);
+}
+
+OpType CloudMergeStrategy::TagLocalNotExist(bool isCloudDelete)
+{
+    // when cloud data is deleted, we think it is different data
+        if (isCloudDelete) {
+            return OpType::NOT_HANDLE;
+        }
+        return OpType::INSERT;
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.h
index 9f99a87404acc14ea22a4893739326c25e5c46ea..dc0e6888a39d6cc5aabafb265d5f54dac95a4191 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_merge_strategy.h
@@ -23,13 +23,19 @@ public:
     CloudMergeStrategy() = default;
     ~CloudMergeStrategy() override = default;
 
-    OpType TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo) override;
+    OpType TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+        const LogInfo &cloudInfo) override;
 
     bool JudgeUpdateCursor() override;
 
     bool JudgeUpload() override;
 private:
     OpType TagLocallyNewer(const LogInfo &localInfo, const LogInfo &cloudInfo, bool isCloudDelete, bool isLocalDelete);
+
+    OpType TagCloudUpdateLocal(const LogInfo &localInfo, const LogInfo &cloudInfo, bool isCloudDelete,
+        bool isLocalDelete);
+
+    OpType TagLocalNotExist(bool isCloudDelete);
 };
 }
 #endif // DIFFERENTIAL_STRATEGY_H
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.cpp
index e79b0ae15aa39d3792ed63000a465fb032a6db2c..5048082931967af17712715312b332cf4a1e38c0 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include "cloud_sync_strategy.h"
+#include "cloud/cloud_db_constant.h"
 
 namespace DistributedDB {
 CloudSyncStrategy::CloudSyncStrategy() : policy_(SingleVerConflictResolvePolicy::DEFAULT_LAST_WIN)
@@ -24,7 +25,7 @@ void CloudSyncStrategy::SetConflictResolvePolicy(SingleVerConflictResolvePolicy
     policy_ = policy;
 }
 
-OpType CloudSyncStrategy::TagSyncDataStatus([[gnu::unused]] bool existInLocal,
+OpType CloudSyncStrategy::TagSyncDataStatus([[gnu::unused]] bool existInLocal, [[gnu::unused]] bool isSameCurDevice,
     [[gnu::unused]] const LogInfo &localInfo, [[gnu::unused]] const LogInfo &cloudInfo)
 {
     return OpType::NOT_HANDLE;
@@ -59,20 +60,34 @@ bool CloudSyncStrategy::IsSameVersion(const LogInfo &cloudInfo, const LogInfo &l
     return (cloudInfo.version == localInfo.version);
 }
 
-bool CloudSyncStrategy::IsIgnoreUpdate(const LogInfo &localInfo)
+bool CloudSyncStrategy::IsIgnoreUpdate(const LogInfo &localInfo) const
 {
     if (policy_ == SingleVerConflictResolvePolicy::DEFAULT_LAST_WIN) {
         return false;
     }
+    if ((localInfo.flag & static_cast<uint64_t>(LogInfoFlag::FLAG_LOCAL)) == 0 && IsDelete(localInfo)) {
+        LOGW("[CloudSyncStrategy] dont ignore %.6s", localInfo.cloudGid.c_str());
+        return false;
+    }
     if (localInfo.originDev.empty() && localInfo.device.empty()) {
-        LOGW("[CloudSyncStrategy] %.3s was ignored override", localInfo.cloudGid.c_str());
+        LOGW("[CloudSyncStrategy] %.6s was ignored override", localInfo.cloudGid.c_str());
         return true;
     }
     return false;
 }
 
-OpType CloudSyncStrategy::TagUpdateLocal(const LogInfo &cloudInfo, const LogInfo &localInfo)
+OpType CloudSyncStrategy::TagUpdateLocal(const LogInfo &cloudInfo, const LogInfo &localInfo) const
 {
     return IsIgnoreUpdate(localInfo) ? OpType::NOT_HANDLE : OpType::UPDATE;
 }
+
+bool CloudSyncStrategy::IsSameRecord(const LogInfo &cloudInfo, const LogInfo &localInfo)
+{
+    // avoid compensated and unlock record miss update
+    return (localInfo.flag & static_cast<uint64_t>(LogInfoFlag::FLAG_WAIT_COMPENSATED_SYNC)) == 0 &&
+        localInfo.status == static_cast<uint32_t>(LockStatus::UNLOCK) &&
+        !localInfo.version.empty() && localInfo.version == cloudInfo.version &&
+        std::abs(static_cast<int64_t>(cloudInfo.timestamp - localInfo.timestamp)) <
+        static_cast<int64_t>(CloudDbConstant::ONE_SECOND);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.h
index 1af3a2013528583e236f5173b16eb7a9705ecfe5..a4d55f6a97fdea7c6d2af4362cf8780dedde9c16 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_strategy.h
@@ -29,7 +29,8 @@ public:
 
     void SetConflictResolvePolicy(SingleVerConflictResolvePolicy policy);
 
-    virtual OpType TagSyncDataStatus(bool existInLocal, const LogInfo &localInfo, const LogInfo &cloudInfo);
+    virtual OpType TagSyncDataStatus(bool existInLocal, bool isSameCurDevice, const LogInfo &localInfo,
+        const LogInfo &cloudInfo);
 
     virtual bool JudgeUpdateCursor();
 
@@ -39,12 +40,13 @@ public:
 
     static bool IsLogNeedUpdate(const LogInfo &cloudInfo, const LogInfo &localInfo);
 
+    OpType TagUpdateLocal(const LogInfo &cloudInfo, const LogInfo &localInfo) const;
 protected:
     static bool IsSameVersion(const LogInfo &cloudInfo, const LogInfo &localInfo);
 
-    bool IsIgnoreUpdate(const LogInfo &localInfo);
+    bool IsIgnoreUpdate(const LogInfo &localInfo) const;
 
-    OpType TagUpdateLocal(const LogInfo &cloudInfo, const LogInfo &localInfo);
+    bool IsSameRecord(const LogInfo &cloudInfo, const LogInfo &localInfo);
 
     SingleVerConflictResolvePolicy policy_;
 };
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp
index 0b19450d9b86a35dd2263f55f3b4c810fa2ca1e8..bf23f2c9a1bc4b62c7d9765bc29d5e1d86bff53c 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.cpp
@@ -124,10 +124,10 @@ bool IsDataContainField(const std::string &assetFieldName, const VBucket &data)
     return true;
 }
 
-void TagAssetWithSameHash(const bool isNormalStatus, Asset &beCoveredAsset, Asset &coveredAsset, Assets &res,
+void TagAssetWithSameHash(const bool setNormalStatus, Asset &beCoveredAsset, Asset &coveredAsset, Assets &res,
     int &errCode)
 {
-    TagAssetWithNormalStatus(isNormalStatus, (
+    TagAssetWithNormalStatus(setNormalStatus, (
         AssetOperationUtils::EraseBitMask(beCoveredAsset.status) == AssetStatus::DELETE ||
         AssetOperationUtils::EraseBitMask(beCoveredAsset.status) == AssetStatus::ABNORMAL ||
         beCoveredAsset.status == (AssetStatus::DOWNLOADING | DOWNLOAD_WITH_NULL)) ?
@@ -264,24 +264,26 @@ Assets TagAsset(const std::string &assetFieldName, VBucket &coveredData, VBucket
     return res;
 }
 
-void MarkAssetForUpload(Asset &asset, bool isInsert)
+void MarkAssetForUpload(bool isInsert, Asset &asset)
 {
-    uint32_t newStatus = static_cast<uint32_t>(AssetStatus::NORMAL);
     uint32_t lowBitStatus = AssetOperationUtils::EraseBitMask(asset.status);
     if (lowBitStatus == AssetStatus::DELETE) {
         asset.flag = static_cast<uint32_t>(AssetOpType::DELETE);
     } else if (isInsert) {
         asset.flag = static_cast<uint32_t>(AssetOpType::INSERT);
+        lowBitStatus = static_cast<uint32_t>(AssetStatus::INSERT);
     } else if (asset.status == AssetStatus::NORMAL) {
         asset.flag = static_cast<uint32_t>(AssetOpType::NO_CHANGE);
     } else if (asset.assetId.empty()) {
         asset.flag = static_cast<uint32_t>(AssetOpType::INSERT);
+        lowBitStatus = static_cast<uint32_t>(AssetStatus::INSERT);
     } else if (!asset.assetId.empty()) {
         asset.flag = static_cast<uint32_t>(AssetOpType::UPDATE);
+        lowBitStatus = static_cast<uint32_t>(AssetStatus::UPDATE);
     } else {
         asset.flag = static_cast<uint32_t>(AssetOpType::NO_CHANGE);
     }
-    asset.status = newStatus;
+    asset.status = lowBitStatus;
     Timestamp timestamp;
     int errCode = OS::GetCurrentSysTimeInMicrosecond(timestamp);
     if (errCode != E_OK) {
@@ -291,24 +293,24 @@ void MarkAssetForUpload(Asset &asset, bool isInsert)
     asset.timestamp = static_cast<int64_t>(timestamp / CloudDbConstant::TEN_THOUSAND);
 }
 
-void TagAssetsForUpload(const std::string &filedName, VBucket &coveredData, bool isInsert)
+void TagAssetsForUpload(const std::string &filedName, bool isInsert, VBucket &coveredData)
 {
     if (!IsDataContainField<Assets>(filedName, coveredData)) {
         return;
     }
     Assets &covered = std::get<Assets>(GetAssetsCaseInsensitive(filedName, coveredData));
     for (auto &asset: covered) {
-        MarkAssetForUpload(asset, isInsert);
+        MarkAssetForUpload(isInsert, asset);
     }
 }
 
-void TagAssetForUpload(const std::string &filedName, VBucket &coveredData, bool isInsert)
+void TagAssetForUpload(const std::string &filedName, bool isInsert, VBucket &coveredData)
 {
     if (!IsDataContainField<Asset>(filedName, coveredData)) {
         return;
     }
     Asset &asset = std::get<Asset>(GetAssetsCaseInsensitive(filedName, coveredData));
-    MarkAssetForUpload(asset, isInsert);
+    MarkAssetForUpload(isInsert, asset);
 }
 } // namespace
 
@@ -343,15 +345,15 @@ Type &GetAssetsCaseInsensitive(const std::string &assetFieldName, VBucket &vBuck
     return vBucket[assetFieldName];
 }
 
-void TagAssetsInSingleCol(const Field &assetField, VBucket &coveredData, bool isInsert)
+void TagAssetsInSingleCol(const Field &assetField, bool isInsert, VBucket &coveredData)
 {
     switch (assetField.type) {
         case TYPE_INDEX<Assets>: {
-            TagAssetsForUpload(assetField.colName, coveredData, isInsert);
+            TagAssetsForUpload(assetField.colName, isInsert, coveredData);
             break;
         }
         case TYPE_INDEX<Asset>: {
-            TagAssetForUpload(assetField.colName, coveredData, isInsert);
+            TagAssetForUpload(assetField.colName, isInsert, coveredData);
             break;
         }
         default:
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h
index cdea9a05f9788f11ce90e3d39c3add0d2bb14e6c..bde28d8128886b9dbc91b1fdb44bad3e2a589606 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_tag_assets.h
@@ -31,6 +31,6 @@ namespace DistributedDB {
 Assets TagAssetsInSingleCol(
     VBucket &coveredData, VBucket &beCoveredData, const Field &assetField, bool setNormalStatus, int &errCode);
 Type &GetAssetsCaseInsensitive(const std::string &assetFieldName, VBucket &vBucket);
-void TagAssetsInSingleCol(const Field &assetField, VBucket &coveredData, bool isInsert);
+void TagAssetsInSingleCol(const Field &assetField, bool isInsert, VBucket &coveredData);
 } // namespace DistributedDB
 #endif // CLOUD_SYNC_TAG_ASSETS_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp
index 43fd64344d597c0fc4381262d9e1253a23a2ae49..1d88bc6865c7be37217f11283749e9eb9d6d2526 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.cpp
@@ -25,7 +25,7 @@ int CloudSyncUtils::GetCloudPkVals(const VBucket &datum, const std::vector<std::
     std::vector<Type> &cloudPkVals)
 {
     if (!cloudPkVals.empty()) {
-        LOGE("[CloudSyncer] Output paramater should be empty");
+        LOGE("[CloudSyncer] Output parameter should be empty");
         return -E_INVALID_ARGS;
     }
     for (const auto &pkColName : pkColNames) {
@@ -186,6 +186,7 @@ LogInfo CloudSyncUtils::GetCloudLogInfo(DistributedDB::VBucket &datum)
     cloudLogInfo.wTimestamp = (Timestamp)std::get<int64_t>(datum[CloudDbConstant::CREATE_FIELD]);
     cloudLogInfo.flag = (std::get<bool>(datum[CloudDbConstant::DELETE_FIELD])) ? 1u : 0u;
     cloudLogInfo.cloudGid = std::get<std::string>(datum[CloudDbConstant::GID_FIELD]);
+    CloudStorageUtils::GetStringFromCloudData(CloudDbConstant::CLOUD_KV_FIELD_DEVICE, datum, cloudLogInfo.device);
     (void)CloudStorageUtils::GetValueFromVBucket<std::string>(CloudDbConstant::SHARING_RESOURCE_FIELD,
         datum, cloudLogInfo.sharingResource);
     (void)CloudStorageUtils::GetValueFromVBucket<std::string>(CloudDbConstant::VERSION_FIELD,
@@ -212,7 +213,7 @@ int CloudSyncUtils::SaveChangedDataByType(const VBucket &datum, ChangedData &cha
 }
 
 int CloudSyncUtils::CheckCloudSyncDataValid(const CloudSyncData &uploadData, const std::string &tableName,
-    const int64_t &count, uint64_t &taskId)
+    int64_t count)
 {
     size_t insRecordLen = uploadData.insData.record.size();
     size_t insExtendLen = uploadData.insData.extend.size();
@@ -259,7 +260,7 @@ int CloudSyncUtils::GetWaterMarkAndUpdateTime(std::vector<VBucket> &extend, Time
             return -E_INTERNAL_ERROR;
         }
         if (TYPE_INDEX<int64_t> != extendData.at(CloudDbConstant::MODIFY_FIELD).index()) {
-            LOGE("[CloudSyncer] VBucket's MODIFY_FIELD doestn't fit int64_t.");
+            LOGE("[CloudSyncer] VBucket's MODIFY_FIELD doesn't fit int64_t.");
             return -E_INTERNAL_ERROR;
         }
         if (extendData.empty() || extendData.find(CloudDbConstant::CREATE_FIELD) == extendData.end()) {
@@ -267,7 +268,7 @@ int CloudSyncUtils::GetWaterMarkAndUpdateTime(std::vector<VBucket> &extend, Time
             return -E_INTERNAL_ERROR;
         }
         if (TYPE_INDEX<int64_t> != extendData.at(CloudDbConstant::CREATE_FIELD).index()) {
-            LOGE("[CloudSyncer] VBucket's CREATE_FIELD doestn't fit int64_t.");
+            LOGE("[CloudSyncer] VBucket's CREATE_FIELD doesn't fit int64_t.");
             return -E_INTERNAL_ERROR;
         }
         waterMark = std::max(int64_t(waterMark), std::get<int64_t>(extendData.at(CloudDbConstant::MODIFY_FIELD)));
@@ -302,7 +303,7 @@ void CloudSyncUtils::ModifyCloudDataTime(DistributedDB::VBucket &data)
 int CloudSyncUtils::UpdateExtendTime(CloudSyncData &uploadData, const int64_t &count, uint64_t taskId,
     Timestamp &waterMark)
 {
-    int ret = CloudSyncUtils::CheckCloudSyncDataValid(uploadData, uploadData.tableName, count, taskId);
+    int ret = CloudSyncUtils::CheckCloudSyncDataValid(uploadData, uploadData.tableName, count);
     if (ret != E_OK) {
         LOGE("[CloudSyncer] Invalid Sync Data when get local water mark.");
         return ret;
@@ -392,8 +393,6 @@ int CloudSyncUtils::SaveChangedData(ICloudSyncer::SyncParam &param, size_t dataI
                 param.withoutRowIdData.updateData.emplace_back(dataIndex,
                     param.changedData.primaryData[ChangeType::OP_UPDATE].size());
             }
-        } else {
-            LOGW("[CloudSyncer] deletePrimaryKeySet ignore opType %d.", opType);
         }
     }
     // INSERT: for no primary key or composite primary key situation
@@ -404,15 +403,18 @@ int CloudSyncUtils::SaveChangedData(ICloudSyncer::SyncParam &param, size_t dataI
     switch (opType) {
         // INSERT: only for single primary key situation
         case OpType::INSERT:
+            param.info.downLoadInfo.insertCount++;
             return CloudSyncUtils::SaveChangedDataByType(
                 param.downloadData.data[dataIndex], param.changedData, dataInfo.localInfo, ChangeType::OP_INSERT);
         case OpType::UPDATE:
+            param.info.downLoadInfo.updateCount++;
             if (CloudSyncUtils::NeedSaveData(dataInfo.localInfo.logInfo, dataInfo.cloudLogInfo)) {
                 return CloudSyncUtils::SaveChangedDataByType(param.downloadData.data[dataIndex], param.changedData,
                     dataInfo.localInfo, ChangeType::OP_UPDATE);
             }
             return E_OK;
         case OpType::DELETE:
+            param.info.downLoadInfo.deleteCount++;
             return CloudSyncUtils::SaveChangedDataByType(param.downloadData.data[dataIndex], param.changedData,
                 dataInfo.localInfo, ChangeType::OP_DELETE);
         default:
@@ -427,7 +429,20 @@ void CloudSyncUtils::ClearWithoutData(ICloudSyncer::SyncParam &param)
     param.withoutRowIdData.assetInsertData.clear();
 }
 
-int CloudSyncUtils::FillAssetIdToAssets(CloudSyncBatch &data, int errorCode)
+bool CloudSyncUtils::IsSkipAssetsMissingRecord(const std::vector<VBucket> &extend)
+{
+    if (extend.empty()) {
+        return false;
+    }
+    for (size_t i = 0; i < extend.size(); ++i) {
+        if (DBCommon::IsIntTypeRecordError(extend[i]) && !DBCommon::IsRecordAssetsMissing(extend[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int CloudSyncUtils::FillAssetIdToAssets(CloudSyncBatch &data, int errorCode, const CloudWaterType &type)
 {
     if (data.extend.size() != data.assets.size()) {
         LOGE("[CloudSyncUtils] size not match, extend:%zu assets:%zu.", data.extend.size(), data.assets.size());
@@ -435,29 +450,32 @@ int CloudSyncUtils::FillAssetIdToAssets(CloudSyncBatch &data, int errorCode)
     }
     int errCode = E_OK;
     for (size_t i = 0; i < data.assets.size(); i++) {
-        if (data.assets[i].empty()) {
-            continue;
-        }
-        if (errorCode != E_OK && DBCommon::IsRecordError(data.extend[i])) {
-            continue;
-        }
-        if (DBCommon::IsRecordIgnored(data.extend[i])) {
+        if (data.assets[i].empty() || DBCommon::IsRecordIgnored(data.extend[i]) ||
+            (errorCode != E_OK &&
+                (DBCommon::IsRecordError(data.extend[i]) || DBCommon::IsRecordAssetsMissing(data.extend[i]))) ||
+            DBCommon::IsNeedCompensatedForUpload(data.extend[i], type)) {
+            if (errCode != E_OK && DBCommon::IsRecordAssetsMissing(data.extend[i])) {
+                LOGI("[CloudSyncUtils][FileAssetIdToAssets] errCode with assets missing, skip fill assets id");
+            }
             continue;
         }
-        for (auto &[col, value] : data.assets[i]) {
+        for (auto it = data.assets[i].begin(); it != data.assets[i].end();) {
+            auto &[col, value] = *it;
             if (!CheckIfContainsInsertAssets(value)) {
+                ++it;
                 continue;
             }
             auto extendIt = data.extend[i].find(col);
             if (extendIt == data.extend[i].end()) {
-                LOGE("[CloudSyncUtils] Asset field name can not find in extend.");
-                errCode = -E_CLOUD_ERROR;
+                LOGI("[CloudSyncUtils] Asset field name can not find in extend. key is:%s.", col.c_str());
+                it = data.assets[i].erase(it);
                 continue;
             }
             if (extendIt->second.index() != value.index()) {
                 LOGE("[CloudSyncUtils] Asset field type not same. extend:%zu, data:%zu",
                     extendIt->second.index(), value.index());
                 errCode = -E_CLOUD_ERROR;
+                ++it;
                 continue;
             }
             int ret = FillAssetIdToAssetData(extendIt->second, value);
@@ -465,6 +483,7 @@ int CloudSyncUtils::FillAssetIdToAssets(CloudSyncBatch &data, int errorCode)
                 LOGE("[CloudSyncUtils] fail to fill assetId, %d.", ret);
                 errCode = -E_CLOUD_ERROR;
             }
+            ++it;
         }
     }
     return errCode;
@@ -484,20 +503,17 @@ int CloudSyncUtils::FillAssetIdToAssetData(const Type &extend, Type &assetData)
         std::get<Asset>(assetData).assetId = std::get<Asset>(extend).assetId;
     }
     if (extend.index() == TYPE_INDEX<Assets>) {
-        int errCode = FillAssetIdToAssetsData(std::get<Assets>(extend), std::get<Assets>(assetData));
-        if (errCode != E_OK) {
-            LOGE("[CloudSyncUtils][FillAssetIdToAssetData] Failed to fill assetId to Assets, %d.", errCode);
-            return errCode;
-        }
+        FillAssetIdToAssetsData(std::get<Assets>(extend), std::get<Assets>(assetData));
     }
     return E_OK;
 }
 
-int CloudSyncUtils::FillAssetIdToAssetsData(const Assets &extend, Assets &assets)
+void CloudSyncUtils::FillAssetIdToAssetsData(const Assets &extend, Assets &assets)
 {
-    int errCode = E_OK;
-    for (auto &asset : assets) {
+    for (auto it = assets.begin(); it != assets.end();) {
+        auto &asset = *it;
         if (asset.flag != static_cast<uint32_t>(AssetOpType::INSERT)) {
+            ++it;
             continue;
         }
         auto extendAssets = extend;
@@ -510,11 +526,12 @@ int CloudSyncUtils::FillAssetIdToAssetsData(const Assets &extend, Assets &assets
             }
         }
         if (!isAssetExisted) {
-            LOGE("[CloudSyncUtils][FillAssetIdToAssets] Assets name can not find in extend.");
-            errCode = -E_CLOUD_ERROR;
+            LOGI("Unable to sync local asset, skip fill assetId.");
+            it = assets.erase(it);
+        } else {
+            ++it;
         }
     }
-    return errCode;
 }
 
 bool CloudSyncUtils::CheckIfContainsInsertAssets(const Type &assetData)
@@ -594,11 +611,33 @@ CloudSyncer::CloudTaskInfo CloudSyncUtils::InitCompensatedSyncTaskInfo()
     CloudSyncer::CloudTaskInfo taskInfo;
     taskInfo.priorityTask = true;
     taskInfo.timeout = CloudDbConstant::CLOUD_DEFAULT_TIMEOUT;
-    taskInfo.devices.push_back(CloudDbConstant::DEFAULT_CLOUD_DEV);
     taskInfo.mode = SyncMode::SYNC_MODE_CLOUD_MERGE;
     taskInfo.callback = nullptr;
     taskInfo.compensatedTask = true;
-    taskInfo.users.push_back("");
     return taskInfo;
 }
-}
\ No newline at end of file
+
+CloudSyncer::CloudTaskInfo CloudSyncUtils::InitCompensatedSyncTaskInfo(const CloudSyncOption &option,
+    const SyncProcessCallback &onProcess)
+{
+    CloudSyncer::CloudTaskInfo taskInfo = InitCompensatedSyncTaskInfo();
+    taskInfo.callback = onProcess;
+    taskInfo.devices = option.devices;
+    if (option.users.empty()) {
+        taskInfo.users.push_back("");
+    } else {
+        taskInfo.users = option.users;
+    }
+    return taskInfo;
+}
+
+CloudSyncer::CloudTaskInfo CloudSyncUtils::InitCompensatedSyncTaskInfo(const CloudSyncer::CloudTaskInfo &oriTaskInfo)
+{
+    CloudSyncer::CloudTaskInfo taskInfo = InitCompensatedSyncTaskInfo();
+    taskInfo.lockAction = oriTaskInfo.lockAction;
+    taskInfo.users = oriTaskInfo.users;
+    taskInfo.devices = oriTaskInfo.devices;
+    taskInfo.storeId = oriTaskInfo.storeId;
+    return taskInfo;
+}
+}
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h
index 68aa2346de415b0898dbbb25c1e16ab4f1b76110..1569891ef32d929da96be01639023d857ad8eed5 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_sync_utils.h
@@ -62,8 +62,7 @@ public:
     static int SaveChangedDataByType(const VBucket &datum, ChangedData &changedData, const DataInfoWithLog &localInfo,
         ChangeType type);
 
-    static int CheckCloudSyncDataValid(const CloudSyncData &uploadData, const std::string &tableName,
-        const int64_t &count, uint64_t &taskId);
+    static int CheckCloudSyncDataValid(const CloudSyncData &uploadData, const std::string &tableName, int64_t count);
 
     static void ClearCloudSyncData(CloudSyncData &uploadData);
 
@@ -84,11 +83,13 @@ public:
 
     static void ClearWithoutData(ICloudSyncer::SyncParam &param);
 
-    static int FillAssetIdToAssets(CloudSyncBatch &data, int errorCode);
+    static bool IsSkipAssetsMissingRecord(const std::vector<VBucket> &extend);
+
+    static int FillAssetIdToAssets(CloudSyncBatch &data, int errorCode, const CloudWaterType &type);
 
     static int FillAssetIdToAssetData(const Type &extend, Type &assetData);
 
-    static int FillAssetIdToAssetsData(const Assets &extend, Assets &assets);
+    static void FillAssetIdToAssetsData(const Assets &extend, Assets &assets);
 
     static bool CheckIfContainsInsertAssets(const Type &assetData);
 
@@ -97,9 +98,14 @@ public:
     static OpType CalOpType(ICloudSyncer::SyncParam &param, size_t dataIndex);
 
     static CloudSyncer::CloudTaskInfo InitCompensatedSyncTaskInfo();
+
+    static CloudSyncer::CloudTaskInfo InitCompensatedSyncTaskInfo(const CloudSyncOption &option,
+        const SyncProcessCallback &onProcess);
+
+    static CloudSyncer::CloudTaskInfo InitCompensatedSyncTaskInfo(const CloudSyncer::CloudTaskInfo &oriTaskInfo);
 private:
     static void InsertOrReplaceChangedDataByType(ChangeType type, std::vector<Type> &pkVal,
         ChangedData &changedData);
 };
 }
-#endif // CLOUD_SYNC_UTILS_H
\ No newline at end of file
+#endif // CLOUD_SYNC_UTILS_H
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp
index dee07b3ef19fb76cc2c13cd166b1f9c6db049934..c880084ccadcba251d8658d0db11c29505830423 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.cpp
@@ -15,8 +15,8 @@
 #include "cloud_syncer.h"
 
 #include <cstdint>
-#include <utility>
 #include <unordered_map>
+#include <utility>
 
 #include "cloud/asset_operation_utils.h"
 #include "cloud/cloud_db_constant.h"
@@ -228,7 +228,6 @@ int CloudSyncer::DoSync(TaskId taskId)
         std::lock_guard<std::mutex> autoLock(dataLock_);
         taskInfo = cloudTaskInfos_[taskId];
     }
-    storageProxy_->SetCloudTaskConfig({ !taskInfo.priorityTask });
     bool needUpload = true;
     bool isNeedFirstDownload = false;
     {
@@ -266,7 +265,7 @@ int CloudSyncer::DoSync(TaskId taskId)
         currentContext_.isFirstDownload = isFirstDownload;
         currentContext_.isRealNeedUpload = needUpload;
     }
-    errCode = DoSyncInner(taskInfo, needUpload, isFirstDownload);
+    errCode = DoSyncInner(taskInfo);
     return errCode;
 }
 
@@ -289,7 +288,8 @@ int CloudSyncer::PrepareAndUpload(const CloudTaskInfo &taskInfo, size_t index)
     if (errCode == -E_CLOUD_VERSION_CONFLICT) {
         {
             std::lock_guard<std::mutex> autoLock(dataLock_);
-            currentContext_.isDownloadFinished[currentContext_.currentUserIndex][taskInfo.table[index]] = false;
+            currentContext_.processRecorder->MarkDownloadFinish(currentContext_.currentUserIndex,
+                taskInfo.table[index], false);
             LOGI("[CloudSyncer] upload version conflict, index:%zu", index);
         }
         return errCode;
@@ -311,12 +311,19 @@ int CloudSyncer::DoUploadInNeed(const CloudTaskInfo &taskInfo, const bool needUp
         LOGE("[CloudSyncer] start transaction failed before doing upload.");
         return errCode;
     }
-    for (size_t i = GetStartTableIndex(taskInfo.taskId, true); i < taskInfo.table.size(); ++i) {
+    for (size_t i = 0u; i < taskInfo.table.size(); ++i) {
         LOGD("[CloudSyncer] try upload table, index: %zu", i);
+        if (IsTableFinishInUpload(taskInfo.table[i])) {
+            continue;
+        }
         errCode = PrepareAndUpload(taskInfo, i);
+        if (errCode == -E_TASK_PAUSED) { // should re download paused table
+            MarkDownloadFinishIfNeed(taskInfo.table[i], false);
+        }
         if (errCode != E_OK) {
             break;
         }
+        MarkUploadFinishIfNeed(taskInfo.table[i]);
     }
     if (errCode == -E_TASK_PAUSED) {
         std::lock_guard<std::mutex> autoLock(dataLock_);
@@ -435,7 +442,7 @@ CloudSyncEvent CloudSyncer::SyncMachineDoFinished()
     return CloudSyncEvent::ALL_TASK_FINISHED_EVENT;
 }
 
-int CloudSyncer::DoSyncInner(const CloudTaskInfo &taskInfo, const bool needUpload, bool isFirstDownload)
+int CloudSyncer::DoSyncInner(const CloudTaskInfo &taskInfo)
 {
     cloudSyncStateMachine_.SwitchStateAndStep(CloudSyncEvent::START_SYNC_EVENT);
     DBDfxAdapter::ReportBehavior(
@@ -925,8 +932,8 @@ bool CloudSyncer::NeedNotifyChangedData(const ChangedData &changedData)
     // when there have no data been changed, it don't need fill back
     if (changedData.primaryData[OP_INSERT].empty() && changedData.primaryData[OP_UPDATE].empty() &&
         changedData.primaryData[OP_DELETE].empty()) {
-            return false;
-        }
+        return false;
+    }
     return true;
 }
 
@@ -1013,7 +1020,7 @@ int CloudSyncer::SaveDataInTransaction(CloudSyncer::TaskId taskId, SyncParam &pa
 
 int CloudSyncer::DoDownloadAssets(bool skipSave, SyncParam &param)
 {
-    // Begin dowloading assets
+    // Begin downloading assets
     ChangedData changedAssets;
     int ret = DownloadAssets(param.info, param.pkColNames, param.dupHashKeySet, changedAssets);
     bool isSharedTable = false;
@@ -1026,7 +1033,7 @@ int CloudSyncer::DoDownloadAssets(bool skipSave, SyncParam &param)
         (void)NotifyChangedData(std::move(changedAssets));
     }
     if (ret == -E_TASK_PAUSED) {
-        LOGD("[CloudSyncer] current task was paused, abort dowload asset");
+        LOGD("[CloudSyncer] current task was paused, abort download asset");
         std::lock_guard<std::mutex> autoLock(dataLock_);
         resumeTaskInfos_[currentContext_.currentTaskId].skipQuery = true;
         return ret;
@@ -1057,7 +1064,9 @@ int CloudSyncer::SaveDataNotifyProcess(CloudSyncer::TaskId taskId, SyncParam &pa
         param.downloadData.opType.resize(param.downloadData.data.size());
         param.downloadData.existDataKey.resize(param.downloadData.data.size());
         param.downloadData.existDataHashKey.resize(param.downloadData.data.size());
+        (void)storageProxy_->CreateTempSyncTrigger(param.tableName);
         ret = SaveDataInTransaction(taskId, param);
+        (void)storageProxy_->ClearAllTempSyncTrigger();
         if (ret != E_OK) {
             return ret;
         }
@@ -1100,10 +1109,13 @@ int CloudSyncer::DoDownload(CloudSyncer::TaskId taskId, bool isFirstDownload)
         LOGE("[CloudSyncer] get sync param for download failed %d", errCode);
         return errCode;
     }
-    (void)storageProxy_->CreateTempSyncTrigger(param.tableName);
     errCode = DoDownloadInner(taskId, param, isFirstDownload);
-    (void)storageProxy_->ClearAllTempSyncTrigger();
     if (errCode == -E_TASK_PAUSED) {
+        // No need to handle ret.
+        int ret = storageProxy_->GetCloudWaterMark(param.tableName, param.cloudWaterMark);
+        if (ret != E_OK) {
+            LOGE("[DoDownload] Cannot get cloud watermark : %d.", ret);
+        }
         std::lock_guard<std::mutex> autoLock(dataLock_);
         resumeTaskInfos_[taskId].syncParam = std::move(param);
     }
@@ -1227,12 +1239,13 @@ int CloudSyncer::DoBatchUpload(CloudSyncData &uploadData, UploadParam &uploadPar
 int CloudSyncer::PutWaterMarkAfterBatchUpload(const std::string &tableName, UploadParam &uploadParam)
 {
     int errCode = E_OK;
+    storageProxy_->ReleaseUploadRecord(tableName, uploadParam.mode, uploadParam.localMark);
     // if we use local cover cloud strategy, it won't update local water mark also.
     if (IsModeForcePush(uploadParam.taskId) || (IsPriorityTask(uploadParam.taskId) &&
         !IsQueryListEmpty(uploadParam.taskId))) {
         return E_OK;
     }
-    errCode = storageProxy_->PutWaterMarkByMode(tableName, uploadParam.localMark, uploadParam.mode);
+    errCode = storageProxy_->PutWaterMarkByMode(tableName, uploadParam.mode, uploadParam.localMark);
     if (errCode != E_OK) {
         LOGE("[CloudSyncer] Cannot set local water mark while Uploading, %d.", errCode);
     }
@@ -1287,16 +1300,12 @@ int CloudSyncer::PreProcessBatchUpload(UploadParam &uploadParam, const InnerProc
         return ret;
     }
     ret = CloudSyncUtils::CheckCloudSyncDataValid(uploadData, innerProcessInfo.tableName,
-        innerProcessInfo.upLoadInfo.total, uploadParam.taskId);
+        innerProcessInfo.upLoadInfo.total);
     if (ret != E_OK) {
         LOGE("[CloudSyncer] Invalid Cloud Sync Data of Upload, %d.", ret);
         return ret;
     }
-    ret = TagUploadAssets(uploadData);
-    if (ret != E_OK) {
-        LOGE("TagUploadAssets report ERROR, cannot tag uploadAssets");
-        return ret;
-    }
+    TagUploadAssets(uploadData);
     CloudSyncUtils::UpdateAssetsFlag(uploadData);
     // get local water mark to be updated in future.
     ret = CloudSyncUtils::UpdateExtendTime(uploadData, innerProcessInfo.upLoadInfo.total,
@@ -1359,33 +1368,6 @@ bool CloudSyncer::IsPriorityTask(TaskId taskId)
     return cloudTaskInfos_[taskId].priorityTask;
 }
 
-int CloudSyncer::DoUploadByMode(const std::string &tableName, UploadParam &uploadParam, InnerProcessInfo &info)
-{
-    ContinueToken continueStmtToken = nullptr;
-    CloudSyncData uploadData(tableName, uploadParam.mode);
-    SetUploadDataFlag(uploadParam.taskId, uploadData);
-    auto [err, localWater] = GetLocalWater(tableName, uploadParam);
-    if (err != E_OK) {
-        return err;
-    }
-    int ret = storageProxy_->GetCloudData(GetQuerySyncObject(tableName), localWater, continueStmtToken, uploadData);
-    if ((ret != E_OK) && (ret != -E_UNFINISHED)) {
-        LOGE("[CloudSyncer] Failed to get cloud data when upload, %d.", ret);
-        return ret;
-    }
-    uploadParam.count -= uploadData.ignoredCount;
-    info.upLoadInfo.total -= static_cast<uint32_t>(uploadData.ignoredCount);
-    ret = HandleBatchUpload(uploadParam, info, uploadData, continueStmtToken);
-    if (ret != -E_TASK_PAUSED) {
-        // reset watermark to zero when task no paused
-        RecordWaterMark(uploadParam.taskId, 0u);
-    }
-    if (continueStmtToken != nullptr) {
-        storageProxy_->ReleaseContinueToken(continueStmtToken);
-    }
-    return ret;
-}
-
 int CloudSyncer::PreHandleData(VBucket &datum, const std::vector<std::string> &pkColNames)
 {
     // type index of field in fields, true means mandatory filed
@@ -1519,6 +1501,7 @@ int CloudSyncer::PrepareSync(TaskId taskId)
         currentContext_.strategy = StrategyFactory::BuildSyncStrategy(cloudTaskInfos_[taskId].mode, policy_);
         currentContext_.notifier->Init(cloudTaskInfos_[taskId].table, cloudTaskInfos_[taskId].devices,
             cloudTaskInfos_[taskId].users);
+        currentContext_.processRecorder = std::make_shared<ProcessRecorder>();
     }
     LOGI("[CloudSyncer] exec storeId %.3s taskId %" PRIu64, cloudTaskInfos_[taskId].storeId.c_str(), taskId);
     return E_OK;
@@ -1544,8 +1527,7 @@ int CloudSyncer::LockCloud(TaskId taskId)
 int CloudSyncer::UnlockCloud()
 {
     FinishHeartBeatTimer();
-    int errCode = cloudDB_.UnLock();
-    return errCode;
+    return cloudDB_.UnLock();
 }
 
 int CloudSyncer::StartHeartBeatTimer(int period, TaskId taskId)
@@ -1754,8 +1736,10 @@ int CloudSyncer::TagStatusByStrategy(bool isExist, SyncParam &param, DataInfo &d
             LOGE("[CloudSyncer] strategy has not been set when tag status, %d.", -E_INTERNAL_ERROR);
             return -E_INTERNAL_ERROR;
         }
-        strategyOpResult = currentContext_.strategy->TagSyncDataStatus(isExist, dataInfo.localInfo.logInfo,
+        bool isSameCurDevice = storageProxy_->IsSameCloudLocalDeviceAndNotLocal(dataInfo.localInfo.logInfo,
             dataInfo.cloudLogInfo);
+        strategyOpResult = currentContext_.strategy->TagSyncDataStatus(
+            isExist, isSameCurDevice, dataInfo.localInfo.logInfo, dataInfo.cloudLogInfo);
     }
     if (strategyOpResult == OpType::DELETE) {
         param.deletePrimaryKeySet.insert(dataInfo.localInfo.logInfo.hashKey);
@@ -1793,6 +1777,7 @@ int CloudSyncer::GetLocalInfo(size_t index, SyncParam &param, DataInfoWithLog &l
         }
         errCode = E_OK;
     }
+    logInfo.logInfo.isNeedUpdateAsset = IsNeedUpdateAsset(localAssetInfo);
     return errCode;
 }
 
@@ -1878,14 +1863,13 @@ void CloudSyncer::ClearCurrentContextWithoutLock()
     currentContext_.currentTaskId = INVALID_TASK_ID;
     currentContext_.notifier = nullptr;
     currentContext_.strategy = nullptr;
+    currentContext_.processRecorder = nullptr;
     currentContext_.tableName.clear();
     currentContext_.assetDownloadList.clear();
     currentContext_.assetFields.clear();
     currentContext_.assetsInfo.clear();
     currentContext_.cloudWaterMarks.clear();
     currentContext_.isNeedUpload = false;
-    currentContext_.isDownloadFinished.clear();
-    currentContext_.currentState = CloudSyncState::IDLE;
     currentContext_.currentUserIndex = 0;
     currentContext_.repeatCount = 0;
 }
@@ -1920,8 +1904,7 @@ void CloudSyncer::ClearContextAndNotify(TaskId taskId, int errCode)
     }
     // generate compensated sync
     if (!info.compensatedTask) {
-        CloudTaskInfo taskInfo = CloudSyncUtils::InitCompensatedSyncTaskInfo();
-        taskInfo.lockAction = info.lockAction;
+        CloudTaskInfo taskInfo = CloudSyncUtils::InitCompensatedSyncTaskInfo(info);
         GenerateCompensatedSync(taskInfo);
     }
 }
@@ -1986,11 +1969,13 @@ int CloudSyncer::DownloadOneAssetRecord(const std::set<Key> &dupHashKeySet, cons
             info.downLoadInfo.successCount -= 1;
         }
     }
-    if (dupHashKeySet.find(downloadItem.hashKey) == dupHashKeySet.end()) {
-        changedAssets.primaryData[CloudSyncUtils::OpTypeToChangeType(downloadItem.strategy)].push_back(
-            downloadItem.primaryKeyValList);
-    } else if (downloadItem.strategy == OpType::INSERT) {
-        changedAssets.primaryData[ChangeType::OP_UPDATE].push_back(downloadItem.primaryKeyValList);
+    if (!downloadItem.assets.empty()) {
+        if (dupHashKeySet.find(downloadItem.hashKey) == dupHashKeySet.end()) {
+            changedAssets.primaryData[CloudSyncUtils::OpTypeToChangeType(downloadItem.strategy)].push_back(
+                downloadItem.primaryKeyValList);
+        } else if (downloadItem.strategy == OpType::INSERT) {
+            changedAssets.primaryData[ChangeType::OP_UPDATE].push_back(downloadItem.primaryKeyValList);
+        }
     }
     // If the assets are DELETE, needn't fill back cloud assets.
     if (downloadItem.strategy == OpType::DELETE) {
@@ -2054,13 +2039,6 @@ bool CloudSyncer::IsCurrentTableResume(TaskId taskId, bool upload)
 int CloudSyncer::DownloadDataFromCloud(TaskId taskId, SyncParam &param, bool &abort,
     bool isFirstDownload)
 {
-    if (IsCurrentTableResume(taskId, false)) {
-        std::lock_guard<std::mutex> autoLock(dataLock_);
-        if (resumeTaskInfos_[taskId].skipQuery) {
-            LOGD("[CloudSyncer] skip query");
-            return E_OK;
-        }
-    }
     // Get cloud data after cloud water mark
     param.info.tableStatus = ProcessStatus::PROCESSING;
     param.downloadData = {};
@@ -2101,23 +2079,6 @@ size_t CloudSyncer::GetDownloadAssetIndex(TaskId taskId)
     return index;
 }
 
-size_t CloudSyncer::GetStartTableIndex(TaskId taskId, bool upload)
-{
-    std::lock_guard<std::mutex> autoLock(dataLock_);
-    if (!cloudTaskInfos_[taskId].resume) {
-        return 0u;
-    }
-    if (upload != resumeTaskInfos_[taskId].upload) {
-        return upload ? 0u : cloudTaskInfos_[taskId].table.size();
-    }
-    for (size_t i = 0; i < cloudTaskInfos_[taskId].table.size(); ++i) {
-        if (resumeTaskInfos_[taskId].context.tableName == cloudTaskInfos_[taskId].table[i]) {
-            return i;
-        }
-    }
-    return 0u;
-}
-
 uint32_t CloudSyncer::GetCurrentTableUploadBatchIndex()
 {
     std::lock_guard<std::mutex> autoLock(dataLock_);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h
index b73c70bf47b6e951c1f3fe5a3a409db815f65970..e98fbb92e3e30268ce10f5a45388d1ba972e9877 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer.h
@@ -27,6 +27,7 @@
 #include "cloud/icloud_db.h"
 #include "cloud/icloud_syncer.h"
 #include "cloud/process_notifier.h"
+#include "cloud/process_recorder.h"
 #include "cloud_locker.h"
 #include "data_transformer.h"
 #include "db_common.h"
@@ -84,12 +85,15 @@ public:
     CloudSyncEvent SyncMachineDoFinished();
 
     void SetGenCloudVersionCallback(const GenerateCloudVersionCallback &callback);
+
+    SyncProcess GetCloudTaskStatus(uint64_t taskId) const;
 protected:
     struct TaskContext {
         TaskId currentTaskId = 0u;
         std::string tableName;
         std::shared_ptr<ProcessNotifier> notifier;
         std::shared_ptr<CloudSyncStrategy> strategy;
+        std::shared_ptr<ProcessRecorder> processRecorder;
         std::map<TableName, std::vector<Field>> assetFields;
         // should be cleared after each Download
         DownloadList assetDownloadList;
@@ -98,11 +102,9 @@ protected:
         // struct: <currentUserIndex, <tableName, waterMark>>
         std::map<int, std::map<TableName, std::string>> cloudWaterMarks;
         std::shared_ptr<CloudLocker> locker;
-        bool isNeedUpload = false;  // whether the current task need do upload
-        CloudSyncState currentState = CloudSyncState::IDLE;
+        bool isNeedUpload = false;  // whether the current task need to do upload
         bool isRealNeedUpload = false;
         bool isFirstDownload = false;
-        std::map<int, std::map<std::string, bool>> isDownloadFinished; // struct: <currentUserIndex, <tableName, value>>
         int currentUserIndex = 0;
         int repeatCount = 0;
     };
@@ -142,7 +144,7 @@ protected:
 
     int PrepareAndUpload(const CloudTaskInfo &taskInfo, size_t index);
 
-    int DoSyncInner(const CloudTaskInfo &taskInfo, const bool needUpload, bool isFirstDownload);
+    int DoSyncInner(const CloudTaskInfo &taskInfo);
 
     int DoUploadInNeed(const CloudTaskInfo &taskInfo, const bool needUpload);
 
@@ -257,7 +259,7 @@ protected:
     int TagDownloadAssets(const Key &hashKey, size_t idx, SyncParam &param, const DataInfo &dataInfo,
         VBucket &localAssetInfo);
 
-    int TagUploadAssets(CloudSyncData &uploadData);
+    void TagUploadAssets(CloudSyncData &uploadData);
 
     int FillCloudAssets(const std::string &tableName, VBucket &normalAssets,
         VBucket &failedAssets);
@@ -323,8 +325,6 @@ protected:
 
     size_t GetDownloadAssetIndex(TaskId taskId);
 
-    size_t GetStartTableIndex(TaskId taskId, bool upload);
-
     uint32_t GetCurrentTableUploadBatchIndex();
 
     void ResetCurrentTableUploadBatchIndex();
@@ -359,8 +359,14 @@ protected:
     std::pair<int, uint32_t> GetDBAssets(bool isSharedTable, const InnerProcessInfo &info,
         const DownloadItem &downloadItem, VBucket &dbAssets);
 
-    std::map<std::string, Assets> BackFillAssetsAfterDownload(std::map<std::string, Assets> tmpAssets,
-        std::map<std::string, std::vector<uint32_t>> tmpFlags, int downloadCode);
+    std::map<std::string, Assets>& BackFillAssetsAfterDownload(int downloadCode, int deleteCode,
+        std::map<std::string, std::vector<uint32_t>> &tmpFlags, std::map<std::string, Assets> &tmpAssetsToDownload,
+        std::map<std::string, Assets> &tmpAssetsToDelete);
+
+    int IsNeedSkipDownload(bool isSharedTable, int &errCode, const InnerProcessInfo &info,
+        const DownloadItem &downloadItem, VBucket &dbAssets);
+
+    bool CheckDownloadOrDeleteCode(int &errCode, int downloadCode, int deleteCode, DownloadItem &downloadItem);
 
     int DownloadAssetsOneByOneInner(bool isSharedTable, const InnerProcessInfo &info, DownloadItem &downloadItem,
         std::map<std::string, Assets> &downloadAssets);
@@ -415,9 +421,17 @@ protected:
 
     CloudSyncEvent SyncMachineDoRepeatCheck();
 
-    void MarkDownloadFinishIfNeed(const std::string &downloadTable);
+    void MarkDownloadFinishIfNeed(const std::string &downloadTable, bool isFinish = true);
+
+    bool IsTableFinishInUpload(const std::string &table);
+
+    void MarkUploadFinishIfNeed(const std::string &table);
+
+    bool IsNeedUpdateAsset(const VBucket &data);
+
+    int GenerateTaskIdIfNeed(CloudTaskInfo &taskInfo);
 
-    std::mutex dataLock_;
+    mutable std::mutex dataLock_;
     TaskId lastTaskId_;
     std::list<TaskId> taskQueue_;
     std::list<TaskId> priorityTaskQueue_;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp
index 166a7376caa0a04b205fb3903b5dc1c005af435e..8f7f5e839e165a2e04ad82466ce510b6e5625ff3 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/cloud_syncer_extend.cpp
@@ -24,6 +24,7 @@
 #include "cloud_sync_tag_assets.h"
 #include "cloud_sync_utils.h"
 #include "db_errno.h"
+#include "kv_store_errno.h"
 #include "log_print.h"
 #include "runtime_context.h"
 #include "storage_proxy.h"
@@ -148,6 +149,12 @@ int CloudSyncer::BatchInsert(Info &insertInfo, CloudSyncData &uploadData, InnerP
 {
     int errCode = cloudDB_.BatchInsert(uploadData.tableName, uploadData.insData.record,
         uploadData.insData.extend, insertInfo);
+    innerProcessInfo.upLoadInfo.successCount += insertInfo.successCount;
+    innerProcessInfo.upLoadInfo.insertCount += insertInfo.successCount;
+    innerProcessInfo.upLoadInfo.total -= insertInfo.total - insertInfo.successCount - insertInfo.failCount;
+    if (errCode != E_OK) {
+        LOGE("[CloudSyncer][BatchInsert] BatchInsert with error, ret is %d.", errCode);
+    }
     if (uploadData.isCloudVersionRecord) {
         return errCode;
     }
@@ -158,11 +165,21 @@ int CloudSyncer::BatchInsert(Info &insertInfo, CloudSyncData &uploadData, InnerP
         return ret;
     }
     if (!isSharedTable) {
-        ret = CloudSyncUtils::FillAssetIdToAssets(uploadData.insData, errCode);
+        ret = CloudSyncUtils::FillAssetIdToAssets(uploadData.insData, errCode, CloudWaterType::INSERT);
+        if (ret != errCode) {
+            LOGE("[CloudSyncer][BatchInsert] FillAssetIdToAssets with error, ret is %d.", ret);
+        }
     }
     if (errCode != E_OK) {
         storageProxy_->FillCloudGidIfSuccess(OpType::INSERT, uploadData);
-        return errCode;
+        bool isSkip = CloudSyncUtils::IsSkipAssetsMissingRecord(uploadData.insData.extend);
+        if (isSkip) {
+            LOGI("[CloudSyncer][BatchInsert] Try to FillCloudLogAndAsset when assets missing. errCode: %d", errCode);
+            return E_OK;
+        } else {
+            LOGE("[CloudSyncer][BatchInsert] errCode: %d, can not skip assets missing record.", errCode);
+            return errCode;
+        }
     }
     // we need to fill back gid after insert data to cloud.
     int errorCode = storageProxy_->FillCloudLogAndAsset(OpType::INSERT, uploadData);
@@ -170,7 +187,6 @@ int CloudSyncer::BatchInsert(Info &insertInfo, CloudSyncData &uploadData, InnerP
         LOGE("[CloudSyncer] Failed to fill back when doing upload insData, %d.", errorCode);
         return ret == E_OK ? errorCode : ret;
     }
-    innerProcessInfo.upLoadInfo.successCount += insertInfo.successCount;
     return E_OK;
 }
 
@@ -178,6 +194,12 @@ int CloudSyncer::BatchUpdate(Info &updateInfo, CloudSyncData &uploadData, InnerP
 {
     int errCode = cloudDB_.BatchUpdate(uploadData.tableName, uploadData.updData.record,
         uploadData.updData.extend, updateInfo);
+    innerProcessInfo.upLoadInfo.successCount += updateInfo.successCount;
+    innerProcessInfo.upLoadInfo.updateCount += updateInfo.successCount;
+    innerProcessInfo.upLoadInfo.total -= updateInfo.total - updateInfo.successCount - updateInfo.failCount;
+    if (errCode != E_OK) {
+        LOGE("[CloudSyncer][BatchUpdate] BatchUpdate with error, ret is %d.", errCode);
+    }
     if (uploadData.isCloudVersionRecord) {
         return errCode;
     }
@@ -188,18 +210,27 @@ int CloudSyncer::BatchUpdate(Info &updateInfo, CloudSyncData &uploadData, InnerP
         return ret;
     }
     if (!isSharedTable) {
-        ret = CloudSyncUtils::FillAssetIdToAssets(uploadData.updData, errCode);
+        ret = CloudSyncUtils::FillAssetIdToAssets(uploadData.updData, errCode, CloudWaterType::UPDATE);
+        if (ret != E_OK) {
+            LOGE("[CloudSyncer][BatchUpdate] FillAssetIdToAssets with error, ret is %d.", ret);
+        }
     }
     if (errCode != E_OK) {
         storageProxy_->FillCloudGidIfSuccess(OpType::UPDATE, uploadData);
-        return errCode;
+        bool isSkip = CloudSyncUtils::IsSkipAssetsMissingRecord(uploadData.insData.extend);
+        if (isSkip) {
+            LOGI("[CloudSyncer][BatchUpdate] Try to FillCloudLogAndAsset when assets missing. errCode: %d", errCode);
+            return E_OK;
+        } else {
+            LOGE("[CloudSyncer][BatchUpdate] errCode: %d, can not skip assets missing record.", errCode);
+            return errCode;
+        }
     }
     int errorCode = storageProxy_->FillCloudLogAndAsset(OpType::UPDATE, uploadData);
     if ((errorCode != E_OK) || (ret != E_OK)) {
         LOGE("[CloudSyncer] Failed to fill back when doing upload updData, %d.", errorCode);
         return ret == E_OK ? errorCode : ret;
     }
-    innerProcessInfo.upLoadInfo.successCount += updateInfo.successCount;
     return E_OK;
 }
 
@@ -263,10 +294,12 @@ std::pair<int, uint32_t> CloudSyncer::GetDBAssets(bool isSharedTable, const Inne
     return res;
 }
 
-std::map<std::string, Assets> CloudSyncer::BackFillAssetsAfterDownload(std::map<std::string, Assets> tmpAssets,
-    std::map<std::string, std::vector<uint32_t>> tmpFlags, int downloadCode)
+std::map<std::string, Assets>& CloudSyncer::BackFillAssetsAfterDownload(int downloadCode, int deleteCode,
+    std::map<std::string, std::vector<uint32_t>> &tmpFlags, std::map<std::string, Assets> &tmpAssetsToDownload,
+    std::map<std::string, Assets> &tmpAssetsToDelete)
 {
-    for (auto &[col, assets] : tmpAssets) {
+    std::map<std::string, Assets> &downloadAssets = tmpAssetsToDownload;
+    for (auto &[col, assets] : tmpAssetsToDownload) {
         int i = 0;
         for (auto &asset : assets) {
             asset.flag = tmpFlags[col][i++];
@@ -280,55 +313,93 @@ std::map<std::string, Assets> CloudSyncer::BackFillAssetsAfterDownload(std::map<
             }
         }
     }
-    return tmpAssets;
+    for (auto &[col, assets] : tmpAssetsToDelete) {
+        for (auto &asset : assets) {
+            asset.flag = static_cast<uint32_t>(AssetOpType::DELETE);
+            if (deleteCode == E_OK) {
+                asset.status = NORMAL;
+            } else {
+                asset.status = ABNORMAL;
+            }
+            downloadAssets[col].push_back(asset);
+        }
+    }
+    return downloadAssets;
+}
+
+int CloudSyncer::IsNeedSkipDownload(bool isSharedTable, int &errCode, const InnerProcessInfo &info,
+    const DownloadItem &downloadItem, VBucket &dbAssets)
+{
+    auto [tmpCode, status] = GetDBAssets(isSharedTable, info, downloadItem, dbAssets);
+    if (tmpCode == -E_CLOUD_GID_MISMATCH) {
+        LOGW("[CloudSyncer] skip download asset because gid mismatch");
+        errCode = E_OK;
+        return true;
+    }
+    if (CloudStorageUtils::IsDataLocked(status)) {
+        LOGI("[CloudSyncer] skip download asset because data lock:%u", status);
+        errCode = E_OK;
+        return true;
+    }
+    if (tmpCode != E_OK) {
+        errCode = (errCode != E_OK) ? errCode : tmpCode;
+        return true;
+    }
+    return false;
+}
+
+bool CloudSyncer::CheckDownloadOrDeleteCode(int &errCode, int downloadCode, int deleteCode, DownloadItem &downloadItem)
+{
+    if (downloadCode == -E_CLOUD_RECORD_EXIST_CONFLICT || deleteCode == -E_CLOUD_RECORD_EXIST_CONFLICT) {
+        downloadItem.recordConflict = true;
+        errCode = E_OK;
+        return false;
+    }
+    errCode = (errCode != E_OK) ? errCode : deleteCode;
+    errCode = (errCode != E_OK) ? errCode : downloadCode;
+    if (downloadCode == -E_NOT_SET || deleteCode == -E_NOT_SET) {
+        return false;
+    }
+    return true;
 }
 
 int CloudSyncer::DownloadAssetsOneByOneInner(bool isSharedTable, const InnerProcessInfo &info,
     DownloadItem &downloadItem, std::map<std::string, Assets> &downloadAssets)
 {
     int errCode = E_OK;
-    std::map<std::string, Assets> tmpAssets;
+    std::map<std::string, Assets> tmpAssetsToDownload;
+    std::map<std::string, Assets> tmpAssetsToDelete;
     std::map<std::string, std::vector<uint32_t>> tmpFlags;
     for (auto &[col, assets] : downloadAssets) {
         for (auto &asset : assets) {
             VBucket dbAssets;
-            auto [tmpCode, status] = GetDBAssets(isSharedTable, info, downloadItem, dbAssets);
-            if (tmpCode == -E_CLOUD_GID_MISMATCH) {
-                LOGW("[CloudSyncer] skip download asset because gid mismatch");
-                errCode = E_OK;
+            if (IsNeedSkipDownload(isSharedTable, errCode, info, downloadItem, dbAssets)) {
                 break;
             }
-            if (CloudStorageUtils::IsDataLocked(status)) {
-                LOGI("[CloudSyncer] skip download asset because data lock:%u", status);
-                errCode = E_OK;
-                break;
-            }
-            if (tmpCode != E_OK) {
-                errCode = (errCode != E_OK) ? errCode : tmpCode;
-                break;
-            }
-            if (!isSharedTable && AssetOperationUtils::CalAssetOperation(col, asset, dbAssets,
+            if (!isSharedTable && asset.flag == static_cast<uint32_t>(AssetOpType::DELETE)) {
+                asset.status = static_cast<uint32_t>(AssetStatus::DELETE);
+                tmpAssetsToDelete[col].push_back(asset);
+            } else if (!isSharedTable && AssetOperationUtils::CalAssetOperation(col, asset, dbAssets,
                 AssetOperationUtils::CloudSyncAction::START_DOWNLOAD) == AssetOperationUtils::AssetOpType::HANDLE) {
-                tmpAssets[col].push_back(asset);
+                asset.status = asset.flag == static_cast<uint32_t>(AssetOpType::INSERT) ?
+                    static_cast<uint32_t>(AssetStatus::INSERT) : static_cast<uint32_t>(AssetStatus::UPDATE);
+                tmpAssetsToDownload[col].push_back(asset);
                 tmpFlags[col].push_back(asset.flag);
             } else {
                 LOGD("[CloudSyncer] skip download asset...");
-                continue;
             }
         }
     }
-    auto downloadCode = cloudDB_.Download(info.tableName, downloadItem.gid, downloadItem.prefix, tmpAssets);
-    if (downloadCode == -E_CLOUD_RECORD_EXIST_CONFLICT) {
-        downloadItem.recordConflict = true;
-        return E_OK;
-    }
-    errCode = (errCode != E_OK) ? errCode : downloadCode;
-    if (downloadCode == -E_NOT_SET) {
+    auto deleteCode = cloudDB_.RemoveLocalAssets(info.tableName, downloadItem.gid, downloadItem.prefix,
+        tmpAssetsToDelete);
+    auto downloadCode = cloudDB_.Download(info.tableName, downloadItem.gid, downloadItem.prefix, tmpAssetsToDownload);
+    if (!CheckDownloadOrDeleteCode(errCode, downloadCode, deleteCode, downloadItem)) {
         return errCode;
     }
 
     // copy asset back
-    downloadAssets = BackFillAssetsAfterDownload(tmpAssets, tmpFlags, downloadCode);
+    downloadAssets = BackFillAssetsAfterDownload(downloadCode, deleteCode, tmpFlags, tmpAssetsToDownload,
+        tmpAssetsToDelete);
     return errCode;
 }
 
@@ -401,14 +472,14 @@ void CloudSyncer::GenerateCompensatedSync(CloudTaskInfo &taskInfo)
 
 void CloudSyncer::ChkIgnoredProcess(InnerProcessInfo &info, const CloudSyncData &uploadData, UploadParam &uploadParam)
 {
-    if (uploadData.ignoredCount == 0) {
+    if (uploadData.ignoredCount == 0) { // LCOV_EXCL_BR_LINE
         return;
     }
     info.upLoadInfo.total -= static_cast<uint32_t>(uploadData.ignoredCount);
-    if (info.upLoadInfo.successCount + info.upLoadInfo.failCount != info.upLoadInfo.total) {
+    if (info.upLoadInfo.successCount + info.upLoadInfo.failCount != info.upLoadInfo.total) { // LCOV_EXCL_BR_LINE
         return;
     }
-    if (!CloudSyncUtils::CheckCloudSyncDataEmpty(uploadData)) {
+    if (!CloudSyncUtils::CheckCloudSyncDataEmpty(uploadData)) { // LCOV_EXCL_BR_LINE
         return;
     }
     info.tableStatus = ProcessStatus::FINISHED;
@@ -456,7 +527,7 @@ int CloudSyncer::PrepareAndDownload(const std::string &table, const CloudTaskInf
         return errCode;
     }
     // shared table not allow logic delete
-    storageProxy_->SetCloudTaskConfig({ !taskInfo.priorityTask && !isShared });
+    storageProxy_->SetCloudTaskConfig({ !isShared });
     errCode = CheckTaskIdValid(taskInfo.taskId);
     if (errCode != E_OK) {
         LOGW("[CloudSyncer] task is invalid, abort sync");
@@ -492,11 +563,13 @@ int CloudSyncer::BatchDelete(Info &deleteInfo, CloudSyncData &uploadData, InnerP
 {
     int errCode = cloudDB_.BatchDelete(uploadData.tableName, uploadData.delData.record,
         uploadData.delData.extend, deleteInfo);
+    innerProcessInfo.upLoadInfo.successCount += deleteInfo.successCount;
+    innerProcessInfo.upLoadInfo.deleteCount += deleteInfo.successCount;
     if (errCode != E_OK) {
         LOGE("[CloudSyncer] Failed to batch delete, %d", errCode);
+        storageProxy_->FillCloudGidIfSuccess(OpType::DELETE, uploadData);
         return errCode;
     }
-    innerProcessInfo.upLoadInfo.successCount += deleteInfo.successCount;
     errCode = storageProxy_->FillCloudLogAndAsset(OpType::DELETE, uploadData);
     if (errCode != E_OK) {
         LOGE("[CloudSyncer] Failed to fill back when doing upload delData, %d.", errCode);
@@ -600,7 +673,8 @@ int CloudSyncer::DoDownloadInNeed(const CloudTaskInfo &taskInfo, const bool need
         std::string table;
         {
             std::lock_guard<std::mutex> autoLock(dataLock_);
-            if (currentContext_.isDownloadFinished[currentContext_.currentUserIndex][taskInfo.table[i]] == true) {
+            if (currentContext_.processRecorder->IsDownloadFinish(currentContext_.currentUserIndex,
+                taskInfo.table[i])) {
                 continue;
             }
             LOGD("[CloudSyncer] try download table, index: %zu", i);
@@ -663,27 +737,28 @@ int CloudSyncer::TryToAddSyncTask(CloudTaskInfo &&taskInfo)
     if (errCode != E_OK) {
         return errCode;
     }
-    lastTaskId_++;
-    if (lastTaskId_ == UINT64_MAX) {
-        lastTaskId_ = 1u;
+    errCode = GenerateTaskIdIfNeed(taskInfo);
+    if (errCode != E_OK) {
+        return errCode;
     }
-    taskInfo.taskId = lastTaskId_;
     cloudTaskInfos_[lastTaskId_] = std::move(taskInfo);
     if (cloudTaskInfos_[lastTaskId_].priorityTask) {
         priorityTaskQueue_.push_back(lastTaskId_);
-    } else {
-        if (!MergeTaskInfo(cloudSchema, lastTaskId_)) {
-            taskQueue_.push_back(lastTaskId_);
-            LOGI("[CloudSyncer] Add task ok, storeId %.3s, taskId %" PRIu64,
-                cloudTaskInfos_[lastTaskId_].storeId.c_str(), cloudTaskInfos_[lastTaskId_].taskId);
-        }
+        LOGI("[CloudSyncer] Add priority task ok, storeId %.3s, taskId %" PRIu64,
+            cloudTaskInfos_[lastTaskId_].storeId.c_str(), cloudTaskInfos_[lastTaskId_].taskId);
+        return E_OK;
+    }
+    if (!MergeTaskInfo(cloudSchema, lastTaskId_)) {
+        taskQueue_.push_back(lastTaskId_);
+        LOGI("[CloudSyncer] Add task ok, storeId %.3s, taskId %" PRIu64,
+            cloudTaskInfos_[lastTaskId_].storeId.c_str(), cloudTaskInfos_[lastTaskId_].taskId);
     }
     return E_OK;
 }
 
 bool CloudSyncer::MergeTaskInfo(const std::shared_ptr<DataBaseSchema> &cloudSchema, TaskId taskId)
 {
-    if (!cloudTaskInfos_[taskId].merge) {
+    if (!cloudTaskInfos_[taskId].merge) { // LCOV_EXCL_BR_LINE
         return false;
     }
     bool isMerge = false;
@@ -703,29 +778,29 @@ std::pair<bool, TaskId> CloudSyncer::TryMergeTask(const std::shared_ptr<DataBase
     TaskId beMergeTask = INVALID_TASK_ID;
     TaskId runningTask = currentContext_.currentTaskId;
     for (const auto &taskId : taskQueue_) {
-        if (taskId == runningTask || taskId == tryTaskId) {
+        if (taskId == runningTask || taskId == tryTaskId) { // LCOV_EXCL_BR_LINE
             continue;
         }
-        if (!IsTasksCanMerge(taskId, tryTaskId)) {
+        if (!IsTasksCanMerge(taskId, tryTaskId)) { // LCOV_EXCL_BR_LINE
             continue;
         }
-        if (MergeTaskTablesIfConsistent(taskId, tryTaskId)) {
+        if (MergeTaskTablesIfConsistent(taskId, tryTaskId)) { // LCOV_EXCL_BR_LINE
             beMergeTask = taskId;
             nextTryTask = tryTaskId;
             merge = true;
             break;
         }
-        if (MergeTaskTablesIfConsistent(tryTaskId, taskId)) {
+        if (MergeTaskTablesIfConsistent(tryTaskId, taskId)) { // LCOV_EXCL_BR_LINE
             beMergeTask = tryTaskId;
             nextTryTask = taskId;
             merge = true;
             break;
         }
     }
-    if (!merge) {
+    if (!merge) { // LCOV_EXCL_BR_LINE
         return res;
     }
-    if (beMergeTask < nextTryTask) {
+    if (beMergeTask < nextTryTask) { // LCOV_EXCL_BR_LINE
         std::tie(beMergeTask, nextTryTask) = SwapTwoTaskAndCopyTable(beMergeTask, nextTryTask);
     }
     AdjustTableBasedOnSchema(cloudSchema, cloudTaskInfos_[nextTryTask]);
@@ -762,7 +837,7 @@ bool CloudSyncer::MergeTaskTablesIfConsistent(TaskId sourceId, TaskId targetId)
     const auto &target = cloudTaskInfos_[targetId];
     bool isMerge = true;
     for (const auto &table : source.table) {
-        if (std::find(target.table.begin(), target.table.end(), table) == target.table.end()) {
+        if (std::find(target.table.begin(), target.table.end(), table) == target.table.end()) { // LCOV_EXCL_BR_LINE
             isMerge = false;
             break;
         }
@@ -777,7 +852,7 @@ void CloudSyncer::AdjustTableBasedOnSchema(const std::shared_ptr<DataBaseSchema>
     taskInfo.table.clear();
     taskInfo.queryList.clear();
     for (const auto &table : cloudSchema->tables) {
-        if (std::find(tmpTables.begin(), tmpTables.end(), table.name) != tmpTables.end()) {
+        if (std::find(tmpTables.begin(), tmpTables.end(), table.name) != tmpTables.end()) { // LCOV_EXCL_BR_LINE
             taskInfo.table.push_back(table.name);
             QuerySyncObject querySyncObject;
             querySyncObject.SetTableName(table.name);
@@ -790,6 +865,10 @@ std::pair<TaskId, TaskId> CloudSyncer::SwapTwoTaskAndCopyTable(TaskId source, Ta
 {
     cloudTaskInfos_[source].table = cloudTaskInfos_[target].table;
     cloudTaskInfos_[source].queryList = cloudTaskInfos_[target].queryList;
+    std::set<std::string> users;
+    users.insert(cloudTaskInfos_[source].users.begin(), cloudTaskInfos_[source].users.end());
+    users.insert(cloudTaskInfos_[target].users.begin(), cloudTaskInfos_[target].users.end());
+    cloudTaskInfos_[source].users = std::vector<std::string>(users.begin(), users.end());
     return {target, source};
 }
 
@@ -811,7 +890,7 @@ std::pair<int, Timestamp> CloudSyncer::GetLocalWater(const std::string &tableNam
 {
     std::pair<int, Timestamp> res = { E_OK, 0u };
     if (IsNeedGetLocalWater(uploadParam.taskId)) {
-        res.first = storageProxy_->GetLocalWaterMarkByMode(tableName, res.second, uploadParam.mode);
+        res.first = storageProxy_->GetLocalWaterMarkByMode(tableName, uploadParam.mode, res.second);
     }
     uploadParam.localMark = res.second;
     return res;
@@ -828,6 +907,7 @@ int CloudSyncer::HandleBatchUpload(UploadParam &uploadParam, InnerProcessInfo &i
         if (ret != E_OK) {
             break;
         }
+        info.upLoadInfo.batchIndex = ++batchIndex;
         if (IsNeedLock(uploadParam) && !isLocked) {
             ret = LockCloudIfNeed(uploadParam.taskId);
             if (ret != E_OK) {
@@ -835,10 +915,8 @@ int CloudSyncer::HandleBatchUpload(UploadParam &uploadParam, InnerProcessInfo &i
             }
             isLocked = true;
         }
-        info.upLoadInfo.batchIndex = ++batchIndex;
         ret = DoBatchUpload(uploadData, uploadParam, info);
         if (ret != E_OK) {
-            NotifyUploadFailed(ret, info);
             break;
         }
         uploadData = CloudSyncData(uploadData.tableName, uploadParam.mode);
@@ -854,6 +932,9 @@ int CloudSyncer::HandleBatchUpload(UploadParam &uploadParam, InnerProcessInfo &i
         }
         ChkIgnoredProcess(info, uploadData, uploadParam);
     }
+    if ((ret != E_OK) && (ret != -E_UNFINISHED)) {
+        NotifyUploadFailed(ret, info);
+    }
     if (isLocked && IsNeedLock(uploadParam)) {
         UnlockIfNeed();
     }
@@ -864,14 +945,19 @@ int CloudSyncer::DoUploadInner(const std::string &tableName, UploadParam &upload
 {
     InnerProcessInfo info = GetInnerProcessInfo(tableName, uploadParam);
     static std::vector<CloudWaterType> waterTypes = DBCommon::GetWaterTypeVec();
+    int errCode = E_OK;
     for (const auto &waterType: waterTypes) {
         uploadParam.mode = waterType;
-        int errCode = DoUploadByMode(tableName, uploadParam, info);
+        errCode = DoUploadByMode(tableName, uploadParam, info);
         if (errCode != E_OK) {
-            return errCode;
+            break;
         }
     }
-    return UploadVersionRecordIfNeed(uploadParam);
+    int ret = E_OK;
+    if (info.upLoadInfo.successCount > 0) {
+        ret = UploadVersionRecordIfNeed(uploadParam);
+    }
+    return errCode != E_OK ? errCode : ret;
 }
 
 int CloudSyncer::UploadVersionRecordIfNeed(const UploadParam &uploadParam)
@@ -914,10 +1000,10 @@ int CloudSyncer::UploadVersionRecordIfNeed(const UploadParam &uploadParam)
     return errCode != E_OK ? errCode : ret;
 }
 
-int CloudSyncer::TagUploadAssets(CloudSyncData &uploadData)
+void CloudSyncer::TagUploadAssets(CloudSyncData &uploadData)
 {
     if (!IsDataContainAssets()) {
-        return E_OK;
+        return;
     }
     std::vector<Field> assetFields;
     {
@@ -927,15 +1013,14 @@ int CloudSyncer::TagUploadAssets(CloudSyncData &uploadData)
 
     for (size_t i = 0; i < uploadData.insData.extend.size(); i++) {
         for (const Field &assetField : assetFields) {
-            (void)TagAssetsInSingleCol(assetField, uploadData.insData.record[i], true);
+            (void)TagAssetsInSingleCol(assetField, true, uploadData.insData.record[i]);
         }
     }
     for (size_t i = 0; i < uploadData.updData.extend.size(); i++) {
         for (const Field &assetField : assetFields) {
-            (void)TagAssetsInSingleCol(assetField, uploadData.updData.record[i], false);
+            (void)TagAssetsInSingleCol(assetField, false, uploadData.updData.record[i]);
         }
     }
-    return E_OK;
 }
 
 bool CloudSyncer::IsLockInDownload()
@@ -993,13 +1078,129 @@ CloudSyncEvent CloudSyncer::SyncMachineDoRepeatCheck()
     return CloudSyncEvent::REPEAT_DOWNLOAD_EVENT;
 }
 
-void CloudSyncer::MarkDownloadFinishIfNeed(const std::string &downloadTable)
+void CloudSyncer::MarkDownloadFinishIfNeed(const std::string &downloadTable, bool isFinish)
 {
     // table exist reference should download every times
-    if (IsLockInDownload() || storageProxy_->IsTableExistReference(downloadTable)) {
+    if (IsLockInDownload() || storageProxy_->IsTableExistReferenceOrReferenceBy(downloadTable)) {
+        return;
+    }
+    std::lock_guard<std::mutex> autoLock(dataLock_);
+    currentContext_.processRecorder->MarkDownloadFinish(currentContext_.currentUserIndex, downloadTable, isFinish);
+}
+
+int CloudSyncer::DoUploadByMode(const std::string &tableName, UploadParam &uploadParam, InnerProcessInfo &info)
+{
+    CloudSyncData uploadData(tableName, uploadParam.mode);
+    SetUploadDataFlag(uploadParam.taskId, uploadData);
+    auto [err, localWater] = GetLocalWater(tableName, uploadParam);
+    if (err != E_OK) {
+        return err;
+    }
+    ContinueToken continueStmtToken = nullptr;
+    int ret = storageProxy_->GetCloudData(GetQuerySyncObject(tableName), localWater, continueStmtToken, uploadData);
+    if ((ret != E_OK) && (ret != -E_UNFINISHED)) {
+        LOGE("[CloudSyncer] Failed to get cloud data when upload, %d.", ret);
+        return ret;
+    }
+    uploadParam.count -= uploadData.ignoredCount;
+    info.upLoadInfo.total -= static_cast<uint32_t>(uploadData.ignoredCount);
+    ret = HandleBatchUpload(uploadParam, info, uploadData, continueStmtToken);
+    if (ret != -E_TASK_PAUSED) {
+        // reset watermark to zero when task no paused
+        RecordWaterMark(uploadParam.taskId, 0u);
+    }
+    if (continueStmtToken != nullptr) {
+        storageProxy_->ReleaseContinueToken(continueStmtToken);
+    }
+    return ret;
+}
+
+bool CloudSyncer::IsTableFinishInUpload(const std::string &table)
+{
+    std::lock_guard<std::mutex> autoLock(dataLock_);
+    return currentContext_.processRecorder->IsUploadFinish(currentContext_.currentUserIndex, table);
+}
+
+void CloudSyncer::MarkUploadFinishIfNeed(const std::string &table)
+{
+    // table exist reference should upload every times
+    if (storageProxy_->IsTableExistReference(table)) {
         return;
     }
     std::lock_guard<std::mutex> autoLock(dataLock_);
-    currentContext_.isDownloadFinished[currentContext_.currentUserIndex][downloadTable] = true;
+    currentContext_.processRecorder->MarkUploadFinish(currentContext_.currentUserIndex, table, true);
+}
+
+bool CloudSyncer::IsNeedUpdateAsset(const VBucket &data)
+{
+    for (const auto &item : data) {
+        const Asset *asset = std::get_if<TYPE_INDEX<Asset>>(&item.second);
+        if (asset != nullptr) {
+            uint32_t lowBitStatus = AssetOperationUtils::EraseBitMask(asset->status);
+            if (lowBitStatus == static_cast<uint32_t>(AssetStatus::ABNORMAL) ||
+            lowBitStatus == static_cast<uint32_t>(AssetStatus::DOWNLOADING)) {
+                return true;
+            }
+            continue;
+        }
+        const Assets *assets = std::get_if<TYPE_INDEX<Assets>>(&item.second);
+        if (assets == nullptr) {
+            continue;
+        }
+        for (const auto &oneAsset : *assets) {
+            uint32_t lowBitStatus = AssetOperationUtils::EraseBitMask(oneAsset.status);
+            if (lowBitStatus == static_cast<uint32_t>(AssetStatus::ABNORMAL) ||
+            lowBitStatus == static_cast<uint32_t>(AssetStatus::DOWNLOADING)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+SyncProcess CloudSyncer::GetCloudTaskStatus(uint64_t taskId) const
+{
+    std::lock_guard<std::mutex> autoLock(dataLock_);
+    auto iter = cloudTaskInfos_.find(taskId);
+    SyncProcess syncProcess;
+    if (iter == cloudTaskInfos_.end()) {
+        syncProcess.process = ProcessStatus::FINISHED;
+        syncProcess.errCode = NOT_FOUND;
+        LOGE("[CloudSyncer] Not found task %" PRIu64, taskId);
+        return syncProcess;
+    }
+    syncProcess.process = iter->second.status;
+    syncProcess.errCode = TransferDBErrno(iter->second.errCode);
+    std::shared_ptr<ProcessNotifier> notifier = nullptr;
+    if (currentContext_.currentTaskId == taskId) {
+        notifier = currentContext_.notifier;
+    }
+    bool hasNotifier = notifier != nullptr;
+    if (hasNotifier) {
+        syncProcess.tableProcess = notifier->GetCurrentTableProcess();
+    }
+    LOGI("[CloudSyncer] Found task %" PRIu64 " storeId %.3s status %d has notifier %d", taskId,
+        iter->second.storeId.c_str(), static_cast<int64_t>(syncProcess.process), static_cast<int>(hasNotifier));
+    return syncProcess;
+}
+
+int CloudSyncer::GenerateTaskIdIfNeed(CloudTaskInfo &taskInfo)
+{
+    if (taskInfo.taskId != INVALID_TASK_ID) {
+        if (cloudTaskInfos_.find(taskInfo.taskId) != cloudTaskInfos_.end()) {
+            LOGE("[CloudSyncer] Sync with exist taskId %" PRIu64 " storeId %.3s", taskInfo.taskId,
+                taskInfo.storeId.c_str());
+            return -E_INVALID_ARGS;
+        }
+        lastTaskId_ = taskInfo.taskId;
+        LOGI("[CloudSyncer] Sync with taskId %" PRIu64 " storeId %.3s", taskInfo.taskId, taskInfo.storeId.c_str());
+        return E_OK;
+    }
+    lastTaskId_++;
+    if (lastTaskId_ == UINT64_MAX) {
+        lastTaskId_ = 1u;
+    }
+    taskInfo.taskId = lastTaskId_;
+    return E_OK;
 }
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.cpp
index dad693a1a891060ea6098f59e0662c44819dc4ac..0a0161272b9b2bfd7e47bbf7e9e051f5ffdc1cbc 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.cpp
@@ -59,23 +59,15 @@ void ProcessNotifier::UpdateProcess(const ICloudSyncer::InnerProcessInfo &proces
         return;
     }
     std::lock_guard<std::mutex> autoLock(processMutex_);
-    syncProcess_.tableProcess[process.tableName].process = process.tableStatus;
+    auto &syncProcess = user_.empty() ? syncProcess_ : multiSyncProcess_[user_];
+    syncProcess.tableProcess[process.tableName].process = process.tableStatus;
     if (process.downLoadInfo.batchIndex != 0u) {
         LOGD("[ProcessNotifier] update download process index: %" PRIu32, process.downLoadInfo.batchIndex);
-        syncProcess_.tableProcess[process.tableName].downLoadInfo.batchIndex = process.downLoadInfo.batchIndex;
-        syncProcess_.tableProcess[process.tableName].downLoadInfo.total = process.downLoadInfo.total;
-        syncProcess_.tableProcess[process.tableName].downLoadInfo.failCount = process.downLoadInfo.failCount;
-        syncProcess_.tableProcess[process.tableName].downLoadInfo.successCount = process.downLoadInfo.successCount;
+        syncProcess.tableProcess[process.tableName].downLoadInfo = process.downLoadInfo;
     }
     if (process.upLoadInfo.batchIndex != 0u) {
         LOGD("[ProcessNotifier] update upload process index: %" PRIu32, process.upLoadInfo.batchIndex);
-        syncProcess_.tableProcess[process.tableName].upLoadInfo.batchIndex = process.upLoadInfo.batchIndex;
-        syncProcess_.tableProcess[process.tableName].upLoadInfo.total = process.upLoadInfo.total;
-        syncProcess_.tableProcess[process.tableName].upLoadInfo.failCount = process.upLoadInfo.failCount;
-        syncProcess_.tableProcess[process.tableName].upLoadInfo.successCount = process.upLoadInfo.successCount;
-    }
-    if (!user_.empty()) {
-        multiSyncProcess_[user_] = syncProcess_;
+        syncProcess.tableProcess[process.tableName].upLoadInfo = process.upLoadInfo;
     }
 }
 
@@ -90,9 +82,9 @@ void ProcessNotifier::NotifyProcess(const ICloudSyncer::CloudTaskInfo &taskInfo,
             LOGD("[ProcessNotifier] task has error, do not notify now");
             return;
         }
-        syncProcess_.errCode = TransferDBErrno(taskInfo.errCode);
+        syncProcess_.errCode = TransferDBErrno(taskInfo.errCode, true);
         syncProcess_.process = taskInfo.status;
-        multiSyncProcess_[user_].errCode = TransferDBErrno(taskInfo.errCode);
+        multiSyncProcess_[user_].errCode = TransferDBErrno(taskInfo.errCode, true);
         multiSyncProcess_[user_].process = taskInfo.status;
         if (user_.empty()) {
             for (const auto &device : devices_) {
@@ -139,29 +131,35 @@ std::vector<std::string> ProcessNotifier::GetDevices() const
 uint32_t ProcessNotifier::GetUploadBatchIndex(const std::string &tableName) const
 {
     std::lock_guard<std::mutex> autoLock(processMutex_);
-    if (syncProcess_.tableProcess.find(tableName) == syncProcess_.tableProcess.end()) {
+    auto &syncProcess = IsMultiUser() ? multiSyncProcess_.at(user_) : syncProcess_;
+    if (syncProcess.tableProcess.find(tableName) == syncProcess.tableProcess.end()) {
         return 0u;
     }
-    return syncProcess_.tableProcess.at(tableName).upLoadInfo.batchIndex;
+    return syncProcess.tableProcess.at(tableName).upLoadInfo.batchIndex;
 }
 
 void ProcessNotifier::ResetUploadBatchIndex(const std::string &tableName)
 {
+    if (tableName.empty()) {
+        return;
+    }
     std::lock_guard<std::mutex> autoLock(processMutex_);
-    if (syncProcess_.tableProcess.find(tableName) == syncProcess_.tableProcess.end()) {
+    auto &syncProcess = IsMultiUser() ? multiSyncProcess_.at(user_) : syncProcess_;
+    if (syncProcess.tableProcess.find(tableName) == syncProcess.tableProcess.end()) {
         LOGW("[ProcessNotifier] The specified table was not found when reset UploadBatchIndex");
         return;
     }
-    syncProcess_.tableProcess[tableName].upLoadInfo.batchIndex = 0;
+    syncProcess.tableProcess[tableName].upLoadInfo.batchIndex = 0;
 }
 
 uint32_t ProcessNotifier::GetLastUploadSuccessCount(const std::string &tableName) const
 {
     std::lock_guard<std::mutex> autoLock(processMutex_);
-    if (syncProcess_.tableProcess.find(tableName) == syncProcess_.tableProcess.end()) {
+    auto &syncProcess = IsMultiUser() ? multiSyncProcess_.at(user_) : syncProcess_;
+    if (syncProcess.tableProcess.find(tableName) == syncProcess_.tableProcess.end()) {
         return 0u;
     }
-    return syncProcess_.tableProcess.at(tableName).upLoadInfo.successCount;
+    return syncProcess.tableProcess.at(tableName).upLoadInfo.successCount;
 }
 
 void ProcessNotifier::GetDownloadInfoByTableName(ICloudSyncer::InnerProcessInfo &process)
@@ -177,7 +175,7 @@ void ProcessNotifier::GetDownloadInfoByTableName(ICloudSyncer::InnerProcessInfo
         syncProcess = multiSyncProcess_[user_];
     }
     
-    if (syncProcess.tableProcess.find(process.tableName) == syncProcess.tableProcess.end()) {
+    if (syncProcess.tableProcess.find(process.tableName) != syncProcess.tableProcess.end()) {
         process.downLoadInfo = syncProcess.tableProcess[process.tableName].downLoadInfo;
     }
 }
@@ -199,4 +197,15 @@ void ProcessNotifier::SetAllTableFinish()
         }
     }
 }
-}
\ No newline at end of file
+
+bool ProcessNotifier::IsMultiUser() const
+{
+    return !user_.empty() && multiSyncProcess_.find(user_) != multiSyncProcess_.end();
+}
+
+std::map<std::string, TableProcessInfo> ProcessNotifier::GetCurrentTableProcess() const
+{
+    std::lock_guard<std::mutex> autoLock(processMutex_);
+    return syncProcess_.tableProcess;
+}
+}
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.h
index 8416c37843a0749a89614dc704905aafc5ef4b75..f688cd5c6db20aed7cedd12577292d29d29025dc 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_notifier.h
@@ -43,6 +43,8 @@ public:
     void SetUser(const std::string &user);
 
     void SetAllTableFinish();
+
+    std::map<std::string, TableProcessInfo> GetCurrentTableProcess() const;
 protected:
     mutable std::mutex processMutex_;
     SyncProcess syncProcess_;
@@ -51,7 +53,8 @@ protected:
     ICloudSyncer *syncer_;
     std::string user_;
 private:
-    void InitSyncProcess(const std::vector<std::string> &tableName, SyncProcess &syncProcess);
+    static void InitSyncProcess(const std::vector<std::string> &tableName, SyncProcess &syncProcess);
+    bool IsMultiUser() const;
 };
 }
 #endif // PROCESS_NOTIFIER_H
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c3301ebab3165cdaf2211165ca86d8ed73037d7
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "process_recorder.h"
+
+namespace DistributedDB {
+void ProcessRecorder::ClearRecord()
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    downloadRecord_.clear();
+    uploadRecord_.clear();
+}
+
+bool ProcessRecorder::IsDownloadFinish(int userIndex, const std::string &table) const
+{
+    return IsRecordFinish(userIndex, table, downloadRecord_);
+}
+
+void ProcessRecorder::MarkDownloadFinish(int userIndex, const std::string &table, bool finish)
+{
+    RecordFinish(userIndex, table, finish, downloadRecord_);
+}
+
+bool ProcessRecorder::IsUploadFinish(int userIndex, const std::string &table) const
+{
+    return IsRecordFinish(userIndex, table, uploadRecord_);
+}
+
+void ProcessRecorder::MarkUploadFinish(int userIndex, const std::string &table, bool finish)
+{
+    RecordFinish(userIndex, table, finish, uploadRecord_);
+}
+
+bool ProcessRecorder::IsRecordFinish(int userIndex, const std::string &table,
+    const std::map<int, std::map<std::string, bool>> &record) const
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    if (record.find(userIndex) == record.end()) {
+        return false;
+    }
+    if (record.at(userIndex).find(table) == record.at(userIndex).end()) {
+        return false;
+    }
+    return record.at(userIndex).at(table);
+}
+
+void ProcessRecorder::RecordFinish(int userIndex, const std::string &table, bool finish,
+    std::map<int, std::map<std::string, bool>> &record)
+{
+    std::lock_guard<std::mutex> autoLock(recordMutex_);
+    record[userIndex][table] = finish;
+}
+}
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.h b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c301d02814294d0ee8a5e5e9ac1b76d588ba683
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/cloud/process_recorder.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef PROCESS_RECORDER_H
+#define PROCESS_RECORDER_H
+
+#include <mutex>
+#include "store_types.h"
+
+namespace DistributedDB {
+class ProcessRecorder {
+public:
+    ProcessRecorder() = default;
+    ~ProcessRecorder() = default;
+
+    void ClearRecord();
+
+    bool IsDownloadFinish(int userIndex, const std::string &table) const;
+    void MarkDownloadFinish(int userIndex, const std::string &table, bool finish);
+
+    bool IsUploadFinish(int userIndex, const std::string &table) const;
+    void MarkUploadFinish(int userIndex, const std::string &table, bool finish);
+private:
+    bool IsRecordFinish(int userIndex, const std::string &table,
+        const std::map<int, std::map<std::string, bool>> &record) const;
+    void RecordFinish(int userIndex, const std::string &table, bool finish,
+        std::map<int, std::map<std::string, bool>> &record);
+
+    mutable std::mutex recordMutex_;
+    std::map<int, std::map<std::string, bool>> downloadRecord_; // record table download finish
+    std::map<int, std::map<std::string, bool>> uploadRecord_;   // record table upload finish
+};
+}
+
+#endif // PROCESS_RECORDER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/ability_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/ability_sync.cpp
index a540dae89cfc0797160edd6f3306107db931d03f..3e75eefdc6cd32aa7d09f2fcb2edc65bad6cb53f 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/ability_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/ability_sync.cpp
@@ -429,7 +429,7 @@ int AbilitySync::AckRecv(const Message *message, ISyncTaskContext *context)
         std::string schema = packet->GetSchema();
         uint8_t schemaType = packet->GetSchemaType();
         bool isCompatible = static_cast<SyncGenericInterface *>(storageInterface_)->CheckCompatible(schema, schemaType);
-        if (!isCompatible) {
+        if (!isCompatible) { // LCOV_EXCL_BR_LINE
             (static_cast<SingleVerSyncTaskContext *>(context))->SetTaskErrCode(-E_SCHEMA_MISMATCH);
             LOGE("[AbilitySync][AckRecv] scheme check failed");
             return -E_SCHEMA_MISMATCH;
@@ -514,7 +514,7 @@ void AbilitySync::SetAbilitySyncFinishedStatus(bool syncFinished, ISyncTaskConte
         return;
     }
     // record finished with all schema compatible
-    if (syncFinished && !context.IsSchemaCompatible()) {
+    if (syncFinished && !context.IsSchemaCompatible()) { // LCOV_EXCL_BR_LINE
         return;
     }
     int errCode = metadata_->SetAbilitySyncFinishMark(deviceId_, syncFinished);
@@ -614,11 +614,13 @@ void AbilitySync::GetPacketSecOption(const ISyncTaskContext *context, SecurityOp
 int AbilitySync::RegisterTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&AbilitySync::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&AbilitySync::Serialization, std::placeholders::_1,
-                                   std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&AbilitySync::DeSerialization, std::placeholders::_1,
-                                     std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
     return MessageTransform::RegTransformFunction(ABILITY_SYNC_MESSAGE, func);
 }
 
@@ -844,13 +846,13 @@ int AbilitySync::RequestPacketDeSerializationTailPart(Parcel &parcel, AbilitySyn
     }
     packet->SetDbAbility(remoteDbAbility);
     if (version >= SOFTWARE_VERSION_RELEASE_9_0) {
-        uint64_t schemaVersion = 0;
+        uint64_t schemaVersion = 0u;
         parcel.ReadUInt64(schemaVersion);
-        packet->SetSchemaVersion(schemaVersion);
         if (parcel.IsError()) {
             LOGW("[AbilitySync] request packet read schema version failed");
             return -E_PARSE_FAIL;
         }
+        packet->SetSchemaVersion(schemaVersion);
     }
     return E_OK;
 }
@@ -896,11 +898,11 @@ int AbilitySync::AckPacketDeSerializationTailPart(Parcel &parcel, AbilitySyncAck
     if (version >= SOFTWARE_VERSION_RELEASE_9_0) {
         uint64_t schemaVersion = 0;
         parcel.ReadUInt64(schemaVersion);
-        packet->SetSchemaVersion(schemaVersion);
         if (parcel.IsError()) {
             LOGW("[AbilitySync] ack packet read schema version failed.");
             return -E_PARSE_FAIL;
         }
+        packet->SetSchemaVersion(schemaVersion);
     }
     return E_OK;
 }
@@ -1213,7 +1215,8 @@ SyncOpinion AbilitySync::MakeKvSyncOpinion(const AbilitySyncRequestPacket *packe
     uint8_t remoteSchemaType = packet->GetSchemaType();
     SchemaObject localSchema = (static_cast<SingleVerKvDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
     SyncOpinion localSyncOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
-    if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(), localSchema.GetSchemaType(), remoteSchemaType)) {
+    if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(),
+        localSchema.GetSchemaType(), remoteSchemaType)) { // LCOV_EXCL_BR_LINE
         // both kv no need convert
         SyncStrategy localStrategy;
         localStrategy.permitSync = true;
@@ -1248,10 +1251,11 @@ int AbilitySync::HandleKvAckSchemaParam(const AbilitySyncAckPacket *recvPacket,
         localStrategy.permitSync,
         true
     };
-    if (localStrategy.permitSync) {
+    if (localStrategy.permitSync) { // LCOV_EXCL_BR_LINE
         RecordAbilitySyncFinish(recvPacket->GetSchemaVersion(), *context);
     }
-    if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(), localSchema.GetSchemaType(), remoteSchemaType)) {
+    if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(),
+        localSchema.GetSchemaType(), remoteSchemaType)) { // LCOV_EXCL_BR_LINE
         return -E_ABILITY_SYNC_FINISHED;
     }
     return E_OK;
@@ -1356,8 +1360,8 @@ void AbilitySync::InitAbilitySyncFinishStatus(ISyncTaskContext &context)
     }
     LOGI("[AbilitySync] Mark ability sync finish from db status");
     syncFinished_ = true;
-    if (context.GetRemoteSoftwareVersion() == 0u) {
-        LOGD("[AbilitySync] Init remote version with default");
+    if (context.GetRemoteSoftwareVersion() == 0u) { // LCOV_EXCL_BR_LINE
+        LOGI("[AbilitySync] Init remote version with default");
         context.SetRemoteSoftwareVersion(SOFTWARE_VERSION_RELEASE_9_0); // remote version >= 109
     }
     InitRemoteDBAbility(context);
@@ -1376,7 +1380,7 @@ void AbilitySync::InitRemoteDBAbility(ISyncTaskContext &context)
 void AbilitySync::RecordAbilitySyncFinish(uint64_t remoteSchemaVersion, ISyncTaskContext &context)
 {
     SetAbilitySyncFinishedStatus(true, context);
-    if (context.GetRemoteSoftwareVersion() >= SOFTWARE_VERSION_RELEASE_9_0) {
+    if (context.GetRemoteSoftwareVersion() >= SOFTWARE_VERSION_RELEASE_9_0) { // LCOV_EXCL_BR_LINE
         (void)metadata_->SetRemoteSchemaVersion(deviceId_, remoteSchemaVersion);
     }
 }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/commit_history_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/commit_history_sync.cpp
index ea62b45e0ceb7b605ccca4d088a6778496cf6e71..4d8a5802879869d6f2b578291331d1b6bb1afc4b 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/commit_history_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/commit_history_sync.cpp
@@ -199,11 +199,13 @@ uint32_t CommitHistorySync::CalculateLen(const Message *inMsg)
 int CommitHistorySync::RegisterTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&CommitHistorySync::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&CommitHistorySync::Serialization, std::placeholders::_1,
-                                   std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&CommitHistorySync::DeSerialization, std::placeholders::_1,
-                                     std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
     return MessageTransform::RegTransformFunction(COMMIT_HISTORY_SYNC_MESSAGE, func);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.cpp
index e95aabeaa85849d5a5f0c0dcad23a7526e2df89d..0605b0985dc59a0f7086d4ebc0047c9bfc017c89 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.cpp
@@ -195,6 +195,43 @@ int GenericSyncer::Sync(const SyncParma &param, uint64_t connectionId)
     return E_OK;
 }
 
+int GenericSyncer::CancelSync(uint32_t syncId)
+{
+    LOGI("[Syncer] Start cancelSync %" PRIu32 "", syncId);
+    ISyncEngine *engine = nullptr;
+    {
+        std::lock_guard<std::mutex> autoLock(syncerLock_);
+        engine = syncEngine_;
+        RefObject::IncObjRef(engine);
+    }
+    SyncOperation *operation = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(operationMapLock_);
+        auto iter = syncOperationMap_.find(syncId);
+        if (iter == syncOperationMap_.end()) {
+            LOGE("[Syncer] Non-existent syncId %" PRIu32 "", syncId);
+            RefObject::DecObjRef(engine);
+            return -E_NOT_SUPPORT;
+        } else if (iter->second->CanCancel() == false) {
+            RefObject::DecObjRef(engine);
+            LOGE("[Syncer] Can't cancel syncId %" PRIu32 " %" PRIu32 "", syncId, iter->second->CanCancel());
+            return -E_NOT_SUPPORT;
+        }
+        operation = iter->second;
+        RefObject::IncObjRef(operation);
+    }
+
+    const std::vector<std::string> &devices = operation->GetDevices();
+    for (auto &deviceId : devices) {
+        engine->ClearAllSyncTaskByDevice(deviceId);
+    }
+    LOGI("[Syncer] End cancelSync %" PRIu32 ", devices = %s", syncId, GetSyncDevicesStr(devices).c_str());
+
+    RefObject::DecObjRef(operation);
+    RefObject::DecObjRef(engine);
+    return E_OK;
+}
+
 int GenericSyncer::PrepareSync(const SyncParma &param, uint32_t syncId, uint64_t connectionId)
 {
     auto *operation =
@@ -423,12 +460,14 @@ int GenericSyncer::InitSyncEngine(ISyncInterface *syncInterface)
     if (errCode != E_OK) {
         return errCode;
     }
-    const std::function<void(std::string)> onlineFunc = std::bind(&GenericSyncer::RemoteDataChanged,
-        this, std::placeholders::_1);
-    const std::function<void(std::string)> offlineFunc = std::bind(&GenericSyncer::RemoteDeviceOffline,
-        this, std::placeholders::_1);
+    const std::function<void(std::string)> onlineFunc = [this](const std::string &device) {
+        RemoteDataChanged(device);
+    };
+    const std::function<void(std::string)> offlineFunc = [this](const std::string &device) {
+        RemoteDeviceOffline(device);
+    };
     const std::function<void(const InternalSyncParma &param)> queryAutoSyncFunc =
-        std::bind(&GenericSyncer::QueryAutoSync, this, std::placeholders::_1);
+        [this](const InternalSyncParma &syncParam) { QueryAutoSync(syncParam); };
     const ISyncEngine::InitCallbackParam param = { onlineFunc, offlineFunc, queryAutoSyncFunc };
     errCode = syncEngine_->Initialize(syncInterface, metadata_, param);
     if (errCode == E_OK) {
@@ -550,7 +589,7 @@ void GenericSyncer::ClearInnerResource(bool isClosedOperation)
 
 void GenericSyncer::TriggerSyncFinished(SyncOperation *operation)
 {
-    if (operation != nullptr && operation->CheckIsAllFinished()) {
+    if (operation != nullptr && operation->CheckIsAllFinished()) { // LCOV_EXCL_BR_LINE
         operation->Finished();
     }
 }
@@ -676,11 +715,11 @@ int GenericSyncer::AddQueuedManualSyncSize(int mode, bool wait)
 bool GenericSyncer::IsQueuedManualSyncFull(int mode, bool wait) const
 {
     std::lock_guard<std::mutex> lock(queuedManualSyncLock_);
-    if (IsManualSync(mode) && (!manualSyncEnable_)) {
+    if (IsManualSync(mode) && (!manualSyncEnable_)) { // LCOV_EXCL_BR_LINE
         LOGI("[GenericSyncer] manualSyncEnable_:false");
         return true;
     }
-    if (IsManualSync(mode) && (!wait)) {
+    if (IsManualSync(mode) && (!wait)) { // LCOV_EXCL_BR_LINE
         if (queuedManualSyncSize_ < queuedManualSyncLimit_) {
             return false;
         } else {
@@ -827,10 +866,10 @@ int GenericSyncer::SyncPreCheck(const SyncParma &param) const
         if (errCode != E_OK) {
             return errCode;
         }
-        if (!IsValidDevices(param.devices) || !IsValidMode(param.mode)) {
+        if (!IsValidDevices(param.devices) || !IsValidMode(param.mode)) { // LCOV_EXCL_BR_LINE
             return -E_INVALID_ARGS;
         }
-        if (IsQueuedManualSyncFull(param.mode, param.wait)) {
+        if (IsQueuedManualSyncFull(param.mode, param.wait)) { // LCOV_EXCL_BR_LINE
             LOGE("[Syncer] -E_BUSY");
             return -E_BUSY;
         }
@@ -851,9 +890,10 @@ int GenericSyncer::SyncPreCheck(const SyncParma &param) const
 void GenericSyncer::InitSyncOperation(SyncOperation *operation, const SyncParma &param)
 {
     operation->SetIdentifier(syncInterface_->GetIdentifier());
+    operation->SetSyncProcessCallFun(param.onSyncProcess);
     operation->Initialize();
-    operation->OnKill(std::bind(&GenericSyncer::SyncOperationKillCallback, this, operation->GetSyncId()));
-    std::function<void(int)> onFinished = std::bind(&GenericSyncer::OnSyncFinished, this, std::placeholders::_1);
+    operation->OnKill([this, id = operation->GetSyncId()] { SyncOperationKillCallback(id); });
+    std::function<void(int)> onFinished = [this](int syncId) { OnSyncFinished(syncId); };
     operation->SetOnSyncFinished(onFinished);
     operation->SetOnSyncFinalize(param.onFinalize);
     if (param.isQuerySync) {
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.h
index feb52e7a742a8852daf7c7e759063341b075f166..183fbb1fae07da317527fa84820b7ae4751793a5 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/generic_syncer.h
@@ -55,6 +55,9 @@ public:
 
     int Sync(const SyncParma &param, uint64_t connectionId) override;
 
+    // Cancel sync function.
+    int CancelSync(uint32_t syncId) override;
+
     // Remove the operation, with the given syncId, used to clean resource if sync finished or failed.
     int RemoveSyncOperation(int syncId) override;
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/isync_engine.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/isync_engine.h
index 75767eec411432e57039c84576d404bfb5161d90..3859a900d107704c80d087776a83645f816861ba 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/isync_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/isync_engine.h
@@ -72,7 +72,7 @@ public:
     virtual void SetEqualIdentifierMap(const std::string &identifier, const std::vector<std::string> &targets) = 0;
 
     // Add auto subscribe timer when start sync engine, used for auto subscribe failed subscribe task when db online
-    virtual int StartAutoSubscribeTimer() = 0;
+    virtual int StartAutoSubscribeTimer(const ISyncInterface &syncInterface) = 0;
 
     // Stop auto subscribe timer when start sync engine
     virtual void StopAutoSubscribeTimer() = 0;
@@ -101,6 +101,8 @@ public:
 
     virtual void TimeChange() = 0;
 
+    virtual void ClearAllSyncTaskByDevice(const std::string &deviceId) = 0;
+
     virtual int32_t GetResponseTaskCount() = 0;
 protected:
     ~ISyncEngine() override {};
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.cpp
index 693e2bf7cff2ecc81147293c7739e9143fd5fae7..ef1ec281c0067d68cfe89fe62b9a9d3609647ea7 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.cpp
@@ -890,6 +890,7 @@ std::pair<int, Value> Metadata::SerializeLocalMetaData(const LocalMetaData &loca
     value.resize(CalculateLocalMetaDataLength());
     Parcel parcel(value.data(), value.size());
     (void)parcel.WriteUInt32(localMetaData.version);
+    parcel.EightByteAlign();
     (void)parcel.WriteUInt64(localMetaData.localSchemaVersion);
     if (parcel.IsError()) {
         LOGE("[Metadata] Serialize localMetaData failed");
@@ -906,11 +907,13 @@ std::pair<int, LocalMetaData> Metadata::DeSerializeLocalMetaData(const Value &va
     auto &[errCode, meta] = res;
     if (value.empty()) {
         errCode = E_OK;
-        meta.version = SOFTWARE_VERSION_RELEASE_8_0;
         return res;
     }
     Parcel parcel(const_cast<uint8_t *>(value.data()), value.size());
     parcel.ReadUInt32(meta.version);
+    if (meta.version >= LOCAL_META_DATA_VERSION_V2) {
+        parcel.EightByteAlign();
+    }
     parcel.ReadUInt64(meta.localSchemaVersion);
     if (parcel.IsError()) {
         LOGE("[Metadata] DeSerialize localMetaData failed");
@@ -923,6 +926,7 @@ std::pair<int, LocalMetaData> Metadata::DeSerializeLocalMetaData(const Value &va
 uint64_t Metadata::CalculateLocalMetaDataLength()
 {
     uint64_t length = Parcel::GetUInt32Len(); // version
+    length = Parcel::GetEightByteAlign(length);
     length += Parcel::GetUInt64Len(); // local schema version
     return length;
 }
@@ -952,7 +956,7 @@ int Metadata::InitLocalMetaData()
     if (localMetaData.localSchemaVersion != 0) {
         return E_OK;
     }
-    uint64_t curTime = 0;
+    uint64_t curTime = 0u;
     errCode = OS::GetCurrentSysTimeInMicrosecond(curTime);
     if (errCode != E_OK) {
         LOGW("[Metadata] get system time failed when init schema version!");
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.h
index 9a066d7fc08294fae3c29682a360efbad5ba75dd..8c344e790ad538fdabe74694454549f686b7833f 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/meta_data.h
@@ -23,6 +23,7 @@
 
 #include "db_types.h"
 #include "ikvdb_sync_interface.h"
+#include "version.h"
 #include "query_sync_water_mark_helper.h"
 
 namespace DistributedDB {
@@ -39,7 +40,7 @@ struct MetaDataValue {
 };
 
 struct LocalMetaData {
-    uint32_t version = 0; // start at 108
+    uint32_t version = LOCAL_META_DATA_VERSION_V2; // start at 108
     uint64_t localSchemaVersion = 0;
 };
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_data_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_data_sync.cpp
index 3d698600109d49d896ad65e0a85efa18f9c2f2b3..b3949076e122b1dc7aa021734f12a35348af74dd 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_data_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_data_sync.cpp
@@ -156,11 +156,13 @@ uint32_t MultiVerDataSync::CalculateLen(const Message *inMsg)
 int MultiVerDataSync::RegisterTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&MultiVerDataSync::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&MultiVerDataSync::Serialization, std::placeholders::_1,
-                                   std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&MultiVerDataSync::DeSerialization, std::placeholders::_1,
-                                     std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
     return MessageTransform::RegTransformFunction(MULTI_VER_DATA_SYNC_MESSAGE, func);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.cpp
index 54bbe224edf7bf9a93f7676bc008b55e52ccc72d..25d6351edcf1b7f20963ccefa92fdd117303be1c 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.cpp
@@ -18,7 +18,7 @@
 #include "multi_ver_sync_task_context.h"
 
 namespace DistributedDB {
-ISyncTaskContext *MultiVerSyncEngine::CreateSyncTaskContext()
+ISyncTaskContext *MultiVerSyncEngine::CreateSyncTaskContext(const ISyncInterface &syncInterface)
 {
     return new (std::nothrow) MultiVerSyncTaskContext;
 }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.h
index 0c23ae95c44ae1eb316c50a8f4e1c2fadbfcefa7..f29f88e1141e89a0fdb749df9f1fa554d5a45cc1 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_engine.h
@@ -30,7 +30,7 @@ protected:
     ~MultiVerSyncEngine() override {};
 
     // Create a context
-    ISyncTaskContext *CreateSyncTaskContext() override;
+    ISyncTaskContext *CreateSyncTaskContext(const ISyncInterface &syncInterface) override;
 
 private:
     DECLARE_OBJECT_TAG(MultiVerSyncEngine);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_state_machine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_state_machine.cpp
index 51c8b7faa25dafbb2dbe95b02b5cf8dfd47481d7..49df30b6eea4f5afff3cc5bd12f7f1b3ae8b5103 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_state_machine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_state_machine.cpp
@@ -101,8 +101,7 @@ void MultiVerSyncStateMachine::SyncStep()
 {
     RefObject::IncObjRef(context_);
     RefObject::IncObjRef(communicator_);
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask(
-        std::bind(&MultiVerSyncStateMachine::SyncStepInnerLocked, this));
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this] { SyncStepInnerLocked(); });
     if (errCode != E_OK) {
         LOGE("[MultiVerSyncStateMachine] Schedule SyncStep failed");
         RefObject::DecObjRef(communicator_);
@@ -544,8 +543,7 @@ void MultiVerSyncStateMachine::SyncResponseBegin(uint32_t sessionId)
             LOGE("[MultiVerSyncStateMachine][SyncResponseEnd] sessionId existed! exit.");
             return;
         }
-        TimerAction timeOutCallback =
-            std::bind(&MultiVerSyncStateMachine::SyncResponseTimeout, this, std::placeholders::_1);
+        TimerAction timeOutCallback = [this](TimerId timerId) -> int { return SyncResponseTimeout(timerId); };
         // To make sure context_ alive in timeout callback, we should IncObjRef for the context_.
         RefObject::IncObjRef(context_);
         TimerId timerId = 0;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_task_context.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_task_context.cpp
index 604e7b269245299490bba4c14d94942e7d287a22..3a797b27b67c5f7b4574f7d4e81dbf1c2ee8b849 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_task_context.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/multi_ver_sync_task_context.cpp
@@ -52,9 +52,8 @@ int MultiVerSyncTaskContext::Initialize(const std::string &deviceId, ISyncInterf
     }
 
     errCode = stateMachine_->Initialize(this, syncInterface, metadata, communicator);
-    TimerAction timeOutCallback = std::bind(&SyncStateMachine::TimeoutCallback,
-        static_cast<MultiVerSyncStateMachine *>(stateMachine_),
-        std::placeholders::_1);
+    TimerAction timeOutCallback = [stateMachine = static_cast<MultiVerSyncStateMachine *>(stateMachine_)](
+        TimerId timerId) -> int { return stateMachine->TimeoutCallback(timerId); };
     SetTimeoutCallback(timeOutCallback);
     OnKill([this]() { this->KillWait(); });
     {
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/value_slice_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/value_slice_sync.cpp
index 73b973251535ffde26c3df0c237f20038288f429..5176c37754fdae6a6e3f4d30043f851b792667ee 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/value_slice_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/multiver/value_slice_sync.cpp
@@ -156,11 +156,13 @@ uint32_t ValueSliceSync::CalculateLen(const Message *inMsg)
 int ValueSliceSync::RegisterTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&ValueSliceSync::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&ValueSliceSync::Serialization, std::placeholders::_1,
-                                   std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&ValueSliceSync::DeSerialization, std::placeholders::_1,
-                                     std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
     return MessageTransform::RegTransformFunction(VALUE_SLICE_SYNC_MESSAGE, func);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/remote_executor.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/remote_executor.cpp
index b3f4ddd6b03ef0084d4f7ae702782b4d0daca761..10cb8311d38d64fb59698042fc0b0b094a740949 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/remote_executor.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/remote_executor.cpp
@@ -361,7 +361,7 @@ bool RemoteExecutor::CheckTaskExeStatus(const std::string &device)
 uint32_t RemoteExecutor::GenerateSessionId()
 {
     uint32_t sessionId = Hash::Hash32Func(std::to_string(TimeHelper::GetSysCurrentTime()));
-    while (taskMap_.find(sessionId) != taskMap_.end()) {
+    while (taskMap_.find(sessionId) != taskMap_.end()) { // LCOV_EXCL_BR_LINE
         sessionId++;
         if (sessionId == 0) { // if over flow start with 1
             sessionId++;
@@ -449,24 +449,24 @@ void RemoteExecutor::DoRollBack(uint32_t sessionId)
 {
     Task task;
     std::lock_guard<std::mutex> autoLock(taskLock_);
-    if (taskMap_.find(sessionId) == taskMap_.end()) {
+    if (taskMap_.find(sessionId) == taskMap_.end()) { // LCOV_EXCL_BR_LINE
         return;
     }
     task = taskMap_[sessionId];
-    if (task.status != Status::WAITING) {
+    if (task.status != Status::WAITING) { // LCOV_EXCL_BR_LINE
         // task is execute, abort roll back
         return;
     }
     taskMap_.erase(sessionId);
 
     auto iter = searchTaskQueue_[task.target].begin();
-    while (iter != searchTaskQueue_[task.target].end()) {
-        if ((*iter) == sessionId) {
+    while (iter != searchTaskQueue_[task.target].end()) { // LCOV_EXCL_BR_LINE
+        if ((*iter) == sessionId) { // LCOV_EXCL_BR_LINE
             break;
         }
         iter++;
     }
-    if (iter != searchTaskQueue_[task.target].end()) {
+    if (iter != searchTaskQueue_[task.target].end()) { // LCOV_EXCL_BR_LINE
         searchTaskQueue_[task.target].erase(iter);
     }
     // this task should not in workingSet
@@ -617,7 +617,7 @@ void RemoteExecutor::StartTimer(uint64_t timeout, uint32_t sessionId)
 {
     TimerId timerId = 0u;
     RefObject::IncObjRef(this);
-    TimerAction timeoutCallBack = std::bind(&RemoteExecutor::TimeoutCallBack, this, std::placeholders::_1);
+    TimerAction timeoutCallBack = [this](TimerId timerId) { return TimeoutCallBack(timerId); };
     int errCode = RuntimeContext::GetInstance()->SetTimer(timeout, timeoutCallBack, [this]() {
         RefObject::DecObjRef(this);
     }, timerId);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_message_schedule.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_message_schedule.cpp
index 5077c233a26a1564d00d2dfd599af27fa0ced0c2..da64cdb2510d6f9b3bc95b3b52256a890e2df6cb 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_message_schedule.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_message_schedule.cpp
@@ -228,7 +228,7 @@ void SingleVerDataMessageSchedule::StartTimer(SingleVerSyncTaskContext *context)
     std::lock_guard<std::mutex> lock(lock_);
     TimerId timerId = 0;
     RefObject::IncObjRef(context);
-    TimerAction timeOutCallback = std::bind(&SingleVerDataMessageSchedule::TimeOut, this, std::placeholders::_1);
+    TimerAction timeOutCallback = [this](TimerId timerId) { return TimeOut(timerId); };
     int errCode = RuntimeContext::GetInstance()->SetTimer(IDLE_TIME_OUT, timeOutCallback,
         [context]() {
             int errCode = RuntimeContext::GetInstance()->ScheduleTask([context]() {
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.cpp
index f66e41b1a88576cdfdce2272820040bc34baeb25..98c60e9c66cad4d0d3134eaab35f929d808106dc 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.cpp
@@ -14,13 +14,15 @@
  */
 
 #include "single_ver_data_packet.h"
+
+#include "generic_single_ver_kv_entry.h"
 #include "icommunicator.h"
-#include "single_ver_kvdb_sync_interface.h"
+#include "parcel.h"
 #include "query_sync_object.h"
-#include "generic_single_ver_kv_entry.h"
+#include "single_ver_data_sync_utils.h"
+#include "single_ver_kvdb_sync_interface.h"
 #include "sync_types.h"
 #include "version.h"
-#include "parcel.h"
 
 namespace DistributedDB {
 DataRequestPacket::~DataRequestPacket()
@@ -197,10 +199,12 @@ uint32_t DataRequestPacket::CalculateLen(uint32_t messageId) const
         totalLen += Parcel::GetIntLen();   // security label
         totalLen += Parcel::GetIntLen();   // security flag
     }
-    if (totalLen > INT32_MAX) {
-        return 0;
+    if (SingleVerDataSyncUtils::IsSupportRequestTotal(version_)) {
+        totalLen += Parcel::GetUInt32Len(); // totalDataCount
+        totalLen = Parcel::GetEightByteAlign(totalLen);
     }
-    return totalLen;
+    
+    return totalLen > INT32_MAX ? 0 : totalLen;
 }
 
 void DataRequestPacket::SetFlag(uint32_t flag)
@@ -353,6 +357,16 @@ SecurityOption DataRequestPacket::GetSecurityOption() const
     return securityOption_;
 }
 
+void DataRequestPacket::SetTotalDataCount(uint32_t total)
+{
+    totalDataCount_ = total;
+}
+
+uint32_t DataRequestPacket::GetTotalDataCount() const
+{
+    return totalDataCount_;
+}
+
 void DataAckPacket::SetData(uint64_t data)
 {
     data_ = data;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.h
index 9b3ba510b132f4029b2fb0c14894d4141800a122..63b57372f5d4dda2f9144a1886c2d828fc04ca45 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_packet.h
@@ -123,6 +123,9 @@ public:
 
     void SetSecurityOption(const SecurityOption &option);
     SecurityOption GetSecurityOption() const;
+
+    void SetTotalDataCount(uint32_t total);
+    uint32_t GetTotalDataCount() const;
 protected:
     std::vector<SendDataItem> data_;
     WaterMark endWaterMark_ = 0;
@@ -145,6 +148,7 @@ protected:
     int64_t systemTimeOffset_ = 0; // sender device time offset with receiver, add in 109
     int64_t senderTimeOffset_ = 0; // sender local time offset, add in 109
     SecurityOption securityOption_;
+    uint32_t totalDataCount_ = 0;
     static const uint32_t IS_LAST_SEQUENCE = 0x1; // bit 0 used for isLastSequence, 1: is last, 0: not last
     static const uint32_t IS_UPDATE_WATER = 0x2; // bit 1 used for update watermark, 0: update, 1: not update
     static const uint32_t IS_COMPRESS_DATA = 0x4; // bit 3 used for compress data, 0: raw data, 1: compress data
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.cpp
index bd4e90ec4aeb3f4f41f81ad00e1015743a53d16f..75f8680d46d8c97e593d90bfa686edd0bab7e6ad 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.cpp
@@ -83,6 +83,7 @@ int SingleVerDataSync::SyncStart(int mode, SingleVerSyncTaskContext *context)
     } else if (tmpMode == SyncModeType::PULL) {
         errCode = PullRequestStart(context);
     } else {
+        SingleVerDataSyncUtils::CacheInitWaterMark(context, this);
         errCode = PullResponseStart(context);
     }
     if (context->IsSkipTimeoutError(errCode)) {
@@ -1014,6 +1015,8 @@ int SingleVerDataSync::DataRequestRecv(SingleVerSyncTaskContext *context, const
         (void)SendDataAck(context, message, errCode, dataTime.endTime);
         return errCode;
     }
+    SingleVerDataSyncUtils::UpdateSyncProcess(context, packet, data.size());
+
     if (pullEndWatermark > 0 && !storage_->IsReadable()) { // pull mode
         pullEndWatermark = 0;
         errCode = SendDataAck(context, message, -E_EKEYREVOKED, dataTime.endTime);
@@ -1063,8 +1066,9 @@ int SingleVerDataSync::SendDataPacket(SyncType syncType, DataRequestPacket *pack
     if (performance != nullptr) {
         performance->StepTimeRecordStart(PT_TEST_RECORDS::RECORD_DATA_SEND_REQUEST_TO_ACK_RECV);
     }
-    CommErrHandler handler = std::bind(&SyncTaskContext::CommErrHandlerFunc, std::placeholders::_1,
-        context, message->GetSessionId());
+    CommErrHandler handler = [this, context, sessionId = message->GetSessionId()](int ret) {
+        SyncTaskContext::CommErrHandlerFunc(ret, context, sessionId);
+    };
     errCode = Send(context, message, handler, packetLen);
     if (errCode != E_OK) {
         delete message;
@@ -1084,6 +1088,15 @@ int SingleVerDataSync::SendPullResponseDataPkt(int ackCode, SyncEntry &syncOutDa
     }
     SyncType syncType = (context->IsQuerySync()) ? SyncType::QUERY_SYNC_TYPE : SyncType::MANUAL_FULL_SYNC_TYPE;
     FillDataRequestPacket(packet, context, syncOutData, ackCode, SyncModeType::RESPONSE_PULL);
+
+    if ((ackCode == E_OK || ackCode == SEND_FINISHED) &&
+        SingleVerDataSyncUtils::IsSupportRequestTotal(packet->GetVersion())) {
+        uint32_t total = 0u;
+        (void)SingleVerDataSyncUtils::GetUnsyncTotal(context, storage_, total);
+        LOGD("[SendPullResponseDataPkt] GetUnsyncTotal total=%u", total);
+        packet->SetTotalDataCount(total);
+    }
+    
     uint32_t packetLen = packet->CalculateLen(SingleVerDataSyncUtils::GetMessageId(syncType));
     Message *message = new (std::nothrow) Message(SingleVerDataSyncUtils::GetMessageId(syncType));
     if (message == nullptr) {
@@ -1449,8 +1462,9 @@ int SingleVerDataSync::SendReSendPacket(DataRequestPacket *packet, SingleVerSync
         return errCode;
     }
     SingleVerDataSyncUtils::SetMessageHeadInfo(*message, TYPE_REQUEST, context->GetDeviceId(), sequenceId, sessionId);
-    CommErrHandler handler = std::bind(&SyncTaskContext::CommErrHandlerFunc, std::placeholders::_1,
-        context, message->GetSessionId());
+    CommErrHandler handler = [this, context, sessionId = message->GetSessionId()](int ret) {
+        SyncTaskContext::CommErrHandlerFunc(ret, context, sessionId);
+    };
     errCode = Send(context, message, handler, packetLen);
     if (errCode != E_OK) {
         delete message;
@@ -1699,7 +1713,7 @@ void SingleVerDataSync::UpdateMtuSize()
     mtuSize_ = communicateHandle_->GetCommunicatorMtuSize(deviceId_) * 9 / 10; // get the 9/10 of the size
 }
 
-void SingleVerDataSync::FillRequestReSendPacket(const SingleVerSyncTaskContext *context, DataRequestPacket *packet,
+void SingleVerDataSync::FillRequestReSendPacket(SingleVerSyncTaskContext *context, DataRequestPacket *packet,
     DataSyncReSendInfo reSendInfo, SyncEntry &syncData, int sendCode)
 {
     SingleVerDataSyncUtils::SetDataRequestCommonInfo(*context, *storage_, *packet, metadata_);
@@ -1746,6 +1760,17 @@ void SingleVerDataSync::FillRequestReSendPacket(const SingleVerSyncTaskContext *
         packet->SetCompressDataMark();
         packet->SetCompressAlgo(curAlgo);
     }
+    FillRequestReSendPacketV2(context, packet);
+}
+
+void SingleVerDataSync::FillRequestReSendPacketV2(SingleVerSyncTaskContext *context, DataRequestPacket *packet)
+{
+    if (context->GetMode() == SyncModeType::RESPONSE_PULL &&
+        SingleVerDataSyncUtils::IsSupportRequestTotal(packet->GetVersion())) {
+        uint32_t total = 0u;
+        (void)SingleVerDataSyncUtils::GetUnsyncTotal(context, storage_, total);
+        packet->SetTotalDataCount(total);
+    }
 }
 
 DataSizeSpecInfo SingleVerDataSync::GetDataSizeSpecInfo(size_t packetSize)
@@ -1907,8 +1932,9 @@ int SingleVerDataSync::SendControlPacket(ControlRequestPacket *packet, SingleVer
     }
     SingleVerDataSyncUtils::SetMessageHeadInfo(*message, TYPE_REQUEST, context->GetDeviceId(),
         context->GetSequenceId(), context->GetRequestSessionId());
-    CommErrHandler handler = std::bind(&SyncTaskContext::CommErrHandlerFunc, std::placeholders::_1,
-        context, message->GetSessionId());
+    CommErrHandler handler = [this, context, sessionId = message->GetSessionId()](int ret) {
+        SyncTaskContext::CommErrHandlerFunc(ret, context, sessionId);
+    };
     errCode = Send(context, message, handler, packetLen);
     if (errCode != E_OK) {
         delete message;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.h
index c8b7d77534a9b9f9690a4965b5e984b6b08e7372..e98503c76c5e1848a4bc8af2a2b61853e1f98b88 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync.h
@@ -117,6 +117,11 @@ public:
 
     void ClearDataMsg();
 
+    void GetLocalWaterMark(SyncType syncType, const std::string &queryIdentify, const SingleVerSyncTaskContext *context,
+        WaterMark &warterMark) const;
+    
+    void GetLocalDeleteSyncWaterMark(const SingleVerSyncTaskContext *context, WaterMark &waterMark) const;
+
 protected:
     static const int SEND_FINISHED = 0xff;
     static const int LOCAL_WATER_MARK_NOT_INIT = 0xaa;
@@ -168,16 +173,11 @@ protected:
     int SaveLocalWaterMark(SyncType syncType, const SingleVerSyncTaskContext *context,
         SyncTimeRange dataTimeRange, bool isCheckBeforUpdate = false) const;
 
-    void GetLocalWaterMark(SyncType syncType, const std::string &queryIdentify, const SingleVerSyncTaskContext *context,
-        WaterMark &waterMark) const;
-
     void GetPeerWaterMark(SyncType syncType, const std::string &queryIdentify, const DeviceID &deviceId,
         WaterMark &waterMark) const;
 
     void GetPeerDeleteSyncWaterMark(const DeviceID &deviceId, WaterMark &waterMark);
 
-    void GetLocalDeleteSyncWaterMark(const SingleVerSyncTaskContext *context, WaterMark &waterMark) const;
-
     int RemoveDeviceDataHandle(SingleVerSyncTaskContext *context, const Message *message, WaterMark maxSendDataTime);
 
     int DealRemoveDeviceDataByAck(SingleVerSyncTaskContext *context, WaterMark ackWaterMark,
@@ -227,9 +227,11 @@ protected:
 
     virtual void UpdateSendInfo(SyncTimeRange dataTimeRange, SingleVerSyncTaskContext *context);
 
-    void FillRequestReSendPacket(const SingleVerSyncTaskContext *context, DataRequestPacket *packet,
+    void FillRequestReSendPacket(SingleVerSyncTaskContext *context, DataRequestPacket *packet,
         DataSyncReSendInfo reSendInfo, SyncEntry &syncData, int sendCode);
 
+    void FillRequestReSendPacketV2(SingleVerSyncTaskContext *context, DataRequestPacket *packet);
+
     void UpdateMtuSize();
 
     DataSizeSpecInfo GetDataSizeSpecInfo(size_t packetSize);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.cpp
index b61f0026c51e53ba2b7d05272e5eda65da8f3bc6..8a729af6e95e59a64a61668788c4d89c3be51e46 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.cpp
@@ -509,6 +509,11 @@ std::pair<TimeOffset, TimeOffset> SingleVerDataSyncUtils::GetTimeOffsetFromReque
     std::pair<TimeOffset, TimeOffset> res;
     auto &[systemOffset, senderLocalOffset] = res;
     const DataRequestPacket *packet = message->GetObject<DataRequestPacket>();
+    if (packet == nullptr) {
+        systemOffset = 0;
+        senderLocalOffset = 0;
+        return res;
+    }
     systemOffset = packet->GetSystemTimeOffset();
     senderLocalOffset = packet->GetSenderTimeOffset();
     return res;
@@ -523,9 +528,8 @@ void SingleVerDataSyncUtils::RecordClientId(const SingleVerSyncTaskContext &cont
         storage.GetDbProperties().GetStringProp(DBProperties::STORE_ID, "")
     };
     std::string clientId;
-    int errCode = E_OK;
     if (RuntimeContext::GetInstance()->TranslateDeviceId(context.GetDeviceId(), info, clientId) == E_OK) {
-        errCode = metadata->SaveClientId(context.GetDeviceId(), clientId);
+        int errCode = metadata->SaveClientId(context.GetDeviceId(), clientId);
         if (errCode != E_OK) {
             LOGW("[DataSync] record clientId failed %d", errCode);
         }
@@ -572,4 +576,67 @@ int SingleVerDataSyncUtils::SchemaVersionMatchCheck(const SingleVerSyncTaskConte
     }
     return E_OK;
 }
+
+int SingleVerDataSyncUtils::GetUnsyncTotal(SingleVerSyncTaskContext *context, const SyncGenericInterface *storage,
+    uint32_t &total)
+{
+    SyncTimeRange waterRange;
+    WaterMark startMark = context->GetInitWaterMark();
+    if ((waterRange.endTime == 0) || (startMark > waterRange.endTime)) {
+        return E_OK;
+    }
+
+    waterRange.beginTime = startMark;
+    waterRange.deleteBeginTime = context->GetInitDeletedMark();
+    return GetUnsyncTotal(context, storage, waterRange, total);
+}
+
+int SingleVerDataSyncUtils::GetUnsyncTotal(SingleVerSyncTaskContext *context, const SyncGenericInterface *storage,
+    SyncTimeRange &waterMarkInfo, uint32_t &total)
+{
+    int errCode;
+    SyncType curType = (context->IsQuerySync()) ? SyncType::QUERY_SYNC_TYPE : SyncType::MANUAL_FULL_SYNC_TYPE;
+    if (curType != SyncType::QUERY_SYNC_TYPE) {
+        errCode = storage->GetUnSyncTotal(waterMarkInfo.beginTime, waterMarkInfo.endTime, total);
+    } else {
+        QuerySyncObject queryObj = context->GetQuery();
+        errCode = storage->GetUnSyncTotal(queryObj, waterMarkInfo, total);
+    }
+    if (errCode != E_OK) {
+        LOGE("[DataSync][GetUnsyncTotal] Get unsync data num failed,errCode=%d", errCode);
+    }
+    return errCode;
+}
+
+bool SingleVerDataSyncUtils::IsSupportRequestTotal(uint32_t version)
+{
+    return version >= SOFTWARE_VERSION_RELEASE_10_0;
+}
+
+void SingleVerDataSyncUtils::UpdateSyncProcess(SingleVerSyncTaskContext *context, const DataRequestPacket *packet,
+    uint32_t dataSize)
+{
+    LOGD("[DataSync][UpdateSyncProcess] mode=%d, total=%" PRIu64 ", size=%" PRIu64, packet->GetMode(),
+        packet->GetTotalDataCount(), dataSize);
+    if (packet->GetMode() == SyncModeType::PUSH || packet->GetMode() == SyncModeType::QUERY_PUSH) {
+        // save total count to sync process
+        if (packet->GetTotalDataCount() > 0) {
+            context->SetOperationSyncProcessTotal(context->GetDeviceId(), packet->GetTotalDataCount());
+        }
+        context->UpdateOperationFinishedCount(context->GetDeviceId(), dataSize);
+    }
+}
+
+void SingleVerDataSyncUtils::CacheInitWaterMark(SingleVerSyncTaskContext *context, SingleVerDataSync *dataSync)
+{
+    SyncType curType = (context->IsQuerySync()) ? SyncType::QUERY_SYNC_TYPE : SyncType::MANUAL_FULL_SYNC_TYPE;
+    WaterMark startMark = 0;
+    dataSync->GetLocalWaterMark(curType, context->GetQuerySyncId(), context, startMark);
+    context->SetInitWaterMark(startMark);
+
+    WaterMark deletedMark = 0;
+    dataSync->GetLocalDeleteSyncWaterMark(context, deletedMark);
+    context->SetInitDeletedMark(deletedMark);
+    LOGI("[SingleVerDataSync][CacheInitWaterMark] startMark %" PRIu64 " deletedMark %" PRIu64, startMark, deletedMark);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.h
index ad7c03eadf8b662051e2b4195e80cadd6c81b426..275b6d8e54079af1842e88c9f2e7f06aaa82f154 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_data_sync_utils.h
@@ -17,6 +17,7 @@
 
 #include "message.h"
 #include "single_ver_data_packet.h"
+#include "single_ver_data_sync.h"
 #include "single_ver_sync_task_context.h"
 namespace DistributedDB {
 class SingleVerDataSyncUtils {
@@ -102,6 +103,18 @@ public:
 
     static int SchemaVersionMatchCheck(const SingleVerSyncTaskContext &context, const DataRequestPacket &packet,
         std::shared_ptr<Metadata> &metadata);
+
+    static int GetUnsyncTotal(SingleVerSyncTaskContext *context, const SyncGenericInterface *storage,
+        uint32_t &total);
+    static int GetUnsyncTotal(SingleVerSyncTaskContext *context, const SyncGenericInterface *storage,
+        SyncTimeRange &waterMarkInfo, uint32_t &total);
+    
+    static bool IsSupportRequestTotal(uint32_t version);
+
+    static void UpdateSyncProcess(SingleVerSyncTaskContext *context, const DataRequestPacket *packet,
+        uint32_t dataSize);
+    
+    static void CacheInitWaterMark(SingleVerSyncTaskContext *context, SingleVerDataSync *dataSync);
 private:
     static int RunPermissionCheckInner(const SingleVerSyncTaskContext *context, const SyncGenericInterface* storage,
         const std::string &label, const DataRequestPacket *packet, int mode);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_kv_syncer.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_kv_syncer.cpp
index 648d6b10926813e8eae7eebf74538c3d68853d32..d52e36d0a6cae232b36397c11257f84b4109e928 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_kv_syncer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_kv_syncer.cpp
@@ -194,7 +194,7 @@ int SingleVerKVSyncer::SyncConditionCheck(const SyncParma &param, const ISyncEng
 
 void SingleVerKVSyncer::TriggerSubscribe(const std::string &device, const QuerySyncObject &query)
 {
-    if (!initialized_) {
+    if (!initialized_) { // LCOV_EXCL_BR_LINE
         LOGE("[Syncer] Syncer has not Init");
         return;
     }
@@ -211,12 +211,12 @@ void SingleVerKVSyncer::TriggerSubscribe(const std::string &device, const QueryS
         param.isQuerySync = true;
         param.syncQuery = query;
         int errCode = Sync(param);
-        if (errCode != E_OK) {
+        if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
             LOGE("[SingleVerKVSyncer] subscribe start by RemoteDataChanged failed err %d", errCode);
         }
         RefObject::DecObjRef(syncEngine_);
     });
-    if (retCode != E_OK) {
+    if (retCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[Syncer] triggler query subscribe start failed err %d", retCode);
         RefObject::DecObjRef(syncEngine_);
     }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_relational_syncer.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_relational_syncer.cpp
index 9cfcf588b7f1898dbdecada66576be5fdee39973..85eb16788d8834ed997683a566b35ce18fbcd66e 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_relational_syncer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_relational_syncer.cpp
@@ -25,7 +25,7 @@ int SingleVerRelationalSyncer::Initialize(ISyncInterface *syncInterface, bool is
     if (errCode != E_OK) {
         return errCode;
     }
-    auto callback = std::bind(&SingleVerRelationalSyncer::SchemaChangeCallback, this);
+    auto callback = [this] { SchemaChangeCallback(); };
     return static_cast<RelationalDBSyncInterface *>(syncInterface)->
         RegisterSchemaChangedCallback(callback);
 }
@@ -78,8 +78,9 @@ int SingleVerRelationalSyncer::GenerateEachSyncTask(const SyncParma &param, uint
         LOGI("[SingleVerRelationalSyncer] SubSyncId %" PRIu32 " create by SyncId %" PRIu32 ", hashTableName = %s",
             subSyncId, syncId, STR_MASK(DBCommon::TransferStringToHex(hashTableName)));
         subParam.syncQuery = table;
-        subParam.onComplete = std::bind(&SingleVerRelationalSyncer::DoOnSubSyncComplete, this, subSyncId,
-            syncId, param, std::placeholders::_1);
+        subParam.onComplete = [this, subSyncId, syncId, param](const std::map<std::string, int> &devicesMap) {
+            DoOnSubSyncComplete(subSyncId, syncId, param, devicesMap);
+        };
         {
             std::lock_guard<std::mutex> lockGuard(syncMapLock_);
             fullSyncIdMap_[syncId].insert(subSyncId);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_serialize_manager.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_serialize_manager.cpp
index baf07292952dbe94c686806cdf321122b81c5248..186c9f779e5ceff0262c5208e5596faa408d5c1f 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_serialize_manager.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_serialize_manager.cpp
@@ -22,6 +22,7 @@
 #include "message_transform.h"
 #include "parcel.h"
 #include "remote_executor_packet.h"
+#include "single_ver_data_sync_utils.h"
 #include "sync_types.h"
 #include "version.h"
 
@@ -737,11 +738,13 @@ ERROR:
 int SingleVerSerializeManager::RegisterCommunicatorTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&SingleVerSerializeManager::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&SingleVerSerializeManager::Serialization, std::placeholders::_1,
-        std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&SingleVerSerializeManager::DeSerialization, std::placeholders::_1,
-        std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
 
     static std::vector<MessageId> messageIds = {
         QUERY_SYNC_MESSAGE, DATA_SYNC_MESSAGE, CONTROL_SYNC_MESSAGE, REMOTE_EXECUTE_MESSAGE
@@ -761,11 +764,13 @@ int SingleVerSerializeManager::RegisterCommunicatorTransformFunc()
 void SingleVerSerializeManager::RegisterInnerTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&SingleVerSerializeManager::ISyncPacketCalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&SingleVerSerializeManager::ISyncPacketSerialization,
-        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&SingleVerSerializeManager::ISyncPacketDeSerialization,
-        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return ISyncPacketCalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return ISyncPacketSerialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return ISyncPacketDeSerialization(buffer, length, inMsg);
+    };
     std::lock_guard<std::mutex> autoLock(handlesLock_);
     messageHandles_.emplace(static_cast<uint32_t>(REMOTE_EXECUTE_MESSAGE), func);
 }
@@ -934,6 +939,12 @@ int SingleVerSerializeManager::DataPacketInnerDeSerialization(DataRequestPacket
         parcel.ReadInt(option.securityFlag);
         packet->SetSecurityOption(option);
     }
+    if (SingleVerDataSyncUtils::IsSupportRequestTotal(packet->GetVersion())) {
+        uint32_t total = 0u;
+        parcel.ReadUInt32(total);
+        parcel.EightByteAlign();
+        packet->SetTotalDataCount(total);
+    }
     return errCode;
 }
 
@@ -966,6 +977,10 @@ int SingleVerSerializeManager::DataPacketInnerSerialization(const DataRequestPac
             return -E_PARSE_FAIL;
         }
     }
+    if (SingleVerDataSyncUtils::IsSupportRequestTotal(packet->GetVersion())) {
+        parcel.WriteUInt32(packet->GetTotalDataCount());
+        parcel.EightByteAlign();
+    }
     return E_OK;
 }
 }  // namespace DistributedDB
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.cpp
index 356f4c1014c840ae7c795bc5acd211183125eb1a..c5254c5af0444997fa669fa9f42130d523133930 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.cpp
@@ -21,10 +21,10 @@
 #include "single_ver_sync_task_context.h"
 
 namespace DistributedDB {
-ISyncTaskContext *SingleVerSyncEngine::CreateSyncTaskContext()
+ISyncTaskContext *SingleVerSyncEngine::CreateSyncTaskContext(const ISyncInterface &syncInterface)
 {
     SingleVerSyncTaskContext *context = nullptr;
-    switch (syncInterface_->GetInterfaceType()) {
+    switch (syncInterface.GetInterfaceType()) {
         case ISyncInterface::SYNC_SVD:
             context = new (std::nothrow) SingleVerKvSyncTaskContext();
             break;
@@ -54,15 +54,15 @@ void SingleVerSyncEngine::EnableClearRemoteStaleData(bool enable)
     std::unique_lock<std::mutex> lock(contextMapLock_);
     for (auto &iter : syncTaskContextMap_) {
         auto context = static_cast<SingleVerSyncTaskContext *>(iter.second);
-        if (context != nullptr) {
+        if (context != nullptr) { // LCOV_EXCL_BR_LINE
             context->EnableClearRemoteStaleData(enable);
         }
     }
 }
 
-int SingleVerSyncEngine::StartAutoSubscribeTimer()
+int SingleVerSyncEngine::StartAutoSubscribeTimer(const ISyncInterface &syncInterface)
 {
-    if (syncInterface_->IsSupportSubscribe() == -E_NOT_SUPPORT) {
+    if (syncInterface.IsSupportSubscribe() == -E_NOT_SUPPORT) {
         LOGI("[StartAutoSubscribeTimer] no need to start subscribe timer");
         return E_OK;
     }
@@ -73,7 +73,7 @@ int SingleVerSyncEngine::StartAutoSubscribeTimer()
         return -E_INTERNAL_ERROR;
     }
     TimerId timerId = 0;
-    TimerAction timeOutCallback = std::bind(&SingleVerSyncEngine::SubscribeTimeOut, this, std::placeholders::_1);
+    TimerAction timeOutCallback = [this](TimerId id) { return SubscribeTimeOut(id); };
     int errCode = RuntimeContext::GetInstance()->SetTimer(SUBSCRIBE_TRIGGER_TIME_OUT, timeOutCallback, nullptr,
         timerId);
     if (errCode != E_OK) {
@@ -101,13 +101,13 @@ void SingleVerSyncEngine::StopAutoSubscribeTimer()
 
 int SingleVerSyncEngine::SubscribeTimeOut(TimerId id)
 {
-    if (!queryAutoSyncCallback_) {
+    if (!queryAutoSyncCallback_) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
     std::lock_guard<std::mutex> lockGuard(timerLock_);
     std::map<std::string, std::vector<QuerySyncObject>> allSyncQueries;
     GetAllUnFinishSubQueries(allSyncQueries);
-    if (allSyncQueries.empty()) {
+    if (allSyncQueries.empty()) { // LCOV_EXCL_BR_LINE
         return E_OK;
     }
     for (const auto &item : allSyncQueries) {
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.h
index 1368e2a03e37912ea71db63e009540dbd6347a05..7ae4abd209ed8aba3780ec4a949042623615b033 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_engine.h
@@ -27,7 +27,7 @@ public:
     void EnableClearRemoteStaleData(bool enable);
 
     // used by SingleVerKVSyncer when db online
-    int StartAutoSubscribeTimer() override;
+    int StartAutoSubscribeTimer(const ISyncInterface &syncInterface) override;
 
     // used by SingleVerKVSyncer when remote/local db closed
     void StopAutoSubscribeTimer() override;
@@ -39,7 +39,7 @@ protected:
     ~SingleVerSyncEngine() override {};
 
     // Create a context
-    ISyncTaskContext *CreateSyncTaskContext() override;
+    ISyncTaskContext *CreateSyncTaskContext(const ISyncInterface &syncInterface) override;
 
 private:
     DECLARE_OBJECT_TAG(SingleVerSyncEngine);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_state_machine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_state_machine.cpp
index 1daa1d1bae76244c0e142c64783300b9a288f0df..81d63f122a7bd94fdb6a75d652ff144c364b507d 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_state_machine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_state_machine.cpp
@@ -169,8 +169,7 @@ void SingleVerSyncStateMachine::SyncStep()
 {
     RefObject::IncObjRef(context_);
     RefObject::IncObjRef(communicator_);
-    int errCode = RuntimeContext::GetInstance()->ScheduleTask(
-        std::bind(&SingleVerSyncStateMachine::SyncStepInnerLocked, this));
+    int errCode = RuntimeContext::GetInstance()->ScheduleTask([this] { SyncStepInnerLocked(); });
     if (errCode != E_OK) {
         LOGE("[StateMachine][SyncStep] Schedule SyncStep failed");
         RefObject::DecObjRef(communicator_);
@@ -358,17 +357,15 @@ void SingleVerSyncStateMachine::InitStateSwitchTable(uint32_t version,
 
 void SingleVerSyncStateMachine::InitStateMapping()
 {
-    stateMapping_[TIME_SYNC] = std::bind(&SingleVerSyncStateMachine::DoTimeSync, this);
-    stateMapping_[ABILITY_SYNC] = std::bind(&SingleVerSyncStateMachine::DoAbilitySync, this);
-    stateMapping_[WAIT_FOR_RECEIVE_DATA_FINISH] = std::bind(&SingleVerSyncStateMachine::DoWaitForDataRecv, this);
-    stateMapping_[SYNC_TASK_FINISHED] = std::bind(&SingleVerSyncStateMachine::DoSyncTaskFinished, this);
-    stateMapping_[SYNC_TIME_OUT] = std::bind(&SingleVerSyncStateMachine::DoTimeout, this);
-    stateMapping_[INNER_ERR] = std::bind(&SingleVerSyncStateMachine::DoInnerErr, this);
-    stateMapping_[START_INITIACTIVE_DATA_SYNC] =
-        std::bind(&SingleVerSyncStateMachine::DoInitiactiveDataSyncWithSlidingWindow, this);
-    stateMapping_[START_PASSIVE_DATA_SYNC] =
-        std::bind(&SingleVerSyncStateMachine::DoPassiveDataSyncWithSlidingWindow, this);
-    stateMapping_[SYNC_CONTROL_CMD] = std::bind(&SingleVerSyncStateMachine::DoInitiactiveControlSync, this);
+    stateMapping_[TIME_SYNC] = [this] { return DoTimeSync(); };
+    stateMapping_[ABILITY_SYNC] = [this] { return DoAbilitySync(); };
+    stateMapping_[WAIT_FOR_RECEIVE_DATA_FINISH] = [this] { return DoWaitForDataRecv(); };
+    stateMapping_[SYNC_TASK_FINISHED] = [this] { return DoSyncTaskFinished(); };
+    stateMapping_[SYNC_TIME_OUT] = [this] { return DoTimeout(); };
+    stateMapping_[INNER_ERR] = [this] { return DoInnerErr(); };
+    stateMapping_[START_INITIACTIVE_DATA_SYNC] = [this] { return DoInitiactiveDataSyncWithSlidingWindow(); };
+    stateMapping_[START_PASSIVE_DATA_SYNC] = [this] { return DoPassiveDataSyncWithSlidingWindow(); };
+    stateMapping_[SYNC_CONTROL_CMD] = [this] { return DoInitiactiveControlSync(); };
 }
 
 Event SingleVerSyncStateMachine::DoInitiactiveDataSyncWithSlidingWindow() const
@@ -480,8 +477,9 @@ Event SingleVerSyncStateMachine::DoTimeSync() const
         CommErrHandler handler = nullptr;
         // Auto sync need do retry don't use errHandler to return.
         if (!context_->IsAutoSync()) {
-            handler = std::bind(&SyncTaskContext::CommErrHandlerFunc, std::placeholders::_1,
-                context_, context_->GetRequestSessionId());
+            handler = [this, context = context_, requestSessionId = context_->GetRequestSessionId()](int ret) {
+                SyncTaskContext::CommErrHandlerFunc(ret, context, requestSessionId);
+            };
         }
         int errCode = timeSync_->SyncStart(handler, context_->GetRequestSessionId());
         if (errCode == E_OK) {
@@ -511,8 +509,9 @@ Event SingleVerSyncStateMachine::DoAbilitySync() const
         return GetEventAfterTimeSync(context_->GetMode());
     }
 
-    CommErrHandler handler = std::bind(&SyncTaskContext::CommErrHandlerFunc, std::placeholders::_1,
-        context_, context_->GetRequestSessionId());
+    CommErrHandler handler = [this, context = context_, requestSessionId = context_->GetRequestSessionId()](int ret) {
+        SyncTaskContext::CommErrHandlerFunc(ret, context, requestSessionId);
+    };
     LOGI("[StateMachine][AbilitySync] start abilitySync,label=%s,dev=%s", dataSync_->GetLabel().c_str(),
         STR_MASK(context_->GetDeviceId()));
     errCode = abilitySync_->SyncStart(context_->GetRequestSessionId(), context_->GetSequenceId(),
@@ -1097,7 +1096,7 @@ void SingleVerSyncStateMachine::PushPullDataRequestEvokeErrHandle()
 {
     // the pushpull sync task should wait for send finished after remote dev get data occur E_EKEYREVOKED error.
     if (context_->GetRemoteSoftwareVersion() > SOFTWARE_VERSION_RELEASE_2_0 &&
-        SyncOperation::TransferSyncMode(context_->GetMode()) == SyncModeType::PUSH_AND_PULL) {
+        SyncOperation::TransferSyncMode(context_->GetMode()) == SyncModeType::PUSH_AND_PULL) { // LCOV_EXCL_BR_LINE
         LOGI("data request errCode = %d, wait for send finished", -E_EKEYREVOKED);
         context_->SetTaskErrCode(-E_EKEYREVOKED);
         context_->SetOperationStatus(SyncOperation::OP_RECV_FINISHED);
@@ -1149,7 +1148,7 @@ void SingleVerSyncStateMachine::DataRecvErrCodeHandle(uint32_t sessionId, int er
 
 bool SingleVerSyncStateMachine::AbilityMsgSessionIdCheck(const Message *inMsg)
 {
-    if (inMsg != nullptr && inMsg->GetSessionId() == context_->GetRequestSessionId()) {
+    if (inMsg != nullptr && inMsg->GetSessionId() == context_->GetRequestSessionId()) { // LCOV_EXCL_BR_LINE
         return true;
     }
     LOGE("[AbilitySync] session check failed,dev=%s", STR_MASK(context_->GetDeviceId()));
@@ -1158,7 +1157,7 @@ bool SingleVerSyncStateMachine::AbilityMsgSessionIdCheck(const Message *inMsg)
 
 SyncType SingleVerSyncStateMachine::GetSyncType(uint32_t messageId) const
 {
-    if (messageId == QUERY_SYNC_MESSAGE) {
+    if (messageId == QUERY_SYNC_MESSAGE) { // LCOV_EXCL_BR_LINE
         return SyncType::QUERY_SYNC_TYPE;
     }
     return SyncType::MANUAL_FULL_SYNC_TYPE;
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.cpp
index 162ce6f3741710762374140690b88673ef3f1110..7f49227a1f4ebaea371da0912b2d0fa18fdf04b4 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.cpp
@@ -68,9 +68,9 @@ int SingleVerSyncTaskContext::Initialize(const std::string &deviceId, ISyncInter
         LOGE("[SingleVerSyncTaskContext] timeHelper Initialize failed, err %d.", errCode);
         goto ERROR_OUT;
     }
-    timeOutCallback = std::bind(&SyncStateMachine::TimeoutCallback,
-        static_cast<SingleVerSyncStateMachine *>(stateMachine_),
-        std::placeholders::_1);
+    timeOutCallback = [stateMachine = static_cast<SingleVerSyncStateMachine *>(stateMachine_)](TimerId timerId) {
+        return stateMachine->TimeoutCallback(timerId);
+    };
     SetTimeoutCallback(timeOutCallback);
 
     syncInterface_ = syncInterface;
@@ -362,7 +362,7 @@ bool SingleVerSyncTaskContext::GetSendPermitCheck() const
 
 bool SingleVerSyncTaskContext::IsSkipTimeoutError(int errCode) const
 {
-    if (errCode == -E_TIMEOUT && IsSyncTaskNeedRetry() && (GetRetryTime() < GetSyncRetryTimes())) {
+    if (errCode == -E_TIMEOUT && IsSyncTaskNeedRetry() && (GetRetryTime() < GetSyncRetryTimes())) { // LCOV_EXCL_BR_LINE
         LOGE("[SingleVerSyncTaskContext] send message timeout error occurred");
         return true;
     } else {
@@ -594,4 +594,50 @@ void SingleVerSyncTaskContext::StopFeedDogForGetData()
 {
     stateMachine_->StopFeedDogForGetData();
 }
+
+void SingleVerSyncTaskContext::UpdateOperationFinishedCount(const std::string &deviceId, uint32_t count)
+{
+    std::lock_guard<std::mutex> lock(operationLock_);
+    if (syncOperation_ != nullptr) {
+        syncOperation_->UpdateFinishedCount(deviceId, count);
+    }
+}
+
+void SingleVerSyncTaskContext::SetOperationSyncProcessTotal(const std::string &deviceId, uint32_t total)
+{
+    std::lock_guard<std::mutex> lock(operationLock_);
+    if (syncOperation_ != nullptr) {
+        syncOperation_->SetSyncProcessTotal(deviceId, total);
+    }
+}
+
+void SingleVerSyncTaskContext::SetInitWaterMark(WaterMark waterMark)
+{
+    initWaterMark_ = waterMark;
+}
+
+WaterMark SingleVerSyncTaskContext::GetInitWaterMark() const
+{
+    return initWaterMark_;
+}
+
+void SingleVerSyncTaskContext::SetInitDeletedMark(WaterMark waterMark)
+{
+    initDeletedMark_ = waterMark;
+}
+
+WaterMark SingleVerSyncTaskContext::GetInitDeletedMark() const
+{
+    return initDeletedMark_;
+}
+
+int32_t SingleVerSyncTaskContext::GetResponseTaskCount()
+{
+    std::lock_guard<std::mutex> autoLock(targetQueueLock_);
+    int32_t taskCount = static_cast<int32_t>(responseTargetQueue_.size());
+    if (responseSessionId_ != 0) {
+        taskCount++;
+    }
+    return taskCount;
+}
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.h
index 70fb1908d207488651bf1f1749d872cb38f23b5e..0cb30f5165a523a0af228ddd1e6367eba263104a 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/singlever/single_ver_sync_task_context.h
@@ -136,6 +136,17 @@ public:
 
     void StartFeedDogForGetData(uint32_t sessionId);
     void StopFeedDogForGetData();
+
+    void UpdateOperationFinishedCount(const std::string &deviceId, uint32_t count);
+    void SetOperationSyncProcessTotal(const std::string &deviceId, uint32_t total);
+
+    void SetInitWaterMark(WaterMark waterMark);
+    WaterMark GetInitWaterMark() const;
+    void SetInitDeletedMark(WaterMark waterMark);
+    WaterMark GetInitDeletedMark() const;
+
+    int32_t GetResponseTaskCount() override;
+
 protected:
     ~SingleVerSyncTaskContext() override;
     void CopyTargetData(const ISyncTarget *target, const TaskParam &taskParam) override;
@@ -177,6 +188,9 @@ private:
     mutable std::mutex queryTaskStatusMutex_;
     // <queryId, lastExcuStatus>
     std::unordered_map<std::string, int> lastQuerySyncTaskStatusMap_;
+    // Initial Water Mark when the sync task launched.
+    WaterMark initWaterMark_ = 0;
+    WaterMark initDeletedMark_ = 0;
 };
 } // namespace DistributedDB
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.cpp
index 2cdb73332022d545202897a0ddeb098c4ad4d4f5..43f28afd6074710918aa846ac7deb306509e9cec 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.cpp
@@ -72,10 +72,8 @@ int SyncEngine::Initialize(ISyncInterface *syncInterface, const std::shared_ptr<
     if ((syncInterface == nullptr) || (metadata == nullptr)) {
         return -E_INVALID_ARGS;
     }
-    syncInterface_ = syncInterface;
-    int errCode = StartAutoSubscribeTimer();
-    if (errCode != OK) {
-        syncInterface_ = nullptr;
+    int errCode = StartAutoSubscribeTimer(*syncInterface);
+    if (errCode != E_OK) {
         return errCode;
     }
 
@@ -85,19 +83,18 @@ int SyncEngine::Initialize(ISyncInterface *syncInterface, const std::shared_ptr<
         // There need to set nullptr. other wise, syncInterface will be
         // DecRef in th destroy-method.
         StopAutoSubscribeTimer();
-        syncInterface_ = nullptr;
         return errCode;
     }
     onRemoteDataChanged_ = callbackParam.onRemoteDataChanged;
     offlineChanged_ = callbackParam.offlineChanged;
     queryAutoSyncCallback_ = callbackParam.queryAutoSyncCallback;
-    errCode = InitInnerSource(callbackParam.onRemoteDataChanged, callbackParam.offlineChanged);
+    errCode = InitInnerSource(callbackParam.onRemoteDataChanged, callbackParam.offlineChanged, syncInterface);
     if (errCode != E_OK) {
         // reset ptr if initialize device manager failed
-        syncInterface_ = nullptr;
         StopAutoSubscribeTimer();
         return errCode;
     }
+    SetSyncInterface(syncInterface);
     if (subManager_ == nullptr) {
         subManager_ = std::make_shared<SubscribeManager>();
     }
@@ -134,7 +131,7 @@ int SyncEngine::Close()
         while (!msgQueue_.empty()) {
             Message *inMsg = msgQueue_.front();
             msgQueue_.pop_front();
-            if (inMsg != nullptr) {
+            if (inMsg != nullptr) { // LCOV_EXCL_BR_LINE
                 queueCacheSize_ -= GetMsgSize(inMsg);
                 delete inMsg;
                 inMsg = nullptr;
@@ -213,8 +210,10 @@ void SyncEngine::StartCommunicator()
         return;
     }
     LOGD("[SyncEngine][StartCommunicator] RegOnConnectCallback");
-    int errCode = communicator_->RegOnConnectCallback(std::bind(&DeviceManager::OnDeviceConnectCallback,
-        deviceManager_, std::placeholders::_1, std::placeholders::_2), nullptr);
+    int errCode = communicator_->RegOnConnectCallback(
+        [this, deviceManager = deviceManager_](const std::string &targetDev, bool isConnect) {
+            deviceManager->OnDeviceConnectCallback(targetDev, isConnect);
+        }, nullptr);
     if (errCode != E_OK) {
         LOGE("[SyncEngine][StartCommunicator] register failed, auto sync can not use! err %d", errCode);
         return;
@@ -231,7 +230,7 @@ void SyncEngine::GetOnlineDevices(std::vector<std::string> &devices) const
 }
 
 int SyncEngine::InitInnerSource(const std::function<void(std::string)> &onRemoteDataChanged,
-    const std::function<void(std::string)> &offlineChanged)
+    const std::function<void(std::string)> &offlineChanged, ISyncInterface *syncInterface)
 {
     deviceManager_ = new (std::nothrow) DeviceManager();
     if (deviceManager_ == nullptr) {
@@ -260,7 +259,7 @@ int SyncEngine::InitInnerSource(const std::function<void(std::string)> &onRemote
             LOGE("[SyncEngine] deviceManager init failed! err %d", errCode);
             break;
         }
-        errCode = executor->Initialize(syncInterface_, communicator_);
+        errCode = executor->Initialize(syncInterface, communicator_);
     } while (false);
     if (errCode != E_OK) {
         delete deviceManager_;
@@ -297,8 +296,7 @@ int SyncEngine::InitComunicator(const ISyncInterface *syncInterface)
     }
 
     errCode = communicator_->RegOnMessageCallback(
-        std::bind(&SyncEngine::MessageReciveCallback, this, std::placeholders::_1, std::placeholders::_2),
-        []() {});
+        [this](const std::string &targetDev, Message *inMsg) { MessageReciveCallback(targetDev, inMsg); }, []() {});
     if (errCode != E_OK) {
         LOGE("[SyncEngine] SyncRequestCallback register failed! err = %d", errCode);
         communicatorAggregator->ReleaseCommunicator(communicator_);
@@ -336,7 +334,7 @@ int SyncEngine::AddSyncOperForContext(const std::string &deviceId, SyncOperation
                 return errCode;
             }
         }
-        if (context->IsKilled()) {
+        if (context->IsKilled()) { // LCOV_EXCL_BR_LINE
             return -E_OBJ_IS_KILLED;
         }
         // IncRef for SyncEngine to make sure context is valid, to avoid a big lock
@@ -441,7 +439,7 @@ ISyncTaskContext *SyncEngine::GetContextForMsg(const std::string &targetDev, int
     {
         std::lock_guard<std::mutex> lock(contextMapLock_);
         context = FindSyncTaskContext(targetDev);
-        if (context != nullptr) {
+        if (context != nullptr) { // LCOV_EXCL_BR_LINE
             if (context->IsKilled()) {
                 errCode = -E_OBJ_IS_KILLED;
                 return nullptr;
@@ -480,8 +478,8 @@ int SyncEngine::ScheduleDealMsg(ISyncTaskContext *context, Message *inMsg)
     if (inMsg->GetMessageId() == LOCAL_DATA_CHANGED) {
         RemoteDataChangedTask(context, comProxy, inMsg);
     } else {
-        errCode = RuntimeContext::GetInstance()->ScheduleTask(std::bind(&SyncEngine::MessageReciveCallbackTask,
-            this, context, comProxy, inMsg));
+        errCode = RuntimeContext::GetInstance()->ScheduleTask(
+            [this, context, comProxy, inMsg] { MessageReciveCallbackTask(context, comProxy, inMsg); });
     }
 
     if (errCode != E_OK) {
@@ -558,7 +556,7 @@ void SyncEngine::PutMsgIntoQueue(const std::string &targetDev, Message *inMsg, i
             [&targetDev](const Message *msg) {
                 return targetDev == msg->GetTarget() && msg->GetMessageId() == LOCAL_DATA_CHANGED;
             });
-        if (iter != msgQueue_.end()) {
+        if (iter != msgQueue_.end()) { // LCOV_EXCL_BR_LINE
             delete inMsg;
             inMsg = nullptr;
             return;
@@ -616,7 +614,7 @@ ISyncTaskContext *SyncEngine::GetSyncTaskContextAndInc(const std::string &device
         LOGI("[SyncEngine] dev=%s, context is null, no need to clear sync operation", STR_MASK(deviceId));
         return nullptr;
     }
-    if (context->IsKilled()) {
+    if (context->IsKilled()) { // LCOV_EXCL_BR_LINE
         LOGI("[SyncEngine] context is killing");
         return nullptr;
     }
@@ -626,34 +624,35 @@ ISyncTaskContext *SyncEngine::GetSyncTaskContextAndInc(const std::string &device
 
 ISyncTaskContext *SyncEngine::GetSyncTaskContext(const std::string &deviceId, int &errCode)
 {
-    ISyncTaskContext *context = CreateSyncTaskContext();
+    auto storage = GetAndIncSyncInterface();
+    if (storage == nullptr) {
+        errCode = -E_INVALID_DB;
+        LOGE("[SyncEngine] SyncTaskContext alloc failed with null db");
+        return nullptr;
+    }
+    ISyncTaskContext *context = CreateSyncTaskContext(*storage);
     if (context == nullptr) {
         errCode = -E_OUT_OF_MEMORY;
         LOGE("[SyncEngine] SyncTaskContext alloc failed, may be no memory available!");
         return nullptr;
     }
-    errCode = context->Initialize(deviceId, syncInterface_, metadata_, communicatorProxy_);
+    errCode = context->Initialize(deviceId, storage, metadata_, communicatorProxy_);
     if (errCode != E_OK) {
         LOGE("[SyncEngine] context init failed err %d, dev %s", errCode, STR_MASK(deviceId));
         RefObject::DecObjRef(context);
+        storage->DecRefCount();
         context = nullptr;
         return nullptr;
     }
     syncTaskContextMap_.insert(std::pair<std::string, ISyncTaskContext *>(deviceId, context));
     // IncRef for SyncEngine to make sure SyncEngine is valid when context access
     RefObject::IncObjRef(this);
-    auto storage = syncInterface_;
-    if (storage != nullptr) {
-        storage->IncRefCount();
-    }
     context->OnLastRef([this, deviceId, storage]() {
         LOGD("[SyncEngine] SyncTaskContext for id %s finalized", STR_MASK(deviceId));
         RefObject::DecObjRef(this);
-        if (storage != nullptr) {
-            storage->DecRefCount();
-        }
+        storage->DecRefCount();
     });
-    context->RegOnSyncTask(std::bind(&SyncEngine::ExecSyncTask, this, context));
+    context->RegOnSyncTask([this, context] { return ExecSyncTask(context); });
     return context;
 }
 
@@ -675,7 +674,7 @@ int SyncEngine::ExecSyncTask(ISyncTaskContext *context)
             context->ClearSyncOperation();
             continue;
         }
-        if (context->IsCurrentSyncTaskCanBeSkipped()) {
+        if (context->IsCurrentSyncTaskCanBeSkipped()) { // LCOV_EXCL_BR_LINE
             context->SetOperationStatus(SyncOperation::OP_FINISHED_ALL);
             context->ClearSyncOperation();
             continue;
@@ -739,7 +738,7 @@ void SyncEngine::SetSyncRetry(bool isRetry)
     std::lock_guard<std::mutex> lock(contextMapLock_);
     for (auto &iter : syncTaskContextMap_) {
         ISyncTaskContext *context = iter.second;
-        if (context != nullptr) {
+        if (context != nullptr) { // LCOV_EXCL_BR_LINE
             context->SetSyncRetry(isRetry);
         }
     }
@@ -787,7 +786,7 @@ void SyncEngine::SetEqualIdentifier()
 {
     std::map<std::string, std::vector<std::string>> equalIdentifier; // key: equalIdentifier value: devices
     for (auto &item : equalIdentifierMap_) {
-        if (equalIdentifier.find(item.second) == equalIdentifier.end()) {
+        if (equalIdentifier.find(item.second) == equalIdentifier.end()) { // LCOV_EXCL_BR_LINE
             equalIdentifier[item.second] = {item.first};
         } else {
             equalIdentifier[item.second].push_back(item.first);
@@ -844,7 +843,7 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId, ISyncInterfa
         if (communicatorProxy_ == nullptr) {
             return;
         }
-        if (communicatorProxy_->IsDeviceOnline(deviceId)) {
+        if (communicatorProxy_->IsDeviceOnline(deviceId)) { // LCOV_EXCL_BR_LINE
             LOGI("[SyncEngine] target dev=%s is online, no need to clear task.", STR_MASK(deviceId));
             RefObject::DecObjRef(context);
             return;
@@ -859,6 +858,15 @@ void SyncEngine::OfflineHandleByDevice(const std::string &deviceId, ISyncInterfa
     }
 }
 
+void SyncEngine::ClearAllSyncTaskByDevice(const std::string &deviceId)
+{
+    ISyncTaskContext *context = GetSyncTaskContextAndInc(deviceId);
+    if (context != nullptr) {
+        context->ClearAllSyncTask();
+        RefObject::DecObjRef(context);
+    }
+}
+
 void SyncEngine::GetLocalSubscribeQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries)
 {
     subManager_->GetLocalSubscribeQueries(device, subscribeQueries);
@@ -901,8 +909,7 @@ ICommunicator *SyncEngine::AllocCommunicator(const std::string &identifier, int
     }
 
     errCode = communicator->RegOnMessageCallback(
-        std::bind(&SyncEngine::MessageReciveCallback, this, std::placeholders::_1, std::placeholders::_2),
-        []() {});
+        [this](const std::string &targetDev, Message *inMsg) { MessageReciveCallback(targetDev, inMsg); }, []() {});
     if (errCode != E_OK) {
         LOGE("[SyncEngine] SyncRequestCallback register failed in SetEqualIdentifier! err = %d", errCode);
         communicatorAggregator->ReleaseCommunicator(communicator);
@@ -910,8 +917,9 @@ ICommunicator *SyncEngine::AllocCommunicator(const std::string &identifier, int
     }
 
     errCode = communicator->RegOnConnectCallback(
-        std::bind(&DeviceManager::OnDeviceConnectCallback, deviceManager_,
-        std::placeholders::_1, std::placeholders::_2), nullptr);
+        [this, deviceManager = deviceManager_](const std::string &targetDev, bool isConnect) {
+            deviceManager->OnDeviceConnectCallback(targetDev, isConnect);
+        }, nullptr);
     if (errCode != E_OK) {
         LOGE("[SyncEngine][RegConnCB] register failed in SetEqualIdentifier! err %d", errCode);
         communicator->RegOnMessageCallback(nullptr, nullptr);
@@ -990,7 +998,7 @@ void SyncEngine::GetQueryAutoSyncParam(const std::string &device, const QuerySyn
     outParam.syncQuery = query;
 }
 
-int SyncEngine::StartAutoSubscribeTimer()
+int SyncEngine::StartAutoSubscribeTimer([[gnu::unused]] const ISyncInterface &syncInterface)
 {
     return E_OK;
 }
@@ -1007,10 +1015,7 @@ int SyncEngine::SubscribeLimitCheck(const std::vector<std::string> &devices, Que
 
 void SyncEngine::ClearInnerResource()
 {
-    if (syncInterface_ != nullptr) {
-        syncInterface_->DecRefCount();
-        syncInterface_ = nullptr;
-    }
+    ClearSyncInterface();
     if (deviceManager_ != nullptr) {
         delete deviceManager_;
         deviceManager_ = nullptr;
@@ -1039,7 +1044,7 @@ void SyncEngine::SchemaChange()
         std::lock_guard<std::mutex> lock(contextMapLock_);
         for (const auto &entry : syncTaskContextMap_) {
             auto context = entry.second;
-            if (context == nullptr || context->IsKilled()) {
+            if (context == nullptr || context->IsKilled()) { // LCOV_EXCL_BR_LINE
                 continue;
             }
             RefObject::IncObjRef(context);
@@ -1172,7 +1177,7 @@ void SyncEngine::AbortMachineIfNeed(uint32_t syncId)
         std::lock_guard<std::mutex> lock(contextMapLock_);
         for (const auto &entry : syncTaskContextMap_) {
             auto context = entry.second;
-            if (context == nullptr || context->IsKilled()) {
+            if (context == nullptr || context->IsKilled()) { // LCOV_EXCL_BR_LINE
                 continue;
             }
             RefObject::IncObjRef(context);
@@ -1194,7 +1199,7 @@ void SyncEngine::WaitingExecTaskExist()
     std::unique_lock<std::mutex> closeLock(execTaskCountLock_);
     bool isTimeout = execTaskCv_.wait_for(closeLock, std::chrono::milliseconds(DBConstant::MIN_TIMEOUT),
         [this]() { return execTaskCount_ == 0; });
-    if (!isTimeout) {
+    if (!isTimeout) { // LCOV_EXCL_BR_LINE
         LOGD("SyncEngine Close with executing task!");
     }
 }
@@ -1234,7 +1239,7 @@ void SyncEngine::AddQuerySubscribe(SyncGenericInterface *storage, const std::str
     }
     errCode = subManager_->ReserveRemoteSubscribeQuery(device, query);
     if (errCode != E_OK) {
-        if (!subManager_->IsQueryExistSubscribe(query.GetIdentify())) {
+        if (!subManager_->IsQueryExistSubscribe(query.GetIdentify())) { // LCOV_EXCL_BR_LINE
             (void)storage->RemoveSubscribe(query.GetIdentify());
         }
         return;
@@ -1275,6 +1280,40 @@ int32_t SyncEngine::GetResponseTaskCount()
         taskCount += iter->GetResponseTaskCount();
         RefObject::DecObjRef(iter);
     }
+    {
+        std::lock_guard<std::mutex> decLock(execTaskCountLock_);
+        taskCount += static_cast<int32_t>(execTaskCount_);
+    }
     return taskCount;
 }
+
+void SyncEngine::ClearSyncInterface()
+{
+    ISyncInterface *syncInterface = nullptr;
+    {
+        std::lock_guard<std::mutex> autoLock(storageMutex_);
+        if (syncInterface_ == nullptr) {
+            return;
+        }
+        syncInterface = syncInterface_;
+        syncInterface_ = nullptr;
+    }
+    syncInterface->DecRefCount();
+}
+
+ISyncInterface *SyncEngine::GetAndIncSyncInterface()
+{
+    std::lock_guard<std::mutex> autoLock(storageMutex_);
+    if (syncInterface_ == nullptr) {
+        return nullptr;
+    }
+    syncInterface_->IncRefCount();
+    return syncInterface_;
+}
+
+void SyncEngine::SetSyncInterface(ISyncInterface *syncInterface)
+{
+    std::lock_guard<std::mutex> autoLock(storageMutex_);
+    syncInterface_ = syncInterface;
+}
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.h b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.h
index 671e9e297539f623a1cf2dd7d71f3e28d1ce95ad..76fffde847c9de2ba80e5eef9d615195fcd05e72 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_engine.h
@@ -86,6 +86,8 @@ public:
 
     void OfflineHandleByDevice(const std::string &deviceId, ISyncInterface *storage);
 
+    void ClearAllSyncTaskByDevice(const std::string &deviceId) override;
+
     void GetLocalSubscribeQueries(const std::string &device, std::vector<QuerySyncObject> &subscribeQueries);
 
     // subscribeQueries item is queryId
@@ -98,7 +100,7 @@ public:
     void GetAllUnFinishSubQueries(std::map<std::string, std::vector<QuerySyncObject>> &allSyncQueries);
 
     // used by SingleVerSyncer when db online
-    int StartAutoSubscribeTimer() override;
+    int StartAutoSubscribeTimer(const ISyncInterface &syncInterface) override;
 
     // used by SingleVerSyncer when remote/local db closed
     void StopAutoSubscribeTimer() override;
@@ -128,7 +130,7 @@ public:
     int32_t GetResponseTaskCount() override;
 protected:
     // Create a context
-    virtual ISyncTaskContext *CreateSyncTaskContext() = 0;
+    virtual ISyncTaskContext *CreateSyncTaskContext(const ISyncInterface &syncInterface) = 0;
 
     // Find SyncTaskContext from the map
     ISyncTaskContext *FindSyncTaskContext(const std::string &deviceId);
@@ -136,6 +138,13 @@ protected:
     void GetQueryAutoSyncParam(const std::string &device, const QuerySyncObject &query, InternalSyncParma &outParam);
     void GetSubscribeSyncParam(const std::string &device, const QuerySyncObject &query, InternalSyncParma &outParam);
 
+    void ClearSyncInterface();
+    ISyncInterface *GetAndIncSyncInterface();
+    void SetSyncInterface(ISyncInterface *syncInterface);
+
+    ISyncTaskContext *GetSyncTaskContext(const std::string &deviceId, int &errCode);
+
+    std::mutex storageMutex_;
     ISyncInterface *syncInterface_;
     // Used to store all send sync task infos (such as pull sync response, and push sync request)
     std::map<std::string, ISyncTaskContext *> syncTaskContextMap_;
@@ -147,9 +156,7 @@ private:
 
     // Init DeviceManager set callback and remoteExecutor
     int InitInnerSource(const std::function<void(std::string)> &onRemoteDataChanged,
-        const std::function<void(std::string)> &offlineChanged);
-
-    ISyncTaskContext *GetSyncTaskContext(const std::string &deviceId, int &errCode);
+        const std::function<void(std::string)> &offlineChanged, ISyncInterface *syncInterface);
 
     // Init Comunicator, register callbacks
     int InitComunicator(const ISyncInterface *syncInterface);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_state_machine.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_state_machine.cpp
index d2aff3316cefc73a07c3105cafc1868d0f23934d..df617b6b9319a9d7a0b66046e7894d7fc7b658a1 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_state_machine.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_state_machine.cpp
@@ -113,7 +113,7 @@ void SyncStateMachine::Abort()
         this->AbortImmediately();
         RefObject::DecObjRef(this->syncContext_);
     });
-    if (errCode != E_OK) {
+    if (errCode != E_OK) { // LCOV_EXCL_BR_LINE
         LOGE("[SyncStateMachine][Abort] Abort failed, errCode %d", errCode);
         RefObject::DecObjRef(syncContext_);
     }
@@ -143,7 +143,7 @@ int SyncStateMachine::SwitchMachineState(uint8_t event)
     const std::map<uint8_t, EventToState> &table = (*tableIter).switchTable;
     auto eventToStateIter = table.find(currentState_);
     if (eventToStateIter == table.end()) {
-        LOGE("[SyncStateMachine][SwitchState] Can't find EventToState with currentSate %u",
+        LOGW("[SyncStateMachine][SwitchState] Can't find EventToState with currentSate %u",
             currentState_);
         SetCurStateErrStatus();
         return E_OK;
@@ -416,7 +416,7 @@ void SyncStateMachine::DoFeedDogForSync(SyncDirectionFlag flag)
         (void)ResetWatchDog();
     }
     std::lock_guard<std::mutex> innerLock(feedDogLock_[flag]);
-    if (watchDogController_[flag].feedDogCnt >= watchDogController_[flag].feedDogUpperLimit) {
+    if (watchDogController_[flag].feedDogCnt >= watchDogController_[flag].feedDogUpperLimit) { // LCOV_EXCL_BR_LINE
         StopFeedDogForSyncNoLock(flag);
         return;
     }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_task_context.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_task_context.cpp
index f5b5584045b49e47a83cf3b9b8e009cda377ba09..8493a8e0221d0abcfec7b09669dd6cfc4cf09c19 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_task_context.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/sync_task_context.cpp
@@ -122,7 +122,7 @@ void SyncTaskContext::SetOperationStatus(int status)
 
     int operationStatus = syncOperation_->GetStatus(deviceId_);
     if (status == SyncOperation::OP_SEND_FINISHED && operationStatus == SyncOperation::OP_RECV_FINISHED) {
-        if (GetTaskErrCode() == -E_EKEYREVOKED) {
+        if (GetTaskErrCode() == -E_EKEYREVOKED) { // LCOV_EXCL_BR_LINE
             finalStatus = SyncOperation::OP_EKEYREVOKED_FAILURE;
         } else {
             finalStatus = SyncOperation::OP_FINISHED_ALL;
@@ -197,7 +197,7 @@ void SyncTaskContext::ClearSyncTarget()
     requestTargetQueue_.clear();
 
     for (auto &responseTarget : responseTargetQueue_) {
-        if (responseTarget != nullptr) {
+        if (responseTarget != nullptr) { // LCOV_EXCL_BR_LINE
             delete responseTarget;
             responseTarget = nullptr;
         }
@@ -310,7 +310,7 @@ int SyncTaskContext::StartTimer()
     }
     TimerId timerId = 0;
     RefObject::IncObjRef(this);
-    TimerAction timeOutCallback = std::bind(&SyncTaskContext::TimeOut, this, std::placeholders::_1);
+    TimerAction timeOutCallback = [this](TimerId id) { return TimeOut(id); };
     int errCode = RuntimeContext::GetInstance()->SetTimer(timeout_, timeOutCallback,
         [this]() {
             int ret = RuntimeContext::GetInstance()->ScheduleTask([this]() { RefObject::DecObjRef(this); });
@@ -431,7 +431,7 @@ int SyncTaskContext::StartStateMachine()
 
 int SyncTaskContext::ReceiveMessageCallback(Message *inMsg)
 {
-    if (GetRemoteSoftwareVersion() <= SOFTWARE_VERSION_BASE && inMsg->GetMessageId() != ABILITY_SYNC_MESSAGE) {
+    if (inMsg->GetMessageId() != ABILITY_SYNC_MESSAGE) {
         uint16_t remoteVersion = 0;
         (void)communicator_->GetRemoteCommunicatorVersion(deviceId_, remoteVersion);
         SetRemoteSoftwareVersion(SOFTWARE_VERSION_EARLIEST + remoteVersion);
@@ -502,6 +502,9 @@ void SyncTaskContext::CommErrHandlerFunc(int errCode, ISyncTaskContext *context,
 void SyncTaskContext::SetRemoteSoftwareVersion(uint32_t version)
 {
     std::lock_guard<std::mutex> lock(remoteSoftwareVersionLock_);
+    if (remoteSoftwareVersion_ == version) {
+        return;
+    }
     remoteSoftwareVersion_ = version;
     remoteSoftwareVersionId_++;
 }
@@ -610,7 +613,7 @@ void SyncTaskContext::KillWait()
             return false;
         },
         KILL_WAIT_SECONDS);
-    if (!noDeadLock) {
+    if (!noDeadLock) { // LCOV_EXCL_BR_LINE
         LOGE("[SyncTaskContext] Dead lock may happen, we stop waiting the task exit.");
     } else {
         LOGW("[SyncTaskContext] Wait the task exit ok.");
@@ -732,7 +735,7 @@ void SyncTaskContext::Dump(int fd)
         std::lock_guard<std::mutex> lock(targetQueueLock_);
         totalSyncTaskCount = requestTargetQueue_.size() + responseTargetQueue_.size();
         for (const auto &target : requestTargetQueue_) {
-            if (target->IsAutoSync()) {
+            if (target->IsAutoSync()) { // LCOV_EXCL_BR_LINE
                 autoSyncTaskCount++;
             }
         }
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/syncer_proxy.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/syncer_proxy.cpp
index 3126de53bfe9c015f7482fbdb70aa1524559760e..8a96086105eba18d994574c932f1d3c010ebd318 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/syncer_proxy.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/syncer_proxy.cpp
@@ -58,7 +58,7 @@ int SyncerProxy::Sync(const std::vector<std::string> &devices, int mode,
     const std::function<void(const std::map<std::string, int> &)> &onComplete,
     const std::function<void(void)> &onFinalize, bool wait)
 {
-    if (syncer_ == nullptr) {
+    if (syncer_ == nullptr) { // LCOV_EXCL_BR_LINE
         return -E_NOT_INIT;
     }
     return syncer_->Sync(devices, mode, onComplete, onFinalize, wait);
@@ -72,11 +72,19 @@ int SyncerProxy::Sync(const SyncParma &parma, uint64_t connectionId)
     return syncer_->Sync(parma, connectionId);
 }
 
-int SyncerProxy::RemoveSyncOperation(int syncId)
+int SyncerProxy::CancelSync(uint32_t syncId)
 {
     if (syncer_ == nullptr) {
         return -E_NOT_INIT;
     }
+    return syncer_->CancelSync(syncId);
+}
+
+int SyncerProxy::RemoveSyncOperation(int syncId)
+{
+    if (syncer_ == nullptr) { // LCOV_EXCL_BR_LINE
+        return -E_NOT_INIT;
+    }
     return syncer_->RemoveSyncOperation(syncId);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/device/time_sync.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/device/time_sync.cpp
index 13bdb2df998eab13b5257607b27c6d0143938953..55b903c610d1adf65aceafe589bfb5f06f99e788 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/device/time_sync.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/device/time_sync.cpp
@@ -28,9 +28,9 @@ std::set<TimeSync *> TimeSync::timeSyncSet_;
 namespace {
     constexpr uint64_t TIME_SYNC_INTERVAL = 24 * 60 * 60 * 1000; // 24h
     constexpr int TRIP_DIV_HALF = 2;
-    constexpr int64_t MAX_TIME_OFFSET_NOISE = 1 * 1000 * 10000; // 1s for 100ns
-    constexpr int64_t MAX_TIME_RTT_NOISE = 1 * 1000 * 10000; // 1s for 100ns
-    constexpr uint64_t RTT_NOISE_CHECK_INTERVAL = 30 * 60 * 1000 * 10000u; // 30min for 100ns
+    constexpr int64_t MAX_TIME_OFFSET_NOISE = 1 * 1000 * 10000; // 1 second in 100-nanosecond units
+    constexpr int64_t MAX_TIME_RTT_NOISE = 1 * 1000 * 10000; // 1 second in 100-nanosecond units
+    constexpr uint64_t RTT_NOISE_CHECK_INTERVAL = 30 * 60 * 1000 * 10000u; // 30 minute in 100-nanosecond units
 }
 
 // Class TimeSyncPacket
@@ -168,11 +168,13 @@ TimeSync::~TimeSync()
 int TimeSync::RegisterTransformFunc()
 {
     TransformFunc func;
-    func.computeFunc = std::bind(&TimeSync::CalculateLen, std::placeholders::_1);
-    func.serializeFunc = std::bind(&TimeSync::Serialization, std::placeholders::_1,
-                                   std::placeholders::_2, std::placeholders::_3);
-    func.deserializeFunc = std::bind(&TimeSync::DeSerialization, std::placeholders::_1,
-                                     std::placeholders::_2, std::placeholders::_3);
+    func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
+    func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
+        return Serialization(buffer, length, inMsg);
+    };
+    func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
+        return DeSerialization(buffer, length, inMsg);
+    };
     return MessageTransform::RegTransformFunction(TIME_SYNC_MESSAGE, func);
 }
 
@@ -198,7 +200,7 @@ int TimeSync::Initialize(ICommunicator *communicator, const std::shared_ptr<Meta
         return errCode;
     }
     dbId_ = storage->GetIdentifier();
-    driverCallback_ = std::bind(&TimeSync::TimeSyncDriver, this, std::placeholders::_1);
+    driverCallback_ = [this](TimerId timerId) { return TimeSyncDriver(timerId); };
     errCode = RuntimeContext::GetInstance()->SetTimer(TIME_SYNC_INTERVAL, driverCallback_, nullptr, driverTimerId_);
     if (errCode != E_OK) {
         return errCode;
@@ -500,7 +502,7 @@ int TimeSync::TimeSyncDriver(TimerId timerId)
     }
     std::lock_guard<std::mutex> lock(timeDriverLock_);
     int errCode = RuntimeContext::GetInstance()->ScheduleTask([this]() {
-        CommErrHandler handler = std::bind(&TimeSync::CommErrHandlerFunc, std::placeholders::_1, this);
+        CommErrHandler handler = [this](int ret) { CommErrHandlerFunc(ret, this); };
         (void)this->SyncStart(handler);
         std::lock_guard<std::mutex> innerLock(this->timeDriverLock_);
         this->timeDriverLockCount_--;
@@ -521,7 +523,7 @@ int TimeSync::GetTimeOffset(TimeOffset &outOffset, uint32_t timeout, uint32_t se
             std::lock_guard<std::mutex> lock(cvLock_);
             isAckReceived_ = false;
         }
-        CommErrHandler handler = std::bind(&TimeSync::CommErrHandlerFunc, std::placeholders::_1, this);
+        CommErrHandler handler = [this](int ret) { CommErrHandlerFunc(ret, this); };
         int errCode = SyncStart(handler, sessionId);
         LOGD("TimeSync::GetTimeOffset start, current time = %" PRIu64 ", errCode = %d, timeout = %" PRIu32 " ms",
             TimeHelper::GetSysCurrentTime(), errCode, timeout);
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
index 679af631e3b25fb33b4d544e1f7b1596d69f5a88..db3466dd3987e2f8fb82347d0212719cd76b3b94 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.cpp
@@ -46,23 +46,34 @@ SyncOperation::~SyncOperation()
 int SyncOperation::Initialize()
 {
     LOGD("[SyncOperation] Init SyncOperation id:%d.", syncId_);
-    AutoLock lockGuard(this);
-    for (const std::string &deviceId : devices_) {
-        statuses_.insert(std::pair<std::string, int>(deviceId, OP_WAITING));
-    }
+    std::map<std::string, DeviceSyncProcess> tempSyncProcessMap;
+    {
+        AutoLock lockGuard(this);
+        for (const std::string &deviceId : devices_) {
+            statuses_.insert(std::pair<std::string, int>(deviceId, OP_WAITING));
+            DeviceSyncProcess processInfo;
+            processInfo.errCode = static_cast<DBStatus>(OP_WAITING);
+            processInfo.syncId = syncId_;
+            syncProcessMap_.insert(std::pair<std::string, DeviceSyncProcess>(deviceId, processInfo));
+        }
 
-    if (mode_ == AUTO_PUSH) {
-        mode_ = PUSH;
-        isAutoSync_ = true;
-    } else if (mode_ == AUTO_PULL) {
-        mode_ = PULL;
-        isAutoSync_ = true;
-    } else if (mode_ == AUTO_SUBSCRIBE_QUERY) {
-        mode_ = SUBSCRIBE_QUERY;
-        isAutoSubscribe_ = true;
+        if (mode_ == AUTO_PUSH) {
+            mode_ = PUSH;
+            isAutoSync_ = true;
+        } else if (mode_ == AUTO_PULL) {
+            mode_ = PULL;
+            isAutoSync_ = true;
+        } else if (mode_ == AUTO_SUBSCRIBE_QUERY) {
+            mode_ = SUBSCRIBE_QUERY;
+            isAutoSubscribe_ = true;
+        }
+        if (isBlockSync_) {
+            semaphore_ = std::make_unique<SemaphoreUtils>(0);
+        }
+        tempSyncProcessMap = syncProcessMap_;
     }
-    if (isBlockSync_) {
-        semaphore_ = std::make_unique<SemaphoreUtils>(0);
+    if (userSyncProcessCallback_) {
+        ExeSyncProcessCallFun(tempSyncProcessMap);
     }
 
     return E_OK;
@@ -91,6 +102,12 @@ void SyncOperation::SetStatus(const std::string &deviceId, int status)
         return;
     }
 
+    if (userSyncProcessCallback_) {
+        if (syncProcessMap_[deviceId].errCode < static_cast<DBStatus>(OP_FINISHED_ALL)) {
+            syncProcessMap_[deviceId].errCode = static_cast<DBStatus>(status);
+        }
+    }
+
     auto iter = statuses_.find(deviceId);
     if (iter != statuses_.end()) {
         if (iter->second >= OP_FINISHED_ALL) {
@@ -144,6 +161,7 @@ int SyncOperation::GetMode() const
 void SyncOperation::Finished()
 {
     std::map<std::string, int> tmpStatus;
+    std::map<std::string, DeviceSyncProcess> tmpProcessMap;
     {
         AutoLock lockGuard(this);
         if (IsKilled() || isFinished_) {
@@ -151,6 +169,7 @@ void SyncOperation::Finished()
         }
         isFinished_ = true;
         tmpStatus = statuses_;
+        tmpProcessMap = syncProcessMap_;
     }
     PerformanceAnalysis *performance = PerformanceAnalysis::GetInstance();
     if (performance != nullptr) {
@@ -173,6 +192,11 @@ void SyncOperation::Finished()
             }
         }
     }
+
+    if (userSyncProcessCallback_) {
+        ExeSyncProcessCallFun(tmpProcessMap);
+    }
+
     if (onFinished_) {
         LOGD("[SyncOperation] Sync %d finished call onFinished.", syncId_);
         onFinished_(syncId_);
@@ -222,6 +246,67 @@ void SyncOperation::SetSyncContext(RefObject *context)
     RefObject::IncObjRef(context);
 }
 
+bool SyncOperation::CanCancel()
+{
+    return canCancel_;
+}
+
+void SyncOperation::SetSyncProcessCallFun(DeviceSyncProcessCallback callBack)
+{
+    if (callBack) {
+        canCancel_ = true;
+        this->userSyncProcessCallback_ = callBack;
+    }
+}
+
+void SyncOperation::ExeSyncProcessCallFun(const std::map<std::string, DeviceSyncProcess> &syncProcessMap)
+{
+    if (IsBlockSync()) {
+        userSyncProcessCallback_(syncProcessMap);
+    } else {
+        RefObject::IncObjRef(this);
+        int errCode = RuntimeContext::GetInstance()->ScheduleQueuedTask(identifier_, [this, syncProcessMap] {
+            userSyncProcessCallback_(syncProcessMap);
+            RefObject::DecObjRef(this);
+        });
+        if (errCode != E_OK) {
+            LOGE("[SyncOperation] ExeSyncProcessCallFun retCode:%d", errCode);
+            RefObject::DecObjRef(this);
+        }
+    }
+}
+
+void SyncOperation::UpdateFinishedCount(const std::string &deviceId, uint32_t count)
+{
+    if (this->userSyncProcessCallback_) {
+        std::map<std::string, DeviceSyncProcess> tmpMap;
+        {
+            AutoLock lockGuard(this);
+            if (IsKilled()) {
+                return;
+            }
+            LOGD("[UpdateFinishedCount] deviceId %s{private} count %u", deviceId.c_str(), count);
+            this->syncProcessMap_[deviceId].pullInfo.finishedCount += count;
+            tmpMap = this->syncProcessMap_;
+        }
+        ExeSyncProcessCallFun(tmpMap);
+    }
+}
+
+void SyncOperation::SetSyncProcessTotal(const std::string &deviceId, uint32_t total)
+{
+    if (this->userSyncProcessCallback_) {
+        {
+            AutoLock lockGuard(this);
+            if (IsKilled()) {
+                return;
+            }
+            LOGD("[SetSyncProcessTotal] total=%u, syncId=%u, deviceId=%s{private}", total, syncId_, deviceId.c_str());
+            this->syncProcessMap_[deviceId].pullInfo.total = total;
+        }
+    }
+}
+
 bool SyncOperation::CheckIsAllFinished() const
 {
     AutoLock lockGuard(this);
@@ -276,6 +361,10 @@ struct SyncOperationStatusNode {
     int operationStatus = 0;
     DBStatus status = DBStatus::DB_ERROR;
 };
+struct SyncOperationProcessStatus {
+    int operationStatus;
+    ProcessStatus proStatus;
+};
 }
 
 SyncType SyncOperation::GetSyncType(int mode)
@@ -317,6 +406,10 @@ DBStatus SyncOperation::DBStatusTrans(int operationStatus)
 {
     static const SyncOperationStatusNode syncOperationStatusNodes[] = {
         { static_cast<int>(OP_FINISHED_ALL),                  OK },
+        { static_cast<int>(OP_WAITING),                       OK },
+        { static_cast<int>(OP_SYNCING),                       OK },
+        { static_cast<int>(OP_SEND_FINISHED),                 OK },
+        { static_cast<int>(OP_RECV_FINISHED),                 OK },
         { static_cast<int>(OP_TIMEOUT),                       TIME_OUT },
         { static_cast<int>(OP_PERMISSION_CHECK_FAILED),       PERMISSION_CHECK_FORBID_SYNC },
         { static_cast<int>(OP_COMM_ABNORMAL),                 COMM_FAILURE },
@@ -342,6 +435,23 @@ DBStatus SyncOperation::DBStatusTrans(int operationStatus)
     return result == std::end(syncOperationStatusNodes) ? DB_ERROR : result->status;
 }
 
+ProcessStatus SyncOperation::DBStatusTransProcess(int operationStatus)
+{
+    static const SyncOperationProcessStatus syncOperationProcessStatus[] = {
+        { static_cast<int>(OP_WAITING),              PREPARED },
+        { static_cast<int>(OP_SYNCING),              PROCESSING },
+        { static_cast<int>(OP_SEND_FINISHED),        PROCESSING },
+        { static_cast<int>(OP_RECV_FINISHED),        PROCESSING },
+        { static_cast<int>(OP_FINISHED_ALL),         FINISHED },
+        { static_cast<int>(OP_COMM_ABNORMAL),        FINISHED },
+    };
+    const auto &result = std::find_if(std::begin(syncOperationProcessStatus), std::end(syncOperationProcessStatus),
+    [operationStatus](const auto &node) {
+        return node.operationStatus == operationStatus;
+    });
+    return result == std::end(syncOperationProcessStatus) ? FINISHED : result->proStatus;
+}
+
 std::string SyncOperation::GetFinishDetailMsg(const std::map<std::string, int> &finishStatus)
 {
     std::string msg = "Sync detail is:";
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.h b/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.h
index c347b2e60991cbca62a0bc1506bce376910002a1..c96e14579a1d2d1361a2238e57ec11c915a58c5d 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.h
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/sync_operation.h
@@ -129,8 +129,18 @@ public:
 
     static DBStatus DBStatusTrans(int operationStatus);
 
+    static ProcessStatus DBStatusTransProcess(int operationStatus);
+
     void SetSyncContext(RefObject *context);
 
+    bool CanCancel();
+
+    void SetSyncProcessCallFun(DeviceSyncProcessCallback callBack);
+
+    void SetSyncProcessTotal(const std::string &deviceId, uint32_t total);
+
+    void UpdateFinishedCount(const std::string &deviceId, uint32_t count);
+
 protected:
     virtual ~SyncOperation();
 
@@ -161,6 +171,9 @@ private:
     // The callback caller registered, will be called when destruction.
     OnSyncFinalize onFinalize_;
 
+    // The syncProcess callback caller registered
+    DeviceSyncProcessCallback userSyncProcessCallback_;
+
     // The device id we sync with
     std::map<std::string, int> statuses_;
 
@@ -184,6 +197,14 @@ private:
 
     // record identifier used to call ScheduleQueuedTask in SyncOperation::Finished
     std::string identifier_;
+
+    // The device id we syncProcess with
+    std::map<std::string, DeviceSyncProcess> syncProcessMap_;
+
+    // Can be canceled
+    bool canCancel_ = false;
+
+    void ExeSyncProcessCallFun(const std::map<std::string, DeviceSyncProcess> &syncProcessMap);
 };
 } // namespace DistributedDB
 
diff --git a/kv_store/frameworks/libs/distributeddb/syncer/src/time_helper.cpp b/kv_store/frameworks/libs/distributeddb/syncer/src/time_helper.cpp
index 21ff5eda7dbc1fc8d901881cc19aae7cc1013f6f..68ff51740da33327efacf1a90daea1076b6e469c 100644
--- a/kv_store/frameworks/libs/distributeddb/syncer/src/time_helper.cpp
+++ b/kv_store/frameworks/libs/distributeddb/syncer/src/time_helper.cpp
@@ -104,7 +104,7 @@ Timestamp TimeHelper::GetTime()
 {
     Timestamp currentSysTime = GetSysCurrentTime();
     TimeOffset localTimeOffset = GetLocalTimeOffset();
-    Timestamp currentLocalTime = currentSysTime + localTimeOffset;
+    Timestamp currentLocalTime = currentSysTime + static_cast<Timestamp>(localTimeOffset);
     Timestamp lastLocalTime = metadata_->GetLastLocalTime();
     Timestamp currentMonotonicTime = GetMonotonicTime();
     Timestamp deltaTime = 1UL;
diff --git a/kv_store/frameworks/libs/distributeddb/test/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/BUILD.gn
index 3ead7040cb438f9772eef9bf39422477b0b77e15..0b9c63217094f88ab9be94601dd60f7c3d9a1d6e 100644
--- a/kv_store/frameworks/libs/distributeddb/test/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/BUILD.gn
@@ -831,6 +831,11 @@ distributeddb_unittest("DistributedDBMetaDataTest") {
   sources = [ "unittest/common/syncer/distributeddb_meta_data_test.cpp" ]
 }
 
+distributeddb_unittest("DistributedDBCloudKvSyncerTest") {
+  sources =
+      [ "unittest/common/syncer/cloud/distributeddb_cloud_kv_syncer_test.cpp" ]
+}
+
 distributeddb_unittest("DistributedDBCloudKvTest") {
   sources = [ "unittest/common/syncer/cloud/distributeddb_cloud_kv_test.cpp" ]
 }
@@ -976,6 +981,8 @@ group("distributeddatamgr_fuzztest") {
     "fuzztest/fileoper_fuzzer:fuzztest",
     "fuzztest/importfile_fuzzer:fuzztest",
     "fuzztest/iprocesscommunicator_fuzzer:fuzztest",
+    "fuzztest/json_fuzzer:fuzztest",
+    "fuzztest/jsoninner_fuzzer:fuzztest",
     "fuzztest/kvdelegatemanager_fuzzer:fuzztest",
     "fuzztest/kvstoreresultset_fuzzer:fuzztest",
     "fuzztest/nbdelegate_fuzzer:fuzztest",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/BUILD.gn
index 9519d8c926423d1274af15db74f798a50f67360f..2dc2423435815a560c2253e9f0d310929523377c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/BUILD.gn
@@ -64,8 +64,13 @@ ohos_fuzztest("CloudsyncFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "../cloudsync_fuzzer"
 
   sources = distributeddb_src
@@ -91,6 +96,7 @@ ohos_fuzztest("CloudsyncFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_EXPORT_SYMBOLS",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/cloudsync_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/cloudsync_fuzzer.cpp
index 2b224344f4555a61d3541d25e236c9366a47fe4d..88fdeb087cc03355230e19a61e2ef600f5e46d20 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/cloudsync_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/cloudsync_fuzzer.cpp
@@ -38,6 +38,8 @@ static const char *g_storeId = "STORE_ID";
 static const char *g_dbSuffix = ".db";
 static const char *g_table = "worker1";
 KvStoreDelegateManager g_mgr(DistributedDBUnitTest::APP_ID, DistributedDBUnitTest::USER_ID);
+CloudSyncOption g_CloudSyncOption;
+const std::string USER_ID_2 = "user2";
 static const char *g_createLocalTableSql =
     "CREATE TABLE IF NOT EXISTS worker1(" \
     "name TEXT PRIMARY KEY," \
@@ -158,7 +160,7 @@ public:
         return asset;
     }
 
-    void InitDbAsset(const uint8_t* data, size_t size)
+    void InitDbAsset(const uint8_t *data, size_t size)
     {
         if (data == nullptr || size == 0) {
             return;
@@ -250,12 +252,18 @@ public:
         mgr_ = std::make_shared<RelationalStoreManager>("APP_ID", "USER_ID");
         RelationalStoreDelegate::Option option;
         mgr_->OpenStore(storePath_, "STORE_ID", option, delegate_);
+        g_CloudSyncOption.mode = SyncMode::SYNC_MODE_CLOUD_MERGE;
+        g_CloudSyncOption.users.push_back(DistributedDBUnitTest::USER_ID);
+        g_CloudSyncOption.devices.push_back("cloud");
         config_.dataDir = testDir_;
         g_mgr.SetKvStoreConfig(config_);
-        GetKvStore(kvDelegatePtrS1_, DistributedDBUnitTest::STORE_ID_1);
-        GetKvStore(kvDelegatePtrS2_, DistributedDBUnitTest::STORE_ID_2);
+        KvStoreNbDelegate::Option option1;
+        GetKvStore(kvDelegatePtrS1_, DistributedDBUnitTest::STORE_ID_1, option1);
+        KvStoreNbDelegate::Option option2;
+        GetKvStore(kvDelegatePtrS2_, DistributedDBUnitTest::STORE_ID_2, option2);
         virtualCloudDb_ = std::make_shared<VirtualCloudDb>();
         virtualCloudDb1_ = std::make_shared<VirtualCloudDb>();
+        virtualCloudDb2_ = std::make_shared<VirtualCloudDb>();
         virtualAssetLoader_ = std::make_shared<VirtualAssetLoader>();
         delegate_->SetCloudDB(virtualCloudDb_);
         delegate_->SetIAssetLoader(virtualAssetLoader_);
@@ -276,14 +284,15 @@ public:
         CloseKvStore(kvDelegatePtrS1_, DistributedDBUnitTest::STORE_ID_1);
         CloseKvStore(kvDelegatePtrS2_, DistributedDBUnitTest::STORE_ID_2);
         virtualCloudDb1_ = nullptr;
+        virtualCloudDb2_ = nullptr;
         virtualAssetLoader_ = nullptr;
         if (DistributedDBToolsTest::RemoveTestDbFiles(testDir_) != 0) {
             LOGE("rm test db files error.");
         }
     }
 
-    void KvBlockSync(KvStoreNbDelegate *delegate, DBStatus expectDBStatus,
-        SyncMode mode = SyncMode::SYNC_MODE_CLOUD_MERGE, int expectSyncResult = OK)
+    void KvBlockSync(KvStoreNbDelegate *delegate, DBStatus expectDBStatus, CloudSyncOption option,
+        int expectSyncResult = OK)
     {
         if (delegate == nullptr) {
             return;
@@ -292,25 +301,28 @@ public:
         std::condition_variable cv;
         bool finish = false;
         SyncProcess last;
-        auto callback = [expectDBStatus, &last, &cv, &dataMutex, &finish](
+        auto callback = [expectDBStatus, &last, &cv, &dataMutex, &finish, &option](
             const std::map<std::string, SyncProcess> &process) {
-            for (const auto &item: process) {
-                if (item.second.process == DistributedDB::FINISHED) {
-                    {
-                        std::lock_guard<std::mutex> autoLock(dataMutex);
+            size_t notifyCnt = 0;
+            for (const auto &item : process) {
+                LOGD("user = %s, status = %d", item.first.c_str(), item.second.process);
+                if (item.second.process != DistributedDB::FINISHED) {
+                    continue;
+                }
+                {
+                    std::lock_guard<std::mutex> autoLock(dataMutex);
+                    notifyCnt++;
+                    std::set<std::string> userSet(option.users.begin(), option.users.end());
+                    if (notifyCnt == userSet.size()) {
                         finish = true;
                         last = item.second;
+                        cv.notify_one();
                     }
-                    cv.notify_one();
                 }
             }
         };
-        CloudSyncOption option;
-        option.mode = mode;
-        option.users.push_back(DistributedDBUnitTest::USER_ID);
-        option.devices.push_back("cloud");
-        delegate->Sync(option, callback);
-        if (expectSyncResult == OK) {
+        auto result = delegate->Sync(option, callback);
+        if (result == OK) {
             std::unique_lock<std::mutex> uniqueLock(dataMutex);
             cv.wait(uniqueLock, [&finish]() {
                 return finish;
@@ -319,11 +331,11 @@ public:
         lastProcess_ = last;
     }
 
-    static DataBaseSchema GetDataBaseSchema()
+    static DataBaseSchema GetDataBaseSchema(bool invalidSchema)
     {
         DataBaseSchema schema;
         TableSchema tableSchema;
-        tableSchema.name = CloudDbConstant::CLOUD_KV_TABLE_NAME;
+        tableSchema.name = invalidSchema ? "invalid_schema_name" : CloudDbConstant::CLOUD_KV_TABLE_NAME;
         Field field;
         field.colName = CloudDbConstant::CLOUD_KV_FIELD_KEY;
         field.type = TYPE_INDEX<std::string>;
@@ -343,9 +355,9 @@ public:
         return schema;
     }
 
-    void GetKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId, int securityLabel = NOT_SET)
+    void GetKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId, KvStoreNbDelegate::Option option,
+        int securityLabel = NOT_SET, bool invalidSchema = false)
     {
-        KvStoreNbDelegate::Option option;
         DBStatus openRet = OK;
         option.secOption.securityLabel = securityLabel;
         g_mgr.GetKvStore(storeId, option, [&openRet, &delegate](DBStatus status, KvStoreNbDelegate *openDelegate) {
@@ -357,9 +369,11 @@ public:
         }
         std::map<std::string, std::shared_ptr<ICloudDb>> cloudDbs;
         cloudDbs[DistributedDBUnitTest::USER_ID] = virtualCloudDb1_;
+        cloudDbs[USER_ID_2] = virtualCloudDb2_;
         delegate->SetCloudDB(cloudDbs);
         std::map<std::string, DataBaseSchema> schemas;
-        schemas[DistributedDBUnitTest::USER_ID] = GetDataBaseSchema();
+        schemas[DistributedDBUnitTest::USER_ID] = GetDataBaseSchema(invalidSchema);
+        schemas[USER_ID_2] = GetDataBaseSchema(invalidSchema);
         delegate->SetCloudDbSchema(schemas);
     }
 
@@ -391,6 +405,29 @@ public:
         context->WaitForFinish();
     }
 
+    void OptionBlockSync(std::vector<std::string> devices, SyncMode mode = SYNC_MODE_CLOUD_MERGE)
+    {
+        Query query = Query::Select().FromTable({ g_table });
+        auto context = std::make_shared<CloudSyncContext>();
+        auto callback = [context](const std::map<std::string, SyncProcess> &onProcess) {
+            for (const auto &item : onProcess) {
+                if (item.second.process == ProcessStatus::FINISHED) {
+                    context->FinishAndNotify();
+                }
+            }
+        };
+        CloudSyncOption option;
+        option.mode = mode;
+        option.devices = devices;
+        option.query = query;
+        option.waitTime = DBConstant::MAX_TIMEOUT;
+        DBStatus status = delegate_->Sync(option, callback);
+        if (status != OK) {
+            return;
+        }
+        context->WaitForFinish();
+    }
+
     void NormalSync()
     {
         BlockSync();
@@ -403,13 +440,13 @@ public:
         Key key = {'k'};
         Value expectValue = {'v'};
         kvDelegatePtrS1_->Put(key, expectValue);
-        KvBlockSync(kvDelegatePtrS1_, OK);
-        KvBlockSync(kvDelegatePtrS2_, OK);
+        KvBlockSync(kvDelegatePtrS1_, OK, g_CloudSyncOption);
+        KvBlockSync(kvDelegatePtrS2_, OK, g_CloudSyncOption);
         Value actualValue;
         kvDelegatePtrS2_->Get(key, actualValue);
     }
 
-    void RandomModeSync(const uint8_t* data, size_t size)
+    void RandomModeSync(const uint8_t *data, size_t size)
     {
         if (size == 0) {
             BlockSync();
@@ -420,7 +457,7 @@ public:
         BlockSync(mode);
     }
 
-    void DataChangeSync(const uint8_t* data, size_t size)
+    void DataChangeSync(const uint8_t *data, size_t size)
     {
         SetCloudDbSchema(delegate_);
         if (size == 0) {
@@ -428,9 +465,29 @@ public:
         }
         InitDbData(db_, data, size);
         BlockSync();
+        FuzzerData fuzzerData(data, size);
+        CloudSyncConfig config;
+        int maxUploadSize = fuzzerData.GetInt();
+        int maxUploadCount = fuzzerData.GetInt();
+        config.maxUploadSize = maxUploadSize;
+        config.maxUploadCount = maxUploadCount;
+        delegate_->SetCloudSyncConfig(config);
+        kvDelegatePtrS1_->SetCloudSyncConfig(config);
+        uint32_t len = fuzzerData.GetUInt32() % MOD;
+        std::string version = fuzzerData.GetString(len);
+        kvDelegatePtrS1_->SetGenCloudVersionCallback([version](const std::string &origin) {
+            return origin + version;
+        });
+        KvNormalSync();
+        int count = fuzzerData.GetInt();
+        kvDelegatePtrS1_->GetCount(Query::Select(), count);
+        std::string device = fuzzerData.GetString(len);
+        kvDelegatePtrS1_->GetCloudVersion(device);
+        std::vector<std::string> devices = fuzzerData.GetStringVector(len);
+        OptionBlockSync(devices);
     }
 
-    void InitAssets(const uint8_t* data, size_t size)
+    void InitAssets(const uint8_t *data, size_t size)
     {
         FuzzerData fuzzerData(data, size);
         uint32_t len = fuzzerData.GetUInt32() % MOD;
@@ -440,7 +497,7 @@ public:
         }
     }
 
-    void AssetChangeSync(const uint8_t* data, size_t size)
+    void AssetChangeSync(const uint8_t *data, size_t size)
     {
         SetCloudDbSchema(delegate_);
         if (size == 0) {
@@ -451,7 +508,7 @@ public:
         BlockSync();
     }
 
-    void RandomModeRemoveDeviceData(const uint8_t* data, size_t size)
+    void RandomModeRemoveDeviceData(const uint8_t *data, size_t size)
     {
         if (size == 0) {
             return;
@@ -478,6 +535,7 @@ private:
     KvStoreNbDelegate* kvDelegatePtrS2_ = nullptr;
     std::shared_ptr<VirtualCloudDb> virtualCloudDb_;
     std::shared_ptr<VirtualCloudDb> virtualCloudDb1_ = nullptr;
+    std::shared_ptr<VirtualCloudDb> virtualCloudDb2_ = nullptr;
     std::shared_ptr<VirtualAssetLoader> virtualAssetLoader_;
     std::shared_ptr<RelationalStoreManager> mgr_;
     KvStoreConfig config_;
@@ -506,7 +564,7 @@ void TearDown()
     }
 }
 
-void CombineTest(const uint8_t* data, size_t size)
+void CombineTest(const uint8_t *data, size_t size)
 {
     if (g_cloudSyncTest == nullptr) {
         return;
@@ -521,10 +579,10 @@ void CombineTest(const uint8_t* data, size_t size)
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     OHOS::Setup();
     OHOS::CombineTest(data, size);
     OHOS::TearDown();
     return 0;
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/project.xml b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/project.xml
index 798d910c94cf92e0fe357b951465826f22462d4c..95d7da3361c69665cdb3fb901b1a9830d0edeaa8 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/project.xml
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/cloudsync_fuzzer/project.xml
@@ -18,7 +18,7 @@
     <!-- maximum length of a test input -->
     <max_len>1000</max_len>
     <!-- maximum total time in seconds to run the fuzzer -->
-    <max_total_time>30</max_total_time>
+    <max_total_time>600</max_total_time>
     <!-- memory usage limit in Mb -->
     <rss_limit_mb>4096</rss_limit_mb>
   </fuzztest>
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
index f06718b404ae3ffa283f1d67e525481fa7757615..3a8c93103a1093fc8a7c38fc07467d46ba39ba65 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.cpp
@@ -89,6 +89,15 @@ std::vector<std::string> FuzzerData::GetStringVector(size_t size)
     return vec;
 }
 
+std::set<std::string> FuzzerData::GetStringSet(size_t size)
+{
+    std::set<std::string> set;
+    for (size_t i = 1; i <= size; i++) {
+        set.insert(GetString(i));
+    }
+    return set;
+}
+
 std::vector<std::u16string> FuzzerData::GetU16StringVector(size_t size)
 {
     std::vector<std::u16string> vec;
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h b/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
index 135cabef97fa136be232270937e278f62acd6568..cbd2c5a1179a16934316dafa07f06b0a1aef8471 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/fuzzer_data.h
@@ -19,6 +19,7 @@
 
 #include <cstdint>
 #include <vector>
+#include <set>
 #include <string>
 
 namespace DistributedDBTest {
@@ -34,6 +35,7 @@ public:
     std::vector<uint8_t> GetSequence(size_t size, uint32_t mod = MOD);
     std::string GetString(size_t len);
     std::vector<std::string> GetStringVector(size_t size);
+    std::set<std::string> GetStringSet(size_t size);
     std::vector<std::u16string> GetU16StringVector(size_t size);
 private:
     static const uint32_t MOD = 1024; // MOD length
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/BUILD.gn
index 2029d533454030e96595cff25c8ce757bdc7d2c2..8e8f9b74d56f4ef15a445f0981d7301d0495c64a 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("DelegateFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer"
   sources = distributeddb_src
   sources += [
@@ -93,6 +98,7 @@ ohos_fuzztest("DelegateFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
index c2e20ea205748212bfeae57ee4308946fd72cfab..3d07c64178549d8448dba7ef85b566b2f20740df 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/delegate_fuzzer/delegate_fuzzer.cpp
@@ -21,11 +21,13 @@ using namespace DistributedDB;
 using namespace DistributedDBTest;
 
 namespace OHOS {
-std::vector<Entry> CreateEntries(const uint8_t* data, size_t size, std::vector<Key>& keys)
+static constexpr const int MOD = 1024; // 1024 is mod
+static constexpr const int PASSWDLEN = 20; // 20 is passwdlen
+std::vector<Entry> CreateEntries(const uint8_t *data, size_t size, std::vector<Key>& keys)
 {
     std::vector<Entry> entries;
     // key'length is less than 1024.
-    auto count = static_cast<int>(std::min(size, size_t(1024)));
+    auto count = static_cast<int>(std::min(size, size_t(MOD)));
     for (int i = 1; i < count; i++) {
         Entry entry;
         entry.key = std::vector<uint8_t>(data, data + 1);
@@ -51,7 +53,33 @@ KvStoreDelegate *PrepareKvStore(KvStoreConfig &config, KvStoreDelegate::Option &
     return kvDelegatePtr;
 }
 
-void MultiCombineFuzzer(const uint8_t* data, size_t size, KvStoreDelegate::Option &option)
+void EncryptOperation(const uint8_t *data, size_t size, KvStoreDelegate *kvDelegatePtr)
+{
+    if (kvDelegatePtr == nullptr) {
+        return;
+    }
+    CipherPassword passwd;
+    int len = static_cast<int>(std::min(size, size_t(PASSWDLEN)));
+    passwd.SetValue(data, len);
+    kvDelegatePtr->Rekey(passwd);
+    bool autoSync = (size == 0) ? true : data[0];
+    PragmaData praData = static_cast<PragmaData>(&autoSync);
+    kvDelegatePtr->Pragma(AUTO_SYNC, praData);
+}
+
+void CombineTest(const uint8_t *data, KvStoreDelegate *kvDelegatePtr)
+{
+    if (kvDelegatePtr == nullptr) {
+        return;
+    }
+    kvDelegatePtr->GetStoreId();
+    kvDelegatePtr->Rollback();
+    kvDelegatePtr->Commit();
+    auto type = static_cast<ResolutionPolicyType>(data[0]);
+    kvDelegatePtr->SetConflictResolutionPolicy(type, nullptr);
+}
+
+void MultiCombineFuzzer(const uint8_t *data, size_t size, KvStoreDelegate::Option &option)
 {
     KvStoreConfig config;
     KvStoreDelegate *kvDelegatePtr = PrepareKvStore(config, option);
@@ -66,7 +94,8 @@ void MultiCombineFuzzer(const uint8_t* data, size_t size, KvStoreDelegate::Optio
     Key key = std::vector<uint8_t>(data, data + (size % 1024)); /* 1024 is max */
     Value value = std::vector<uint8_t>(data, data + size);
     kvDelegatePtr->Put(key, value);
-    KvStoreSnapshotDelegate* kvStoreSnapshotPtr = nullptr;
+    kvDelegatePtr->StartTransaction();
+    KvStoreSnapshotDelegate *kvStoreSnapshotPtr = nullptr;
     kvDelegatePtr->GetKvStoreSnapshot(nullptr,
         [&kvStoreSnapshotPtr](DBStatus status, KvStoreSnapshotDelegate* kvStoreSnapshot) {
             kvStoreSnapshotPtr = std::move(kvStoreSnapshot);
@@ -89,10 +118,15 @@ void MultiCombineFuzzer(const uint8_t* data, size_t size, KvStoreDelegate::Optio
     kvStoreSnapshotPtr->GetEntries(keyPrefix, [](DBStatus status, const std::vector<Entry> &entries) {
         (void) entries.size();
     });
+    if (option.isEncryptedDb) {
+        EncryptOperation(data, size, kvDelegatePtr);
+    }
     kvDelegatePtr->DeleteBatch(keys);
     kvDelegatePtr->Clear();
+    CombineTest(data, kvDelegatePtr);
     kvDelegatePtr->UnRegisterObserver(observer);
     delete observer;
+    observer = nullptr;
     kvDelegatePtr->ReleaseKvStoreSnapshot(kvStoreSnapshotPtr);
     g_kvManger.CloseKvStore(kvDelegatePtr);
     g_kvManger.DeleteKvStore("distributed_delegate_test");
@@ -101,7 +135,7 @@ void MultiCombineFuzzer(const uint8_t* data, size_t size, KvStoreDelegate::Optio
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     CipherPassword passwd;
     KvStoreDelegate::Option option = {true, true, false, CipherType::DEFAULT, passwd};
@@ -110,4 +144,3 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     OHOS::MultiCombineFuzzer(data, size, option);
     return 0;
 }
-
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/fileoper_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/fileoper_fuzzer/BUILD.gn
index 2cec816d8eccff82ae7fc18ccd4e9e798050e5ca..c7fb71d3e660b6a7233d1b0ad3c3be7934e73307 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/fileoper_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/fileoper_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("FileOperFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/fileoper_fuzzer"
 
   sources = distributeddb_src
@@ -102,6 +107,7 @@ ohos_fuzztest("FileOperFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/importfile_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/importfile_fuzzer/BUILD.gn
index 26269592ecaab21673b2513e96d766b5ff309308..85fee558ba3455d71784e92b5d8f9cda32fd0fb8 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/importfile_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/importfile_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("ImportFileFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/importfile_fuzzer"
 
   sources = distributeddb_src
@@ -94,6 +99,7 @@ ohos_fuzztest("ImportFileFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/BUILD.gn
index d3fbf8a1296b48c0b303bed034a4c59ed4e7f103..c2683478394fb58d5ba8f54a148bfd15868ad56c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("IProcessCommunicatorFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer"
 
   sources = distributeddb_src
@@ -93,6 +98,7 @@ ohos_fuzztest("IProcessCommunicatorFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/iprocesscommunicator_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/iprocesscommunicator_fuzzer.cpp
index 8ddaf1cd49ce84240339d075356c2cfde2e52429..89abb799e225c53e43b72029cc6d6d3dce1610cd 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/iprocesscommunicator_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/iprocesscommunicator_fuzzer/iprocesscommunicator_fuzzer.cpp
@@ -15,8 +15,11 @@
 
 #include "iprocesscommunicator_fuzzer.h"
 #include <list>
-#include "iprocess_communicator.h"
 #include "distributeddb_tools_test.h"
+#include "db_info_handle.h"
+#include "iprocess_communicator.h"
+#include "iprocess_system_api_adapter.h"
+#include "runtime_config.h"
 
 using namespace DistributedDB;
 using namespace DistributedDBTest;
@@ -97,13 +100,65 @@ private:
     DistributedDB::OnDataReceive onDataReceive_ = nullptr;
 };
 
-void CommunicatorFuzzer(const uint8_t* data, size_t size)
+class ProcessSystemApiAdapterFuzzTest : public DistributedDB::IProcessSystemApiAdapter {
+public:
+    ~ProcessSystemApiAdapterFuzzTest() {}
+    DistributedDB::DBStatus RegOnAccessControlledEvent(const OnAccessControlledEvent &callback) override
+    {
+        callback_ = callback;
+        return DistributedDB::OK;
+    }
+
+    bool IsAccessControlled() const override
+    {
+        return true;
+    }
+
+    DistributedDB::DBStatus SetSecurityOption(const std::string &filePath, const SecurityOption &option) override
+    {
+        return DistributedDB::OK;
+    }
+
+    DistributedDB::DBStatus GetSecurityOption(const std::string &filePath, SecurityOption &option) const override
+    {
+        return DistributedDB::OK;
+    }
+
+    bool CheckDeviceSecurityAbility(const std::string &devId, const SecurityOption &option) const override
+    {
+        return true;
+    }
+private:
+    DistributedDB::OnAccessControlledEvent callback_;
+};
+
+class DBInfoHandleFuzzTest : public DistributedDB::DBInfoHandle {
+public:
+    ~DBInfoHandleFuzzTest() {}
+    bool IsSupport() override
+    {
+        return true;
+    }
+
+    bool IsNeedAutoSync(const std::string &userId, const std::string &appId, const std::string &storeId,
+        const DistributedDB::DeviceInfos &devInfo) override
+    {
+        return true;
+    }
+};
+
+void CommunicatorFuzzer(const uint8_t *data, size_t size)
 {
     static auto kvManager = KvStoreDelegateManager("APP_ID", "USER_ID");
     std::string rawString(reinterpret_cast<const char*>(data), size);
     KvStoreDelegateManager::SetProcessLabel(rawString, "defaut");
     auto communicator = std::make_shared<ProcessCommunicatorFuzzTest>();
     KvStoreDelegateManager::SetProcessCommunicator(communicator);
+    RuntimeConfig::SetProcessCommunicator(communicator);
+    auto adapter = std::make_shared<ProcessSystemApiAdapterFuzzTest>();
+    RuntimeConfig::SetProcessSystemAPIAdapter(adapter);
+    auto handleTest = std::make_shared<DBInfoHandleFuzzTest>();
+    RuntimeConfig::SetDBInfoHandle(handleTest);
     std::string testDir;
     DistributedDBToolsTest::TestDirInit(testDir);
     KvStoreConfig config;
@@ -127,7 +182,7 @@ void CommunicatorFuzzer(const uint8_t* data, size_t size)
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     // 4 bytes is required
     if (size < 4) {
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..48bf2bc8c10201dadda477f5c58b0e4511e5ab6d
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/BUILD.gn
@@ -0,0 +1,148 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "kv_store/kv_store"
+
+###############################################################################
+config("module_private_config") {
+  visibility = [ ":*" ]
+
+  include_dirs = [
+    "../../../gaussdb_rd/include",
+    "../../../gaussdb_rd/src/common/include",
+    "../../../gaussdb_rd/src/executor/include",
+    "../../../gaussdb_rd/src/executor/document",
+    "../../../gaussdb_rd/src/oh_adapter/include",
+    "../../../gaussdb_rd/src/oh_adapter/src",
+    "../../../gaussdb_rd/src/interface/include",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "SQLITE_ENABLE_DROPTABLE_CALLBACK",
+  ]
+}
+
+###############################################################################
+ohos_source_set("src_file") {
+  testonly = true
+
+  sources = [
+    "../../../gaussdb_rd/src/common/src/collection_option.cpp",
+    "../../../gaussdb_rd/src/common/src/db_config.cpp",
+    "../../../gaussdb_rd/src/common/src/grd_api_manager.cpp",
+    "../../../gaussdb_rd/src/common/src/json_common.cpp",
+    "../../../gaussdb_rd/src/common/src/os_api.cpp",
+    "../../../gaussdb_rd/src/common/src/rd_log_print.cpp",
+    "../../../gaussdb_rd/src/executor/base/grd_db_api.cpp",
+    "../../../gaussdb_rd/src/executor/base/grd_db_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/document/check_common.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_document_api.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_document_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_resultset_api.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_resultset_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/kv/grd_kv_api.cpp",
+    "../../../gaussdb_rd/src/executor/kv/grd_kv_api_inner.cpp",
+    "../../../gaussdb_rd/src/interface/src/collection.cpp",
+    "../../../gaussdb_rd/src/interface/src/doc_errno.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_key.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_store.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_store_manager.cpp",
+    "../../../gaussdb_rd/src/interface/src/projection_tree.cpp",
+    "../../../gaussdb_rd/src/interface/src/result_set.cpp",
+    "../../../gaussdb_rd/src/interface/src/result_set_common.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/kv_store_manager.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/rd_json_object.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/rd_sqlite_utils.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/sqlite_store_executor_impl.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = [ "//third_party/sqlite:sqlite" ]
+
+  configs += [ "//third_party/cJSON:cJSON_config" ]
+  ldflags = [ "-Wl,--exclude-libs,ALL" ]
+  deps += [ "//third_party/cJSON:cjson" ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "hitrace:hitrace_meter",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "kv_store"
+}
+
+ohos_fuzztest("JsonFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "../json_fuzzer"
+
+  if (!defined(deps)) {
+    deps = []
+  }
+  if (!defined(external_deps)) {
+    external_deps = []
+  }
+  configs = [ ":module_private_config" ]
+  deps += [
+    ":src_file",
+    "//third_party/sqlite:sqlite",
+  ]
+  configs += [ "//third_party/cJSON:cJSON_config" ]
+  ldflags = [ "-Wl,--exclude-libs,ALL" ]
+  deps += [
+    "//third_party/cJSON:cjson",
+    "//third_party/openssl:libcrypto_shared",
+  ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "hitrace:hitrace_meter",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+    "--coverage",
+  ]
+
+  ldflags += [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
+  sources = [ "json_fuzzer.cpp" ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":JsonFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/corpus/init b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..e7c3fecd8d4d4816e40088113a2316bb9eb2e13f
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a1bbce8aebbfa502b4af3a67abe8b643b5dcaeef
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.cpp
@@ -0,0 +1,1688 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "json_fuzzer.h"
+
+#include <climits>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <cstring>
+#include <dirent.h>
+#include <fcntl.h>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <vector>
+
+#include "grd_base/grd_db_api.h"
+#include "grd_base/grd_error.h"
+#include "grd_base/grd_resultset_api.h"
+#include "grd_document/grd_document_api.h"
+#include "grd_kv/grd_kv_api.h"
+#include "grd_resultset_inner.h"
+#include "securec.h"
+
+const char *TEST_DB = "./data";
+const char *TEST_DB_FILE = "./data/testfile";
+const char *COLLECTION_NAME = "collectionname";
+const char *OPTION_STR = "{ \"maxdoc\" : 1000}";
+const char *CONFIG_STR = "{}";
+const char *DB_DIR_PATH = "./data/";
+const char *NO_EXIST_COLLECTION_NAME = "no_exisit";
+const int NUM_THREE = 3;
+const int SMALL_PREFIX_LEN = 5;
+const int NUM_FIFTEEN = 15;
+const int NUM_NINETY_EIGHT = 98;
+const int BATCH_COUNT = 100;
+const int HALF_HALF_BYTES = 256;
+const int MORE_HALF_HALF_BYTES = 257;
+const int LESS_HALF_BYTES = 511;
+const int MORE_HALF_BYTES = 513;
+const int HALF_BYTES = 512;
+const int MAX_LEN_NUM = 600;
+const int LESS_MIDDLE_SIZE = 899;
+const int MIDDLE_SIZE = 900;
+const int MAX_SIZE_NUM = 1000;
+const int ONE_BYTES = 1024;
+const int CURSOR_COUNT = 50000;
+const int VECTOR_SIZE = 100000;
+
+static GRD_DB *g_db = nullptr;
+
+namespace OHOS {
+namespace {
+int RemoveDir(const char *dir)
+{
+    if (dir == nullptr) {
+        return -1;
+    }
+    if (access(dir, F_OK) != 0) {
+        return 0;
+    }
+    struct stat dirStat;
+    if (stat(dir, &dirStat) < 0) {
+        return -1;
+    }
+
+    char dirName[PATH_MAX];
+    DIR *dirPtr = nullptr;
+    struct dirent *dr = nullptr;
+    if (S_ISREG(dirStat.st_mode)) { // normal file
+        remove(dir);
+    } else if (S_ISDIR(dirStat.st_mode)) {
+        dirPtr = opendir(dir);
+        while ((dr = readdir(dirPtr)) != nullptr) {
+            // ignore . and ..
+            if ((strcmp(".", dr->d_name) == 0) || (strcmp("..", dr->d_name) == 0)) {
+                continue;
+            }
+            if (sprintf_s(dirName, sizeof(dirName), "%s / %s", dir, dr->d_name) < 0) {
+                (void)RemoveDir(dirName);
+                closedir(dirPtr);
+                rmdir(dir);
+                return -1;
+            }
+            (void)RemoveDir(dirName);
+        }
+        closedir(dirPtr);
+        rmdir(dir); // remove empty dir
+    } else {
+        return -1;
+    }
+    return 0;
+}
+
+void MakeDir(const char *dir)
+{
+    std::string tmpPath;
+    const char *pcur = dir;
+
+    while (*pcur++ != '\0') {
+        tmpPath.push_back(*(pcur - 1));
+        if ((*pcur == '/' || *pcur == '\0') && access(tmpPath.c_str(), 0) != 0 && !tmpPath.empty()) {
+            if (mkdir(tmpPath.c_str(), (S_IRUSR | S_IWUSR | S_IXUSR)) != 0) {
+                return;
+            }
+        }
+    }
+}
+
+std::string getMaxString()
+{
+    std::string str = "{";
+    for (int i = 0; i <= MAX_SIZE_NUM; i++) {
+        for (int j = 0; j <= MAX_LEN_NUM; j++) {
+            str += "a";
+        }
+    }
+    return str + "}";
+}
+} // namespace
+
+void InsertDocOneFuzz(const std::string documentData)
+{
+    std::string document2 = "{\"_id\":2,\"field\":\"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document2.c_str(), 0);
+    std::string document3 = "{\"_id\":true,\"field\":\"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document3.c_str(), 0);
+    std::string document4 = "{\"_id\" : null, \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document4.c_str(), 0);
+    std::string document5 = "{\"_id\" : [\"2\"], \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document5.c_str(), 0);
+    std::string document6 = "{\"_id\" : {\"val\" : \"2\"}, \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document6.c_str(), 0);
+    std::string document7 = "{\"_id\" : \"3\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document7.c_str(), 0);
+    std::string document9 = "{\"_id\" : \"4\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(NULL, COLLECTION_NAME, document9.c_str(), 0);
+    std::string document10 = "{\"_id\" : \"5\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, NULL, document10.c_str(), 0);
+    std::string document12 = "{\"_id\" : \"6\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document12.c_str(), 1);
+    std::string document13 = "{\"_id\" : \"7\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document13.c_str(), INT_MAX);
+    std::string document14 = "{\"_id\" : \"8\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document14.c_str(), INT_MIN);
+    GRD_InsertDoc(g_db, NULL, NULL, 0);
+    std::string document15 = "{\"_id\" : \"9\", \"name\" : \"" + documentData + "\"}";
+    std::string collectionName2(HALF_BYTES, 'a');
+    GRD_InsertDoc(g_db, collectionName2.c_str(), document15.c_str(), 0);
+    const char *collectionName = "collection@!#";
+    std::string document16 = "{\"_id\" : \"10\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, collectionName, document16.c_str(), GRD_OK);
+    std::string collectionName1(MORE_HALF_HALF_BYTES, 'k');
+    std::string document17 = "{\"_id\" : \"10\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, collectionName1.c_str(), document17.c_str(), GRD_OK);
+    std::string document18 = "({\"level1\" : {\"level2\" : {\"level3\" : {\"level4\": {\"level5\" : 1}},\
+        \"level3_2\" : \"" +
+        documentData + "\"}},\"_id\":\"14\"})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document18.c_str(), 0);
+    std::string document19 = "({\"level1\" : {\"level2\" : {\"level3\" : [{ \"level5\" : \"" + documentData + "\",\
+        \"level5_2\":\"" +
+        documentData + "\"}, \"" + documentData + "\",\"" + documentData + "\"], \"level3_2\":\
+        \"" +
+        documentData + "\"}}, \"_id\":\"14\"})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document19.c_str(), 0);
+    std::string document20 = "({\"level1\" : {\"level2\" : {\"level3\" : { \"level4\" : \"" + documentData + "\"},\
+        \"level3_2\" : \"" +
+        documentData + "\"}}, \"_id\":\"14\"})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document20.c_str(), 0);
+}
+
+void InsertDocTwoFuzz(const std::string documentData)
+{
+    std::string documentPart1 = "{ \"_id\" : \"15\", \"textVal\" : \" ";
+    std::string documentPart2 = "\" }";
+    std::string jsonVal = std::string(HALF_BYTES * ONE_BYTES - documentPart1.size() - documentPart2.size(), 'k');
+    std::string document = documentPart1 + jsonVal + documentPart2;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document.c_str(), 0);
+    std::string jsonVal2 = std::string(HALF_BYTES * ONE_BYTES - 1 - documentPart1.size() - documentPart2.size(), 'k');
+    std::string document21 = documentPart1 + jsonVal2 + documentPart2;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document21.c_str(), 0);
+    std::string document22 = "{\"_id\" : \"16\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document22.c_str(), 0);
+    std::string document23 =
+        "{\"_id\" : \"17\", \"level1\" : {\"level2\" : {\"level3\" : {\"level4\" : " + documentData + "\
+        } } }, \"level1_2\" : \"" +
+        documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document23.c_str(), 0);
+    std::string document24 = documentData;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document24.c_str(), 0);
+    std::string document25 = "{\"name\" : \"" + documentData + "\", \"age\" : " + documentData + ",\
+                            \"friend\" : {\"name\" : \" " +
+        documentData + "\"}, \"_id\" : \"19\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document25.c_str(), 0);
+    std::string collectionName3 = std::string(HALF_HALF_BYTES, 'k');
+    std::string document26 = "{\"_id\" : \"22\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, collectionName3.c_str(), document26.c_str(), GRD_OK);
+    std::string collectionName4 = "Aads_sd__23Asb_";
+    std::string document27 = "{\"_id\" : \"23\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, collectionName4.c_str(), document27.c_str(), GRD_OK);
+    std::string collectionName5 = "GRD_collectionName";
+    std::string document28 = "{\"_id\" : \"24\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document28.c_str(), 0);
+    collectionName5 = "GM_SYS__collectionName";
+    std::string document29 = "{\"_id\" : \"24_2\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document29.c_str(), 0);
+
+    collectionName5 = "grd_collectionName";
+    std::string document30 = "{\"_id\" : \"24_3\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document30.c_str(), 0);
+}
+
+void InsertDocThreeFuzz(const std::string documentData)
+{
+    std::string collectionName5 = "gm_sys_collectionName";
+    std::string document31 = "{\"_id\" : \"24_4\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document31.c_str(), 0);
+
+    collectionName5 = "gM_sYs_collectionName";
+    std::string document32 = "{\"_id\" : \"24_5\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document32.c_str(), 0);
+
+    collectionName5 = "gRd_collectionName";
+    std::string document33 = "{\"_id\" : \"24_6\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document33.c_str(), 0);
+
+    collectionName5 = "gRd@collectionName";
+    std::string document34 = "{\"_id\" : \"24_7\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollection(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDoc(g_db, collectionName5.c_str(), document34.c_str(), 0);
+
+    std::string document35 = "{\"_id\" : \"25_0\", \"level1\" : {\"level2\" : {\"level3\" :\
+        {\"level4\" : \"" +
+        documentData + "\"}}} , \"level1_2\" : \"" + documentData + "\" }";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document35.c_str(), 0);
+
+    std::string document36 = "{\"_id\" : \"25_1\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        { \"newName1\" : [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\"] }]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document36.c_str(), 0);
+
+    std::string document37 = "{\"_id\" : \"25_2\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\", {\"0ab\" : null}]]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document37.c_str(), 0);
+
+    std::string document38 = "{\"_id\" : \"25_3\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        { \"newName1\" : [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\", {\"level5\" : 1}] }]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document38.c_str(), 0);
+}
+
+void InsertDocFourFuzz(const std::string longId, const std::string documentData)
+{
+    std::string document39 =
+        "{\"_id\" : \"35\", \"A_aBdk_324_\" : \"" + documentData + "\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document39.c_str(), 0);
+
+    std::string document40 = "{\"_id\" : \"35_2\", \"1A_aBdk_324_\" : \"" + documentData +
+        "\", "
+        "\"name\" : \"" +
+        documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document40.c_str(), 0);
+    std::string document41 = "{\"_id\" : \"36_0\", \"stringType\" : \"" + documentData +
+        "\", \"numType\" : " + documentData + ", \"BoolType\" : true,\
+                          \"nullType\" : null, \"arrayType\" : " +
+        documentData + ", \"objectType\" : {\"A\" : 3}}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document41.c_str(), 0);
+
+    std::string document42 = "({\"_id\" : \"38_0\", \"field2\" : 1.797693" + longId + "13486232e308})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document42.c_str(), 0);
+    std::string document43 = "({\"_id\" : \"38_1\", \"t1\" : {\"field2\" : 1.797" + longId + "69313486232e308}})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document43.c_str(), 0);
+    std::string document44 = "({\"_id\" : \"38_2\", \"t1\" : [1, 2, 1.79769313486" + longId + "232e308]})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document44.c_str(), 0);
+    std::string document45 = "({\"_id\" : \"38_3\", \"t1\" : [1, 2, -1.7976931348623167" + longId + "E+308]})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document45.c_str(), 0);
+    std::string document46 = "({\"_id\" : \"38_4\", \"t1\" : [1, 2, -1." + longId + "79769313486231570E+308]})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document46.c_str(), 0);
+    std::string document47 = "({\"_id\" : \"38_5\", \"t1\" : [1, 2, 1.79769313486" + longId + "231570E+308]})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document47.c_str(), 0);
+
+    std::string doc1 = "{\"_id\" : ";
+    std::string doc2 = "\"";
+    std::string doc4 = "\"";
+    std::string doc5 = ", \"name\" : \"" + documentData + "\"}";
+    std::string documentMiddle(MIDDLE_SIZE, 'k');
+    std::string document48 = doc1 + doc2 + documentMiddle + doc4 + doc5;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document48.c_str(), 0);
+    std::string documentMiddle2(MAX_SIZE_NUM, 'k');
+    document48 = doc1 + doc2 + documentMiddle2 + doc4 + doc5;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document48.c_str(), 0);
+
+    std::string document49 = "({\"_id\":\"0123\", \"num\":\"" + documentData + "\"})";
+    std::string document50 = "({\"_id\":\"0123\", \"NUM\":\"" + documentData + "\"})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document49.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document50.c_str(), 0);
+
+    std::string document51 = "({\"_id\":\"0123\", \"num.\":\"" + documentData + "\"})";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document51.c_str(), 0);
+
+    const char *document52 = R""({})"";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document52, 0);
+}
+
+void InsertDocFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollection(g_db, collectionNameVal, optionStrVal, 0);
+    std::string documentData(reinterpret_cast<const char *>(data), size);
+    const char *documentVal = documentData.data();
+    GRD_InsertDoc(g_db, collectionNameVal, documentVal, 0);
+    GRD_InsertDoc(g_db, collectionNameVal, documentVal, 0);
+    std::string stringJson = "{" + documentData + "}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson.c_str(), 0);
+    std::string stringJson2 = "{\"_id\":\"1\",\"field\":\"" + documentData + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    std::string longId = "1";
+    for (int i = 0; i < MAX_SIZE_NUM; i++) {
+        longId += "1";
+    }
+    longId = "{\"_id\":\"" + longId + "\",\"field\":\"field_id\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, longId.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, "{\"_id\":123}", 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, "{\"field1.field2.field&*^&3\":\"anc\"}", 0);
+    InsertDocOneFuzz(documentData);
+    InsertDocTwoFuzz(documentData);
+    InsertDocThreeFuzz(documentData);
+    InsertDocFourFuzz(longId, documentData);
+
+    const char *document53 = R""({"empty" : null})"";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document53, 0);
+    GRD_DropCollection(g_db, collectionNameVal, 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+
+    std::string documentNew1 = "{\"_id\" : ";
+    std::string documentNew2 = "\"";
+    std::string documentNew3 = "\"";
+    std::string documentNew4 = ", \"name\" : \"Ori\"}";
+    std::string document = documentNew1 + documentNew2 + documentData + documentNew3 + documentNew4;
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document.c_str(), 0);
+}
+
+static const char *DOCUMENT1 = "{\"_id\" : \"1\", \"name\":\"doc1\",\"item\":\"journal\",\"personInfo\":\
+    {\"school\":\"AB\", \"age\" : 51}}";
+static const char *DOCUMENT2 = "{\"_id\" : \"2\", \"name\":\"doc2\",\"item\": 1, \"personInfo\":\
+    [1, \"my string\", {\"school\":\"AB\", \"age\" : 51}, true, {\"school\":\"CD\", \"age\" : 15}, false]}";
+static const char *DOCUMENT3 = "{\"_id\" : \"3\", \"name\":\"doc3\",\"item\":\"notebook\",\"personInfo\":\
+    [{\"school\":\"C\", \"age\" : 5}]}";
+static const char *DOCUMENT4 = "{\"_id\" : \"4\", \"name\":\"doc4\",\"item\":\"paper\",\"personInfo\":\
+    {\"grade\" : 1, \"school\":\"A\", \"age\" : 18}}";
+static const char *DOCUMENT5 = "{\"_id\" : \"5\", \"name\":\"doc5\",\"item\":\"journal\",\"personInfo\":\
+    [{\"sex\" : \"woma\", \"school\" : \"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT6 = "{\"_id\" : \"6\", \"name\":\"doc6\",\"item\":false,\"personInfo\":\
+    [{\"school\":\"B\", \"teacher\" : \"mike\", \"age\" : 15},\
+    {\"school\":\"C\", \"teacher\" : \"moon\", \"age\" : 20}]}";
+
+static const char *DOCUMENT7 = "{\"_id\" : \"7\", \"name\":\"doc7\",\"item\":\"fruit\",\"other_Info\":\
+    [{\"school\":\"BX\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT8 = "{\"_id\" : \"8\", \"name\":\"doc8\",\"item\":true,\"personInfo\":\
+    [{\"school\":\"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT9 = "{\"_id\" : \"9\", \"name\":\"doc9\",\"item\": true}";
+static const char *DOCUMENT10 = "{\"_id\" : \"10\", \"name\":\"doc10\", \"parent\" : \"kate\"}";
+static const char *DOCUMENT11 = "{\"_id\" : \"11\", \"name\":\"doc11\", \"other\" : \"null\"}";
+static const char *DOCUMENT12 = "{\"_id\" : \"12\", \"name\":\"doc12\",\"other\" : null}";
+static const char *DOCUMENT13 = "{\"_id\" : \"13\", \"name\":\"doc13\",\"item\" : \"shoes\",\"personInfo\":\
+    {\"school\":\"AB\", \"age\" : 15}}";
+static const char *DOCUMENT14 = "{\"_id\" : \"14\", \"name\":\"doc14\",\"item\" : true,\"personInfo\":\
+    [{\"school\":\"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 85}]}";
+static const char *DOCUMENT15 = "{\"_id\" : \"15\", \"name\":\"doc15\",\"personInfo\":[{\"school\":\"C\", \"age\" : "
+                                  "5}]}";
+static const char *DOCUMENT16 = "{\"_id\" : \"16\", \"name\":\"doc16\", \"nested1\":{\"nested2\":{\"nested3\":\
+    {\"nested4\":\"ABC\", \"field2\":\"CCC\"}}}}";
+static const char *DOCUMENT17 = "{\"_id\" : \"17\", \"name\":\"doc17\",\"personInfo\":\"oh,ok\"}";
+static const char *DOCUMENT18 = "{\"_id\" : \"18\", \"name\":\"doc18\",\"item\" : \"mobile phone\",\"personInfo\":\
+    {\"school\":\"DD\", \"age\":66}, \"color\":\"blue\"}";
+static const char *DOCUMENT19 = "{\"_id\" : \"19\", \"name\":\"doc19\",\"ITEM\" : true,\"PERSONINFO\":\
+    {\"school\":\"AB\", \"age\":15}}";
+static const char *DOCUMENT20 = "{\"_id\" : \"20\", \"name\":\"doc20\",\"ITEM\" : true,\"personInfo\":\
+    [{\"SCHOOL\":\"B\", \"AGE\":15}, {\"SCHOOL\":\"C\", \"AGE\":35}]}";
+static const char *DOCUMENT23 = "{\"_id\" : \"23\", \"name\":\"doc22\",\"ITEM\" : "
+                                  "true,\"personInfo\":[{\"school\":\"b\", \"age\":15}, [{\"school\":\"doc23\"}, 10, "
+                                  "{\"school\":\"doc23\"}, true, {\"school\":\"y\"}], {\"school\":\"b\"}]}";
+static std::vector<const char *> g_data = { DOCUMENT1, DOCUMENT2, DOCUMENT3, DOCUMENT4, DOCUMENT5,
+    DOCUMENT6, DOCUMENT7, DOCUMENT8, DOCUMENT9, DOCUMENT10, DOCUMENT11, DOCUMENT12, DOCUMENT13,
+    DOCUMENT14, DOCUMENT15, DOCUMENT16, DOCUMENT17, DOCUMENT18, DOCUMENT19, DOCUMENT20, DOCUMENT23 };
+
+namespace {
+static void InsertData(GRD_DB *g_db, const char *collectionName)
+{
+    for (const auto &item : g_data) {
+        GRD_InsertDoc(g_db, collectionName, item, 0);
+    }
+}
+
+void SetUpTestCase()
+{
+    (void)RemoveDir(TEST_DB);
+    MakeDir(TEST_DB);
+    GRD_DBOpen(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &g_db);
+    InsertData(g_db, COLLECTION_NAME);
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+}
+
+void TearDownTestCase()
+{
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    GRD_DBClose(g_db, GRD_DB_CLOSE);
+    (void)RemoveDir(TEST_DB);
+    g_db = nullptr;
+}
+
+void FindDocResultSetFuzz(const char *collName, const std::string filter, const std::string projectionInfo)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, collName, query, 1, &resultSet);
+    if (resultSet != nullptr) {
+        GRD_Next(resultSet);
+        char *valueResultSet = nullptr;
+        GRD_GetValue(resultSet, &valueResultSet);
+    }
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocWithFlagFuzz(const std::string filter, const std::string projectionInfo, int flag)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocNextTwiceFuzz(const std::string filter, const std::string projectionInfo)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocZeroFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : \"6\", \"name\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"name\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : \"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : 1}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : [\"" + input + "\", 1]}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : {\"" + input + "\" : \"1\"}}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : null}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    const char *collName1 = "grd_type";
+    const char *collName2 = "GM_SYS_sysfff";
+    filter = "{\"_id\" : \"1\"}";
+    FindDocResultSetFuzz(collName1, filter, R"({})");
+    FindDocResultSetFuzz(collName2, filter, R"({})");
+
+    filter = "{\"_id\" : \"100\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+}
+
+void FindDocOneFuzz()
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_ResultSet *resultSet2 = nullptr;
+    Query query = { filter.c_str(), "{}" };
+    const char *collectionName = "DocumentDBFindTest024";
+    GRD_CreateCollection(g_db, collectionName, "", 0);
+    InsertData(g_db, collectionName);
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FindDoc(g_db, collectionName, query, 1, &resultSet2);
+
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+
+    GRD_Next(resultSet2);
+    char *value2 = nullptr;
+    GRD_GetValue(resultSet2, &value2);
+    GRD_FreeValue(value2);
+
+    GRD_Next(resultSet);
+    GRD_Next(resultSet2);
+    GRD_GetValue(resultSet, &value);
+    GRD_GetValue(resultSet2, &value);
+    GRD_FreeResultSet(resultSet);
+    GRD_FreeResultSet(resultSet2);
+    GRD_DropCollection(g_db, collectionName, 0);
+
+    filter = "{\"_id\" : \"16\"}";
+    resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": true, \"nested1.nested2.nested3.nested4\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeResultSet(resultSet);
+
+    projectionInfo = "{\"name\": true, \"nested1\":{\"nested2\":{\"nested3\":{\"nested4\":true}}}}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocTwoFuzz(const std::string &input)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": 0, \"nested1.nested2.nested3.nested4\":0}";
+    std::string filter = "{\"_id\" : \"16\"}";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+
+    projectionInfo = "{\"name\": \"" + input + "\", \"nested1.nested2.nested3.nested4\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+
+    filter = "{\"_id\" : \"7\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"name\": true, \"other_Info\":true, \"non_exist_field\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+
+    projectionInfo = "{\"name\": true, \"other_Info\":true, \" item \":true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+}
+
+void FindDocThreeFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"7\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": true, \"other_Info.non_exist_field\":true}";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+    projectionInfo = "{\"name\": true, \"other_Info\":{\"non_exist_field\":true}}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+    projectionInfo = "{\"name\": true, \"other_Info.0\": true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+    filter = "{\"_id\" : \"4\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"personInfo\": true, \"personInfo.grade\": true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"non_exist_field\":true}";
+    int flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"name\":true, \"item\":true}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    projectionInfo = "{\"name\": " + input + ", \"item\": " + input + "}";
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"name\":false, \"item\":false}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    projectionInfo = "{\"name\": " + input + ", \"item\": " + input + "}";
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"4\"}";
+    projectionInfo = "{\"name\": " + input + ", \"personInfo.grade1\": " + input + ", \
+            \"personInfo.shool1\": " +
+        input + ", \"personInfo.age1\": " + input + "}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    projectionInfo = "{\"name\": false, \"personInfo.grade1\": false, \
+            \"personInfo.shool1\": false, \"personInfo.age1\": false}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+}
+
+void FindDocFourFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"4\"}";
+    std::string projectionInfo =
+        "{\"name\": " + input + ", \"personInfo.school\": " + input + ", \"personInfo.age\": " + input + "}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+
+    filter = "{\"_id\" : \"17\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), "{}" };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, GRD_DOC_ID_DISPLAY, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeResultSet(resultSet);
+
+    resultSet = nullptr;
+    query = { filter.c_str(), "{}" };
+    GRD_FindDoc(g_db, "", query, 0, &resultSet);
+    GRD_FindDoc(g_db, nullptr, query, 0, &resultSet);
+
+    filter = "{\"_id\" : \"4\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"name\":" + input + ", \"personInfo\":0, \"item\":" + input + "}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":true, \"personInfo\":0, \"item\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":\"\", \"personInfo\":0, \"item\":\"\"}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":1, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":-1.123, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":true, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+}
+
+void FindDocFiveFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    std::string projectionInfo = "{\"name\":false, \"personInfo\": 0, \"item\":0}";
+    int flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+
+    filter = "{\"_id\" : \"18\"}";
+    projectionInfo = "{\"name\":true, \"personInfo.age\": \"\", \"item\":1, \"color\":10, \"nonExist\" : "
+                     "-100}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+
+    GRD_ResultSet *resultSet = nullptr;
+    projectionInfo = "{\"personInfo\":[true, " + input + "]}";
+    flag = 1;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    projectionInfo = "{\"personInfo\":null}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    resultSet = nullptr;
+    projectionInfo = "{\"Name\":true, \"personInfo.age\": \"\", \"item\":" + input + ", \"COLOR\":" + input +
+        ", \"nonExist\" : "
+        "" +
+        input + "}";
+    flag = 0;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    GRD_Next(resultSet);
+    GRD_FreeResultSet(resultSet);
+
+    resultSet = nullptr;
+    projectionInfo = "{\"Name\":" + input + ", \"personInfo.age\": false, \"personInfo.SCHOOL\": false, \"item\":\
+        false, \"COLOR\":false, \"nonExist\" : false}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    char *value = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_Next(resultSet);
+    GRD_FreeResultSet(resultSet);
+
+    filter = "{\"_id\" : \"18\"}";
+    resultSet = nullptr;
+    query = { filter.c_str(), "{}" };
+    std::string collectionName1(LESS_HALF_BYTES, 'a');
+    GRD_FindDoc(g_db, collectionName1.c_str(), query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocSixFuzz(const std::string &input)
+{
+    std::string collectionName2(HALF_BYTES, 'a');
+    std::string filter = "{\"_id\" : \"18\"}";
+    Query query = { filter.c_str(), "{}" };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDoc(g_db, collectionName2.c_str(), query, 1, &resultSet);
+    GRD_FindDoc(g_db, "", query, 1, &resultSet);
+
+    resultSet = nullptr;
+    std::string projectionInfo = "{}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, NUM_THREE, &resultSet);
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, INT_MAX, &resultSet);
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, INT_MIN, &resultSet);
+    GRD_FindDoc(nullptr, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, nullptr);
+    query = { nullptr, nullptr };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    std::string document1 = "{\"_id\" : ";
+    std::string document2 = "\"";
+    std::string document4 = "\"";
+    std::string document5 = "}";
+    std::string documentMiddle(MIDDLE_SIZE, 'k');
+    filter = document1 + document2 + documentMiddle + document4 + document5;
+    resultSet = nullptr;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    std::string documentMiddle2(LESS_MIDDLE_SIZE, 'k');
+    filter = document1 + document2 + documentMiddle2 + document4 + document5;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_FreeResultSet(resultSet);
+
+    filter = "{\"personInfo\" : {\"school\":\"" + input + "\"}}";
+    FindDocNextTwiceFuzz(filter, R"({})");
+
+    projectionInfo = "{\"version\": " + input + "}";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    projectionInfo = "({\"a00001\":" + input + ", \"a00001\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    projectionInfo = "({\"abc123_.\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    filter = "({\"abc123_.\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+}
+
+void FindDocSevenFuzz(const std::string &input)
+{
+    std::string document064 = "{\"_id\" : \"64\", \"a\":" + input + ", \"doc64\" : " + input + "}";
+    std::string document063 = "{\"_id\" : \"63\", \"a\":" + input + ", \"doc63\" : " + input + "}";
+    std::string document062 = "{\"_id\" : \"62\", \"a\":" + input + ", \"doc62\" : " + input + "}";
+    std::string document061 = "{\"_id\" : \"61\", \"a\":" + input + ", \"doc61\" : " + input + "}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document064.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document063.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document062.c_str(), 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document061.c_str(), 0);
+    std::string filter = "{\"a\":" + input + "}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = R"({})";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+}
+
+void FindDocFuzzPlus(const std::string &input)
+{
+    FindDocZeroFuzz(input);
+    std::string filter = "{\"_id\" : \"6\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+    FindDocOneFuzz();
+    FindDocTwoFuzz(input);
+    FindDocThreeFuzz(input);
+    FindDocFourFuzz(input);
+    FindDocFiveFuzz(input);
+    FindDocSixFuzz(input);
+    FindDocSevenFuzz(input);
+
+    std::string document = "{\"a\":" + input + ", \"doc64\" : " + input + "}";
+    filter = "{\"b\":" + input + "}";
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    filter = "{\"a\":" + input + "}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = R"({})";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_Next(resultSet);
+    GRD_FreeResultSet(resultSet);
+    filter = "{\"a\":" + input + "}";
+    resultSet = nullptr;
+    projectionInfo = R"({})";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    GRD_Next(resultSet);
+    char *valueNew = nullptr;
+    GRD_GetValue(resultSet, &valueNew);
+    GRD_FreeValue(valueNew);
+    GRD_FreeResultSet(resultSet);
+    filter = "{\"personInfo\" : {\"school\":" + input + "}" + "}";
+    FindDocNextTwiceFuzz(filter, R"({})");
+}
+} // namespace
+
+void FindDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"field\":\"" + input + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    Query query = { inputJson.c_str(), inputJson.c_str() };
+    GRD_ResultSet *resultSet = nullptr;
+    // ResultSet conflict
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, input.c_str(), query, size, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    GRD_FindDoc(nullptr, input.c_str(), query, 1, &resultSet);
+    query.filter = nullptr;
+    GRD_FindDoc(g_db, input.c_str(), query, 1, &resultSet);
+    inputJson = "{\"field\": 0, \"field2\":" + input + "}";
+    query.filter = "{}";
+    query.projection = inputJson.c_str();
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    inputJson = "{\"" + input + "\": 0}";
+    query.projection = inputJson.c_str();
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    inputJson = "{\"field\":[\"aaa\"," + input + "]}";
+    resultSet = nullptr;
+    query.projection = inputJson.c_str();
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    query.filter = "{\"field\": false}";
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSet(resultSet);
+    FindDocFuzzPlus(input);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+}
+
+void UpdateDocOneFuzz(std::string s, const std::string input)
+{
+    std::string inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc6\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc7\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc8\"}", inputJson.c_str(), 1);
+
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, input.c_str(), "{}", 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{}", input.c_str(), 0);
+    GRD_UpdateDoc(nullptr, COLLECTION_NAME, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc6\"}", "{\"c0.c1\":false}", 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc7\"}", "{\"c0.c1\":null}", 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"name\":\"doc8\"}", "{\"c0.0\":\"ac\"}", 1);
+}
+
+void UpdateDocTwoFuzz(const char *newCollName, std::string s, const std::string input)
+{
+    std::string inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc6\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc7\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc8\"}", inputJson.c_str(), 1);
+
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDoc(g_db, newCollName, input.c_str(), "{}", 0);
+    GRD_UpdateDoc(g_db, newCollName, "{}", input.c_str(), 0);
+    GRD_UpdateDoc(nullptr, newCollName, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_InsertDoc(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc6\"}", "{\"c0.c1\":false}", 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_InsertDoc(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc7\"}", "{\"c0.c1\":null}", 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_InsertDoc(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDoc(g_db, newCollName, "{\"name\":\"doc8\"}", "{\"c0.0\":\"ac\"}", 1);
+}
+
+void UpdateDocFilterFuzz()
+{
+    const char *filter = "{\"_id\" : \"1\"}";
+    const char *updata2 = "{\"objectInfo.child.child\" : {\"child\":{\"child\":null}}}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter, updata2, 0);
+
+    const char *filter1 = "{\"_id\" : \"1\"}";
+    const char *updata1 = "{\"_id\" : \"6\"}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter1, updata1, 0);
+
+    const char *filter2 = "{\"_id\" : \"1\"}";
+    const char *updata3 = "{\"age$\" : \"21\"}";
+    const char *updata4 = "{\"bonus..traffic\" : 100}";
+    const char *updata5 = "{\"0item\" : 100}";
+    const char *updata6 = "{\"item\" : 1.79769313486232e308}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter2, updata3, 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter2, updata4, 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter2, updata5, 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter2, updata6, 0);
+
+    const char *filter3 = "{\"_id\" : \"1\"}";
+    const char *updata7 = "{\"age\" : 21}";
+    GRD_UpdateDoc(g_db, NULL, filter3, updata7, 0);
+    GRD_UpdateDoc(g_db, "", filter3, updata7, 0);
+    GRD_UpdateDoc(NULL, COLLECTION_NAME, filter3, updata7, 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, NULL, updata7, 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, filter3, NULL, 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+}
+
+void UpdateDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"_id\":\"2\", \"field\": \"aaa\", "
+                            "\"subject\":\"aaaaaaaaaaa\", \"test1\": true, "
+                            "\"test2\": null}";
+
+    GRD_UpdateDoc(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, input.c_str(), "{}", 0);
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{}", input.c_str(), 0);
+    GRD_UpdateDoc(nullptr, COLLECTION_NAME, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    std::string s;
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    UpdateDocOneFuzz(s, input);
+
+    const char *newCollName = "./student";
+    GRD_UpdateDoc(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDoc(g_db, newCollName, input.c_str(), "{}", 0);
+    GRD_UpdateDoc(g_db, newCollName, "{}", input.c_str(), 0);
+    GRD_UpdateDoc(nullptr, newCollName, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDoc(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+
+    UpdateDocTwoFuzz(newCollName, s, input);
+    UpdateDocFilterFuzz();
+}
+
+void UpsertDocNewFuzz(const std::string input, GRD_DB *db1)
+{
+    GRD_CreateCollection(g_db, "student", "", 0);
+    std::string documentNew =
+        "{\"name\": {\"first\":[\"XXX\", \"BBB\", \"CCC\"], \"last\":\"moray\", \"field\":" + input + "}";
+    std::string updateDocNew = R""({"name.last.AA.B":"Mnado"})"";
+    GRD_UpsertDoc(g_db, "student", R""({"_id":"10001"})"", documentNew.c_str(), 0);
+    GRD_UpsertDoc(db1, "student", R""({"_id":"10001"})"", updateDocNew.c_str(), 1);
+    GRD_DropCollection(g_db, "student", 0);
+
+    GRD_CreateCollection(g_db, "student", "", 0);
+    documentNew = "{\"name\":[\"Tmn\", \"BB\", \"Alice\"], \"field\":" + input + "}";
+    updateDocNew = R""({"name.first":"GG"})"";
+    GRD_UpsertDoc(g_db, "student", R""({"_id":"10002"})"", documentNew.c_str(), 0);
+    GRD_UpsertDoc(db1, "student", R""({"_id":"10002"})"", updateDocNew.c_str(), 1);
+}
+
+void UpsertDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJsonNoId = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    std::string inputJson = "{\"_id\":\"1\", \"field\": " + input + "}";
+
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpsertDoc(g_db, input.c_str(), "{}", "{}", 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), "{}", 0);
+    inputJson = "{\"_id\":\"1\", \"field\":" + input + "}";
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(nullptr, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, nullptr, inputJson.c_str(), 1);
+    GRD_UpsertDoc(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), BATCH_COUNT);
+
+    const char *newCollName = "./student";
+    GRD_DB *db1 = nullptr;
+    GRD_CreateCollection(db1, newCollName, "", 0);
+    GRD_InsertDoc(db1, newCollName, inputJson.c_str(), 0);
+    GRD_UpsertDoc(db1, input.c_str(), "{}", "{}", 0);
+    GRD_UpsertDoc(db1, newCollName, inputJson.c_str(), "{}", 0);
+    inputJson = "{\"_id\":\"1\", \"field\":" + input + "}";
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"newID1999\"}", inputJsonNoId.c_str(), 0);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"newID1999a\"}", inputJsonNoId.c_str(), 1);
+    GRD_UpsertDoc(nullptr, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDoc(db1, newCollName, nullptr, inputJson.c_str(), 1);
+    GRD_UpsertDoc(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), BATCH_COUNT);
+    GRD_DropCollection(db1, newCollName, 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+
+    UpsertDocNewFuzz(input, db1);
+}
+
+void DeleteDocResultFuzz(const std::string input)
+{
+    const char *filter = "{\"age\" : 15}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter, 0);
+    const char *filter1 = "{\"_id\" : \"1\", \"age\" : 15}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter1, 0);
+    std::string filter2 = "{\"_id\" : \"1\", \"name\" : " + input + "}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter2.c_str(), 1);
+    GRD_DeleteDoc(g_db, NULL, filter2.c_str(), 0);
+    GRD_DeleteDoc(g_db, "", filter2.c_str(), 1);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter2.c_str(), 0);
+
+    const char *filter3 = "{\"_id\" : \"1\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter3, "{}" };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter3, 0);
+
+    const char *filter4 = "{\"_id\" : \"1\"}";
+    std::string collectionName1(LESS_HALF_BYTES, 'a');
+    GRD_CreateCollection(g_db, collectionName1.c_str(), "", 0);
+    GRD_DeleteDoc(g_db, collectionName1.c_str(), filter4, 0);
+    GRD_DropCollection(g_db, collectionName1.c_str(), 0);
+    GRD_FreeResultSet(resultSet);
+
+    GRD_DeleteDoc(NULL, COLLECTION_NAME, filter2.c_str(), 0);
+    GRD_DeleteDoc(g_db, NULL, filter2.c_str(), 0);
+    GRD_DeleteDoc(g_db, "", filter2.c_str(), 0);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, NULL, 0);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, "", 0);
+    GRD_DeleteDoc(g_db, "notExisted", filter2.c_str(), 0);
+
+    std::vector<std::string> filterVec = { R"({"_id" : 1})", R"({"_id":[1, 2]})", R"({"_id" : {"t1" : 1}})",
+        R"({"_id":null})", R"({"_id":true})", R"({"_id" : 1.333})", R"({"_id" : -2.0})" };
+    for (const auto &item : filterVec) {
+        GRD_DeleteDoc(g_db, COLLECTION_NAME, item.c_str(), 0);
+    }
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter2.c_str(), 0);
+
+    std::string filter5 = "{\"subject.info\" : \"" + input + "\"}";
+    resultSet = nullptr;
+    query = { filter2.c_str(), "{}" };
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, filter5.c_str(), 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    GRD_FreeResultSet(resultSet);
+}
+
+void DeleteDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"field\":" + input + "}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_DeleteDoc(g_db, input.c_str(), "{}", 0);
+    GRD_DeleteDoc(g_db, nullptr, "{}", 0);
+    std::string longName = "";
+    for (int i = 0; i < MORE_HALF_BYTES; i++) {
+        longName += 'a';
+    }
+    GRD_DeleteDoc(g_db, "grd_name", "{}", 0);
+    GRD_DeleteDoc(g_db, longName.c_str(), "{}", 0);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field1\":" + input + "}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field\":\"" + input + "\"}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field1\":\"" + input + "\"}";
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+
+    const char *document1 = "{  \
+        \"_id\" : \"1\", \
+        \"name\": \"xiaoming\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"math\", \"English\", \"music\", {\"info\" : \"exam\"}] \
+    }";
+    const char *document2 = "{  \
+        \"_id\" : \"2\", \
+        \"name\": \"ori\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"math\", \"English\", \"music\"] \
+    }";
+    const char *document3 = "{  \
+        \"_id\" : \"3\", \
+        \"name\": \"David\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"Sing\", \"Jump\", \"Rap\", \"BasketBall\"] \
+    }";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document1, 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document2, 0);
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document3, 0);
+    GRD_DeleteDoc(g_db, COLLECTION_NAME, "{}", 0);
+
+    DeleteDocResultFuzz(input);
+}
+
+namespace {
+void FindAndRelease(Query query)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    char *value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+
+    const char *newCollName = "./student";
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, newCollName, query, 1, &resultSet);
+    GRD_Next(resultSet);
+    value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+    resultSet = nullptr;
+    GRD_FindDoc(g_db, newCollName, query, 0, &resultSet);
+    GRD_Next(resultSet);
+    value = nullptr;
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+}
+} // namespace
+
+void FindAndReleaseFuzz(std::string document, std::string filter, Query query, const std::string input)
+{
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document.c_str(), 0);
+    query.filter = filter.c_str();
+    query.projection = "{\"field\": 0}";
+    FindAndRelease(query);
+    document = "{\"field1.field2\" [false], \"field1.field2.field3\": [3], "
+               "\"field1.field4\": [null]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document.c_str(), 0);
+    query.filter = document.c_str();
+    query.projection = "{\"field\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field.field2\": 1}";
+    FindAndRelease(query);
+    document = "{\"field1\": {\"field2\": [{\"field3\":\"" + input + "\"}]}}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, document.c_str(), 0);
+    filter = "{\"field1.field2.field3\":\"" + input + "\"}";
+    query.filter = filter.c_str();
+    query.projection = "{\"field1.field2\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field2\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field3\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field3\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field2.field3\": 0, \"field1.field2.field3\": 0}";
+    FindAndRelease(query);
+    std::string projection = "{\"field1\": \"" + input + "\"}";
+    query.projection = projection.c_str();
+    FindAndRelease(query);
+    projection = "{\"" + input + "\": true, \"" + input + "\": false}";
+    query.projection = projection.c_str();
+    FindAndRelease(query);
+}
+
+void NextFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{" + input + "}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    Query query = { inputJson.c_str(), "{}" };
+    FindAndRelease(query);
+    std::string stringJson2 = "{ \"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    query.filter = "{\"_id\": \"1\"}";
+    FindAndRelease(query);
+    std::string filter2 = "{ \"_id\":\"1\", \"field\":\"" + input + " invalid\"}";
+    query.filter = filter2.c_str();
+    FindAndRelease(query);
+    query.filter = "{\"_id\": \"3\"}";
+    FindAndRelease(query);
+    std::string stringJson3 = "{ \"_id\":\"2\", \"field\": [\"field2\", null, \"abc\", 123]}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, stringJson3.c_str(), 0);
+    query.filter = "{\"field\": [\"field2\", null, \"abc\", 123]}";
+    FindAndRelease(query);
+    std::string document = "{\"field\": [\"" + input + "\",\"" + input + "\",\"" + input + "\"]}";
+    std::string filter = "{\"field." + std::to_string(size) + "\":\"" + input + "\"}";
+    FindAndReleaseFuzz(document, filter, query, input);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+}
+
+void GetValueFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollection(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{" + input + "}";
+    GRD_InsertDoc(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    char *value = nullptr;
+    Query query = { inputJson.c_str(), "{}" };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDoc(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_Next(resultSet);
+    GRD_GetValue(resultSet, &value);
+    GRD_FreeValue(value);
+    GRD_FreeResultSet(resultSet);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+}
+
+void FreeResultSetFuzz()
+{
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FreeResultSet(resultSet);
+    resultSet = new GRD_ResultSet;
+    resultSet->resultSet_ = DocumentDB::ResultSet();
+    GRD_FreeResultSet(resultSet);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+}
+
+void DbOpenOneFuzz(GRD_DB *dbVal)
+{
+    std::string path = "./documentFuzz.db";
+    GRD_DBOpen(path.c_str(), "", GRD_DB_OPEN_ONLY, &dbVal);
+    (void)remove(path.c_str());
+
+    path = "./document.db";
+    GRD_DBOpen(path.c_str(), R""({"pageSize":64, "redopubbufsize":4033})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBClose(dbVal, 0);
+    GRD_DBOpen(path.c_str(), R""({"pageSize":64, "redopubbufsize":4032})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpen(path.c_str(), R""({"redopubbufsize":255})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpen(path.c_str(), R""({"redopubbufsize":16385})"", GRD_DB_OPEN_CREATE, &dbVal);
+}
+
+void DbOpenFuzz(const uint8_t *data, size_t size)
+{
+    std::string dbFileData(reinterpret_cast<const char *>(data), size);
+    std::string realDbFileData = DB_DIR_PATH + dbFileData;
+    const char *dbFileVal = realDbFileData.data();
+    std::string configStrData(reinterpret_cast<const char *>(data), size);
+    const char *configStrVal = configStrData.data();
+    GRD_DB *dbVal = nullptr;
+
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    std::string stringMax = getMaxString();
+    const char *configStrMaxLen = stringMax.data();
+    GRD_DBOpen(dbFileVal, configStrMaxLen, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValue = "{\"bufferPoolSize\": \"1024.5\"}";
+    const char *configStrStringValue = fieldStringValue.data();
+    GRD_DBOpen(dbFileVal, configStrStringValue, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldBoolValue = "{\"bufferPoolSize\":}";
+    const char *configStrBool = fieldBoolValue.data();
+    GRD_DBOpen(dbFileVal, configStrBool, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueAppend = "{\"bufferPoolSize\":\"8192\"}";
+    const char *configStrStr = fieldStringValueAppend.data();
+    GRD_DBOpen(dbFileVal, configStrStr, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueFlush = "{\"bufferPoolSize\":\"8192\",\"redoFlushBtTrx\":\"1\"}";
+    const char *configStrFlush = fieldStringValueFlush.data();
+    GRD_DBOpen(dbFileVal, configStrFlush, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueRedoBufsize = "{\"bufferPoolSize\":\"8192\",\"redoBufSize\":\"16384\"}";
+    const char *configStrBs = fieldStringValueRedoBufsize.data();
+    GRD_DBOpen(dbFileVal, configStrBs, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueMaxConnNum = "{\"bufferPoolSize\":\"8192\",\"maxConnNum\":\"1024\"}";
+    const char *configStrMcn = fieldStringValueMaxConnNum.data();
+    GRD_DBOpen(dbFileVal, configStrMcn, GRD_DB_OPEN_CREATE, &dbVal);
+
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    std::string fieldStringValueAll = "{\"bufferPoolSize\":\"8192\",\"redoFlushBtTrx\":\"1\",\"redoBufSize\":"
+                                        "\"16384\",\"maxConnNum\":\"1024\"}";
+    const char *configStrAll = fieldStringValueAll.data();
+    GRD_DBOpen(dbFileVal, configStrAll, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldLowNumber = "{\"bufferPoolSize\": 102}";
+    const char *configStrLowNumber = fieldLowNumber.data();
+    GRD_DBOpen(dbFileVal, configStrLowNumber, GRD_DB_OPEN_CREATE, &dbVal);
+
+    GRD_DBOpen(nullptr, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpen(dbFileVal, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBClose(nullptr, GRD_DB_CLOSE);
+    GRD_DBClose(dbVal, GRD_DB_CLOSE);
+
+    DbOpenOneFuzz(dbVal);
+}
+
+void DbCloseFuzz(const uint8_t *data, size_t size)
+{
+    std::string dbFileData(reinterpret_cast<const char *>(data), size);
+    std::string realDbFileData = DB_DIR_PATH + dbFileData;
+    const char *dbFileVal = realDbFileData.data();
+    std::string configStrData(reinterpret_cast<const char *>(data), size);
+    const char *configStrVal = configStrData.data();
+    GRD_DB *dbVal = nullptr;
+    GRD_DBOpen(dbFileVal, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBClose(dbVal, GRD_DB_CLOSE);
+}
+
+void DbCloseResultSetFuzz()
+{
+    GRD_DB *db = nullptr;
+    GRD_DB *db2 = nullptr;
+    GRD_DBOpen(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db);
+    GRD_DBOpen(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db2);
+    GRD_CreateCollection(db, "collection1", "{\"maxdoc\" : 5}", 0);
+
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { "{}", "{}" };
+    GRD_FindDoc(db, "collection1", query, 0, &resultSet);
+
+    GRD_FreeResultSet(resultSet);
+
+    GRD_DBClose(db, GRD_DB_CLOSE);
+
+    GRD_DBClose(db2, GRD_DB_CLOSE);
+}
+
+void CreateCollectionFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollection(nullptr, collectionNameVal, optionStrVal, 0);
+    GRD_CreateCollection(g_db, collectionNameVal, optionStrVal, 0);
+    const char *optionStr = nullptr;
+    GRD_CreateCollection(g_db, COLLECTION_NAME, optionStr, 0);
+    GRD_CreateCollection(g_db, COLLECTION_NAME, "{\"maxdoc\":5, \"unexpected_max_doc\":32}", 0);
+    GRD_CreateCollection(g_db, COLLECTION_NAME, "{}", 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    std::string optStr = "{\"maxdoc\":" + optionStrData + "}";
+    GRD_CreateCollection(g_db, COLLECTION_NAME, optStr.c_str(), 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    GRD_CreateCollection(g_db, COLLECTION_NAME, optStr.c_str(), MAX_SIZE_NUM);
+    optStr = "{\"maxdoc\": 5}";
+    GRD_CreateCollection(g_db, COLLECTION_NAME, optStr.c_str(), 0);
+    GRD_CreateCollection(g_db, COLLECTION_NAME, optStr.c_str(), 1);
+    GRD_DropCollection(g_db, COLLECTION_NAME, 0);
+    GRD_DropCollection(g_db, COLLECTION_NAME, MAX_SIZE_NUM);
+    GRD_DropCollection(g_db, collectionNameVal, 0);
+}
+
+void DropCollectionFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollection(g_db, collectionNameVal, optionStrVal, 0);
+    GRD_DropCollection(nullptr, collectionNameVal, 0);
+    GRD_DropCollection(g_db, collectionNameVal, 0);
+}
+
+void DbFlushFuzz(const uint8_t *data, size_t size)
+{
+    GRD_DB *db = nullptr;
+    GRD_DB *db2 = nullptr;
+    GRD_DBOpen(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db);
+    GRD_Flush(db, 0);
+    GRD_Flush(db, 1);
+    GRD_Flush(db2, 0);
+    GRD_Flush(db2, 1);
+    GRD_DBClose(db, GRD_DB_CLOSE);
+}
+
+void TestGrdDbApGrdGetItem002Fuzz()
+{
+    const char *config = CONFIG_STR;
+    GRD_DB *db = nullptr;
+    GRD_DBOpen(TEST_DB_FILE, config, GRD_DB_OPEN_CREATE, &db);
+    GRD_IndexPreload(nullptr, COLLECTION_NAME);
+    GRD_IndexPreload(nullptr, "invalid_name");
+    GRD_IndexPreload(g_db, COLLECTION_NAME);
+    std::string smallPrefix = std::string(SMALL_PREFIX_LEN, 'a');
+    for (uint32_t i = 0; i < NUM_NINETY_EIGHT; ++i) {
+        std::string v = smallPrefix + std::to_string(i);
+        GRD_KVItemT key = { &i, sizeof(uint32_t) };
+        GRD_KVItemT value = { reinterpret_cast<void *>(v.data()), static_cast<uint32_t>(v.size()) + 1 };
+        GRD_KVPut(g_db, COLLECTION_NAME, &key, &value);
+
+        GRD_KVItemT getValue = { nullptr, 0 };
+        GRD_KVGet(g_db, COLLECTION_NAME, &key, &getValue);
+        GRD_KVFreeItem(&getValue);
+
+        GRD_KVDel(g_db, COLLECTION_NAME, &key);
+    }
+    GRD_Flush(g_db, 1);
+
+    uint32_t begin = 0, end = MAX_SIZE_NUM;
+    GRD_FilterOptionT option = {};
+    option.mode = KV_SCAN_RANGE;
+    option.begin = { &begin, sizeof(uint32_t) };
+    option.end = { &end, sizeof(uint32_t) };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_KVFilter(g_db, COLLECTION_NAME, &option, &resultSet);
+
+    uint32_t keySize, valueSize;
+    GRD_KVGetSize(resultSet, &keySize, &valueSize);
+
+    resultSet = nullptr;
+    uint32_t i = 32;
+    GRD_KVItemT key = { &i, sizeof(uint32_t) };
+    GRD_KVScan(g_db, COLLECTION_NAME, &key, KV_SCAN_EQUAL_OR_LESS_KEY, &resultSet);
+
+    GRD_Prev(resultSet);
+    GRD_Next(resultSet);
+
+    GRD_FreeResultSet(resultSet);
+}
+
+void TestGrdKvBatchCoupling003Fuzz()
+{
+    const char *config = CONFIG_STR;
+    GRD_DB *db = nullptr;
+    GRD_DBOpen(TEST_DB_FILE, config, GRD_DB_OPEN_CREATE, &db);
+
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_KVScan(g_db, COLLECTION_NAME, nullptr, KV_SCAN_PREFIX, &resultSet);
+
+    for (uint32_t i = 0; i < CURSOR_COUNT; i++) {
+        GRD_Next(resultSet);
+    }
+
+    GRD_KVBatchT *batchDel = nullptr;
+    std::vector<std::string> keySet;
+    std::vector<std::string> valueSet;
+    for (uint32_t i = 0; i < VECTOR_SIZE; i++) {
+        std::string key(MAX_SIZE_NUM, 'a');
+        key += std::to_string(i);
+        keySet.emplace_back(key);
+        std::string value = std::to_string(i);
+        valueSet.emplace_back(value);
+    }
+
+    for (int j = 0; j < BATCH_COUNT; j++) {
+        GRD_KVBatchPrepare(BATCH_COUNT, &batchDel);
+        GRD_KVBatchPut(g_db, COLLECTION_NAME, batchDel);
+        for (uint16_t i = 0; i < BATCH_COUNT; i++) {
+            char *batchKey = const_cast<char *>(keySet[CURSOR_COUNT + j * BATCH_COUNT + i].c_str());
+            char *batchValue = const_cast<char *>(valueSet[CURSOR_COUNT + j * BATCH_COUNT + i].c_str());
+            GRD_KVBatchPushback(static_cast<void *>(batchKey),
+                static_cast<uint32_t>(keySet[CURSOR_COUNT + j * BATCH_COUNT + i].length()) + 1,
+                static_cast<void *>(batchValue),
+                static_cast<uint32_t>(valueSet[CURSOR_COUNT + j * BATCH_COUNT + i].length()) + 1,
+                batchDel);
+        }
+
+        GRD_KVBatchDel(g_db, COLLECTION_NAME, batchDel);
+
+        GRD_KVBatchDestroy(batchDel);
+    }
+
+    GRD_Next(resultSet);
+    GRD_KVItemT keyItem = { nullptr, 0 };
+    GRD_KVItemT valueItem = { nullptr, 0 };
+    GRD_Fetch(resultSet, &keyItem, &valueItem);
+    GRD_KVFreeItem(&keyItem);
+    GRD_KVFreeItem(&valueItem);
+    GRD_FreeResultSet(resultSet);
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" {
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::SetUpTestCase();
+
+    OHOS::DbOpenFuzz(data, size);
+    OHOS::CreateCollectionFuzz(data, size);
+    OHOS::DropCollectionFuzz(data, size);
+    OHOS::InsertDocFuzz(data, size);
+    OHOS::FindDocFuzz(data, size);
+    OHOS::UpdateDocFuzz(data, size);
+    OHOS::UpsertDocFuzz(data, size);
+    OHOS::DeleteDocFuzz(data, size);
+    OHOS::NextFuzz(data, size);
+    OHOS::GetValueFuzz(data, size);
+    OHOS::FreeResultSetFuzz();
+    OHOS::TestGrdDbApGrdGetItem002Fuzz();
+    OHOS::TestGrdKvBatchCoupling003Fuzz();
+    OHOS::DbCloseFuzz(data, size);
+    OHOS::DbCloseResultSetFuzz();
+    OHOS::DbFlushFuzz(data, size);
+
+    OHOS::TearDownTestCase();
+    return 0;
+}
+}
diff --git a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.h
similarity index 63%
rename from datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate.cpp
rename to kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.h
index 17737f1e5bee6c5aa9a25d7a689ef2424013f90a..af5feb8c9cef1cfedaea4faa2da7f8a02d0e38e7 100644
--- a/datamgr_service/services/distributeddataservice/adapter/account/src/account_delegate.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/json_fuzzer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -13,16 +13,9 @@
  * limitations under the License.
  */
 
-#include "account_delegate_impl.h"
+#ifndef JSON_FUZZER_H
+#define JSON_FUZZER_H
 
-namespace OHOS {
-namespace DistributedKv {
-AccountDelegate *AccountDelegate::GetInstance()
-{
-    if (getInstance_ == nullptr) {
-        return nullptr;
-    }
-    return getInstance_();
-}
-}  // namespace DistributedKv
-}  // namespace OHOS
+#define FUZZ_PROJECT_NAME "Json_fuzzer"
+
+#endif // JSON_FUZZER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/project.xml b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..73736f01a8820f5deb20590a5655e6fbe62b6aa6
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/json_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>1800</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..d3823c7e39afbae6409eb6aa3de3cb128376a7f8
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/BUILD.gn
@@ -0,0 +1,148 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "kv_store/kv_store"
+
+###############################################################################
+config("module_private_config") {
+  visibility = [ ":*" ]
+
+  include_dirs = [
+    "../../../gaussdb_rd/include",
+    "../../../gaussdb_rd/src/common/include",
+    "../../../gaussdb_rd/src/executor/include",
+    "../../../gaussdb_rd/src/executor/document",
+    "../../../gaussdb_rd/src/oh_adapter/include",
+    "../../../gaussdb_rd/src/oh_adapter/src",
+    "../../../gaussdb_rd/src/interface/include",
+  ]
+
+  defines = [
+    "SQLITE_ENABLE_SNAPSHOT",
+    "SQLITE_HAS_CODEC",
+    "SQLITE_ENABLE_JSON1",
+    "USING_HILOG_LOGGER",
+    "USE_SQLITE_SYMBOLS",
+    "SQLITE_ENABLE_DROPTABLE_CALLBACK",
+  ]
+}
+
+###############################################################################
+ohos_source_set("src_file") {
+  testonly = true
+
+  sources = [
+    "../../../gaussdb_rd/src/common/src/collection_option.cpp",
+    "../../../gaussdb_rd/src/common/src/db_config.cpp",
+    "../../../gaussdb_rd/src/common/src/grd_api_manager.cpp",
+    "../../../gaussdb_rd/src/common/src/json_common.cpp",
+    "../../../gaussdb_rd/src/common/src/os_api.cpp",
+    "../../../gaussdb_rd/src/common/src/rd_log_print.cpp",
+    "../../../gaussdb_rd/src/executor/base/grd_db_api.cpp",
+    "../../../gaussdb_rd/src/executor/base/grd_db_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/document/check_common.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_document_api.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_document_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_resultset_api.cpp",
+    "../../../gaussdb_rd/src/executor/document/grd_resultset_api_inner.cpp",
+    "../../../gaussdb_rd/src/executor/kv/grd_kv_api.cpp",
+    "../../../gaussdb_rd/src/executor/kv/grd_kv_api_inner.cpp",
+    "../../../gaussdb_rd/src/interface/src/collection.cpp",
+    "../../../gaussdb_rd/src/interface/src/doc_errno.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_key.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_store.cpp",
+    "../../../gaussdb_rd/src/interface/src/document_store_manager.cpp",
+    "../../../gaussdb_rd/src/interface/src/projection_tree.cpp",
+    "../../../gaussdb_rd/src/interface/src/result_set.cpp",
+    "../../../gaussdb_rd/src/interface/src/result_set_common.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/kv_store_manager.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/rd_json_object.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/rd_sqlite_utils.cpp",
+    "../../../gaussdb_rd/src/oh_adapter/src/sqlite_store_executor_impl.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = [ "//third_party/sqlite:sqlite" ]
+
+  configs += [ "//third_party/cJSON:cJSON_config" ]
+  ldflags = [ "-Wl,--exclude-libs,ALL" ]
+  deps += [ "//third_party/cJSON:cjson" ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "hitrace:hitrace_meter",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "kv_store"
+}
+
+ohos_fuzztest("JsonInnerFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "../jsoninner_fuzzer"
+
+  if (!defined(deps)) {
+    deps = []
+  }
+  if (!defined(external_deps)) {
+    external_deps = []
+  }
+  configs = [ ":module_private_config" ]
+  deps += [
+    ":src_file",
+    "//third_party/sqlite:sqlite",
+  ]
+  configs += [ "//third_party/cJSON:cJSON_config" ]
+  ldflags = [ "-Wl,--exclude-libs,ALL" ]
+  deps += [
+    "//third_party/cJSON:cjson",
+    "//third_party/openssl:libcrypto_shared",
+  ]
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "hisysevent:libhisysevent",
+    "hitrace:hitrace_meter",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+    "--coverage",
+  ]
+
+  ldflags += [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
+  sources = [ "jsoninner_fuzzer.cpp" ]
+}
+
+###############################################################################
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":JsonInnerFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/corpus/init b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..e7c3fecd8d4d4816e40088113a2316bb9eb2e13f
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec07c6f7afc492112bd9582c523c079d77d9a3c4
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.cpp
@@ -0,0 +1,1697 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "jsoninner_fuzzer.h"
+
+#include <climits>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <cstring>
+#include <dirent.h>
+#include <fcntl.h>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <vector>
+
+#include "grd_base/grd_db_api.h"
+#include "grd_base/grd_error.h"
+#include "grd_base/grd_resultset_api.h"
+#include "grd_document/grd_document_api.h"
+#include "grd_kv/grd_kv_api.h"
+#include "grd_resultset_inner.h"
+
+#include "grd_db_api_inner.h"
+#include "grd_document_api_inner.h"
+#include "grd_kv_api_inner.h"
+#include "grd_resultset_api_inner.h"
+#include "grd_sequence_api_inner.h"
+#include "grd_type_inner.h"
+#include "securec.h"
+
+using namespace DocumentDB;
+
+const char *TEST_DB = "./data";
+const char *TEST_DB_FILE = "./data/testfile";
+const char *COLLECTION_NAME = "collectionname";
+const char *OPTION_STR = "{ \"maxdoc\" : 1000}";
+const char *CONFIG_STR = "{}";
+const char *DB_DIR_PATH = "./data/";
+const char *NO_EXIST_COLLECTION_NAME = "no_exisit";
+const int NUM_THREE = 3;
+const int SMALL_PREFIX_LEN = 5;
+const int NUM_FIFTEEN = 15;
+const int NUM_NINETY_EIGHT = 98;
+const int BATCH_COUNT = 100;
+const int HALF_HALF_BYTES = 256;
+const int MORE_HALF_HALF_BYTES = 257;
+const int LESS_HALF_BYTES = 511;
+const int MORE_HALF_BYTES = 513;
+const int HALF_BYTES = 512;
+const int MAX_LEN_NUM = 600;
+const int LESS_MIDDLE_SIZE = 899;
+const int MIDDLE_SIZE = 900;
+const int MAX_SIZE_NUM = 1000;
+const int ONE_BYTES = 1024;
+const int CURSOR_COUNT = 50000;
+const int VECTOR_SIZE = 100000;
+
+static GRD_DB *g_db = nullptr;
+
+namespace OHOS {
+namespace {
+int RemoveDir(const char *dir)
+{
+    if (dir == nullptr) {
+        return -1;
+    }
+    if (access(dir, F_OK) != 0) {
+        return 0;
+    }
+    struct stat dirStat;
+    if (stat(dir, &dirStat) < 0) {
+        return -1;
+    }
+
+    char dirName[PATH_MAX];
+    DIR *dirPtr = nullptr;
+    struct dirent *dr = nullptr;
+    if (S_ISREG(dirStat.st_mode)) { // normal file
+        remove(dir);
+    } else if (S_ISDIR(dirStat.st_mode)) {
+        dirPtr = opendir(dir);
+        while ((dr = readdir(dirPtr)) != nullptr) {
+            // ignore . and ..
+            if ((strcmp(".", dr->d_name) == 0) || (strcmp("..", dr->d_name) == 0)) {
+                continue;
+            }
+            if (sprintf_s(dirName, sizeof(dirName), "%s / %s", dir, dr->d_name) < 0) {
+                (void)RemoveDir(dirName);
+                closedir(dirPtr);
+                rmdir(dir);
+                return -1;
+            }
+            (void)RemoveDir(dirName);
+        }
+        closedir(dirPtr);
+        rmdir(dir); // remove empty dir
+    } else {
+        return -1;
+    }
+    return 0;
+}
+
+void MakeDir(const char *dir)
+{
+    std::string tmpPath;
+    const char *pcur = dir;
+
+    while (*pcur++ != '\0') {
+        tmpPath.push_back(*(pcur - 1));
+        if ((*pcur == '/' || *pcur == '\0') && access(tmpPath.c_str(), 0) != 0 && !tmpPath.empty()) {
+            if (mkdir(tmpPath.c_str(), (S_IRUSR | S_IWUSR | S_IXUSR)) != 0) {
+                return;
+            }
+        }
+    }
+}
+
+std::string getMaxString()
+{
+    std::string str = "{";
+    for (int i = 0; i <= MAX_SIZE_NUM; i++) {
+        for (int j = 0; j <= MAX_LEN_NUM; j++) {
+            str += "a";
+        }
+    }
+    return str + "}";
+}
+} // namespace
+
+void InsertDocOneFuzz(const std::string documentData)
+{
+    std::string document2 = "{\"_id\":2,\"field\":\"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document2.c_str(), 0);
+    std::string document3 = "{\"_id\":true,\"field\":\"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document3.c_str(), 0);
+    std::string document4 = "{\"_id\" : null, \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document4.c_str(), 0);
+    std::string document5 = "{\"_id\" : [\"2\"], \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document5.c_str(), 0);
+    std::string document6 = "{\"_id\" : {\"val\" : \"2\"}, \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document6.c_str(), 0);
+    std::string document7 = "{\"_id\" : \"3\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document7.c_str(), 0);
+    std::string document9 = "{\"_id\" : \"4\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(NULL, COLLECTION_NAME, document9.c_str(), 0);
+    std::string document10 = "{\"_id\" : \"5\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, NULL, document10.c_str(), 0);
+    std::string document12 = "{\"_id\" : \"6\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document12.c_str(), 1);
+    std::string document13 = "{\"_id\" : \"7\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document13.c_str(), INT_MAX);
+    std::string document14 = "{\"_id\" : \"8\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document14.c_str(), INT_MIN);
+    GRD_InsertDocInner(g_db, NULL, NULL, 0);
+    std::string document15 = "{\"_id\" : \"9\", \"name\" : \"" + documentData + "\"}";
+    std::string collectionName2(HALF_BYTES, 'a');
+    GRD_InsertDocInner(g_db, collectionName2.c_str(), document15.c_str(), 0);
+    const char *collectionName = "collection@!#";
+    std::string document16 = "{\"_id\" : \"10\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, collectionName, document16.c_str(), GRD_OK);
+    std::string collectionName1(MORE_HALF_HALF_BYTES, 'k');
+    std::string document17 = "{\"_id\" : \"10\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, collectionName1.c_str(), document17.c_str(), GRD_OK);
+    std::string document18 = "({\"level1\" : {\"level2\" : {\"level3\" : {\"level4\": {\"level5\" : 1}},\
+        \"level3_2\" : \"" +
+        documentData + "\"}},\"_id\":\"14\"})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document18.c_str(), 0);
+    std::string document19 = "({\"level1\" : {\"level2\" : {\"level3\" : [{ \"level5\" : \"" + documentData + "\",\
+        \"level5_2\":\"" +
+        documentData + "\"}, \"" + documentData + "\",\"" + documentData + "\"], \"level3_2\":\
+        \"" +
+        documentData + "\"}}, \"_id\":\"14\"})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document19.c_str(), 0);
+    std::string document20 = "({\"level1\" : {\"level2\" : {\"level3\" : { \"level4\" : \"" + documentData + "\"},\
+        \"level3_2\" : \"" +
+        documentData + "\"}}, \"_id\":\"14\"})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document20.c_str(), 0);
+}
+
+void InsertDocTwoFuzz(const std::string documentData)
+{
+    std::string documentPart1 = "{ \"_id\" : \"15\", \"textVal\" : \" ";
+    std::string documentPart2 = "\" }";
+    std::string jsonVal = std::string(HALF_BYTES * ONE_BYTES - documentPart1.size() - documentPart2.size(), 'k');
+    std::string document = documentPart1 + jsonVal + documentPart2;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document.c_str(), 0);
+    std::string jsonVal2 = std::string(HALF_BYTES * ONE_BYTES - 1 - documentPart1.size() - documentPart2.size(), 'k');
+    std::string document21 = documentPart1 + jsonVal2 + documentPart2;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document21.c_str(), 0);
+    std::string document22 = "{\"_id\" : \"16\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document22.c_str(), 0);
+    std::string document23 =
+        "{\"_id\" : \"17\", \"level1\" : {\"level2\" : {\"level3\" : {\"level4\" : " + documentData + "\
+        } } }, \"level1_2\" : \"" +
+        documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document23.c_str(), 0);
+    std::string document24 = documentData;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document24.c_str(), 0);
+    std::string document25 = "{\"name\" : \"" + documentData + "\", \"age\" : " + documentData + ",\
+                            \"friend\" : {\"name\" : \" " +
+        documentData + "\"}, \"_id\" : \"19\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document25.c_str(), 0);
+    std::string collectionName3 = std::string(HALF_HALF_BYTES, 'k');
+    std::string document26 = "{\"_id\" : \"22\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, collectionName3.c_str(), document26.c_str(), GRD_OK);
+    std::string collectionName4 = "Aads_sd__23Asb_";
+    std::string document27 = "{\"_id\" : \"23\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, collectionName4.c_str(), document27.c_str(), GRD_OK);
+    std::string collectionName5 = "GRD_collectionName";
+    std::string document28 = "{\"_id\" : \"24\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document28.c_str(), 0);
+    collectionName5 = "GM_SYS__collectionName";
+    std::string document29 = "{\"_id\" : \"24_2\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document29.c_str(), 0);
+
+    collectionName5 = "grd_collectionName";
+    std::string document30 = "{\"_id\" : \"24_3\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document30.c_str(), 0);
+}
+
+void InsertDocThreeFuzz(const std::string documentData)
+{
+    std::string collectionName5 = "gm_sys_collectionName";
+    std::string document31 = "{\"_id\" : \"24_4\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document31.c_str(), 0);
+
+    collectionName5 = "gM_sYs_collectionName";
+    std::string document32 = "{\"_id\" : \"24_5\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document32.c_str(), 0);
+
+    collectionName5 = "gRd_collectionName";
+    std::string document33 = "{\"_id\" : \"24_6\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document33.c_str(), 0);
+
+    collectionName5 = "gRd@collectionName";
+    std::string document34 = "{\"_id\" : \"24_7\", \"name\" : \"" + documentData + "\"}";
+    GRD_CreateCollectionInner(g_db, collectionName5.c_str(), "", 0);
+    GRD_InsertDocInner(g_db, collectionName5.c_str(), document34.c_str(), 0);
+
+    std::string document35 = "{\"_id\" : \"25_0\", \"level1\" : {\"level2\" : {\"level3\" :\
+        {\"level4\" : \"" +
+        documentData + "\"}}} , \"level1_2\" : \"" + documentData + "\" }";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document35.c_str(), 0);
+
+    std::string document36 = "{\"_id\" : \"25_1\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        { \"newName1\" : [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\"] }]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document36.c_str(), 0);
+
+    std::string document37 = "{\"_id\" : \"25_2\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\", {\"0ab\" : null}]]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document37.c_str(), 0);
+
+    std::string document38 = "{\"_id\" : \"25_3\", \"class_name\" : \"" + documentData +
+        "\", \"signed_info\" : true, \
+        \"student_info\" : [{\"name\":\"" +
+        documentData + "\", \"age\" : " + documentData + ", \"sex\" : \"male\"}, \
+        { \"newName1\" : [\"" +
+        documentData + "\", \"" + documentData + "\", 0, \"" + documentData + "\", {\"level5\" : 1}] }]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document38.c_str(), 0);
+}
+
+void InsertDocFourFuzz(const std::string longId, const std::string documentData)
+{
+    std::string document39 =
+        "{\"_id\" : \"35\", \"A_aBdk_324_\" : \"" + documentData + "\", \"name\" : \"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document39.c_str(), 0);
+
+    std::string document40 = "{\"_id\" : \"35_2\", \"1A_aBdk_324_\" : \"" + documentData +
+        "\", "
+        "\"name\" : \"" +
+        documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document40.c_str(), 0);
+    std::string document41 = "{\"_id\" : \"36_0\", \"stringType\" : \"" + documentData +
+        "\", \"numType\" : " + documentData + ", \"BoolType\" : true,\
+                          \"nullType\" : null, \"arrayType\" : " +
+        documentData + ", \"objectType\" : {\"A\" : 3}}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document41.c_str(), 0);
+
+    std::string document42 = "({\"_id\" : \"38_0\", \"field2\" : 1.797693" + longId + "13486232e308})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document42.c_str(), 0);
+    std::string document43 = "({\"_id\" : \"38_1\", \"t1\" : {\"field2\" : 1.797" + longId + "69313486232e308}})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document43.c_str(), 0);
+    std::string document44 = "({\"_id\" : \"38_2\", \"t1\" : [1, 2, 1.79769313486" + longId + "232e308]})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document44.c_str(), 0);
+    std::string document45 = "({\"_id\" : \"38_3\", \"t1\" : [1, 2, -1.7976931348623167" + longId + "E+308]})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document45.c_str(), 0);
+    std::string document46 = "({\"_id\" : \"38_4\", \"t1\" : [1, 2, -1." + longId + "79769313486231570E+308]})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document46.c_str(), 0);
+    std::string document47 = "({\"_id\" : \"38_5\", \"t1\" : [1, 2, 1.79769313486" + longId + "231570E+308]})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document47.c_str(), 0);
+
+    std::string doc1 = "{\"_id\" : ";
+    std::string doc2 = "\"";
+    std::string doc4 = "\"";
+    std::string doc5 = ", \"name\" : \"" + documentData + "\"}";
+    std::string documentMiddle(MIDDLE_SIZE, 'k');
+    std::string document48 = doc1 + doc2 + documentMiddle + doc4 + doc5;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document48.c_str(), 0);
+    std::string documentMiddle2(MAX_SIZE_NUM, 'k');
+    document48 = doc1 + doc2 + documentMiddle2 + doc4 + doc5;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document48.c_str(), 0);
+
+    std::string document49 = "({\"_id\":\"0123\", \"num\":\"" + documentData + "\"})";
+    std::string document50 = "({\"_id\":\"0123\", \"NUM\":\"" + documentData + "\"})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document49.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document50.c_str(), 0);
+
+    std::string document51 = "({\"_id\":\"0123\", \"num.\":\"" + documentData + "\"})";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document51.c_str(), 0);
+
+    const char *document52 = R""({})"";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document52, 0);
+}
+
+void InsertDocFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollectionInner(g_db, collectionNameVal, optionStrVal, 0);
+    std::string documentData(reinterpret_cast<const char *>(data), size);
+    const char *documentVal = documentData.data();
+    GRD_InsertDocInner(g_db, collectionNameVal, documentVal, 0);
+    GRD_InsertDocInner(g_db, collectionNameVal, documentVal, 0);
+    std::string stringJson = "{" + documentData + "}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson.c_str(), 0);
+    std::string stringJson2 = "{\"_id\":\"1\",\"field\":\"" + documentData + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    std::string longId = "1";
+    for (int i = 0; i < MAX_SIZE_NUM; i++) {
+        longId += "1";
+    }
+    longId = "{\"_id\":\"" + longId + "\",\"field\":\"field_id\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, longId.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":123}", 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, "{\"field1.field2.field&*^&3\":\"anc\"}", 0);
+    InsertDocOneFuzz(documentData);
+    InsertDocTwoFuzz(documentData);
+    InsertDocThreeFuzz(documentData);
+    InsertDocFourFuzz(longId, documentData);
+
+    const char *document53 = R""({"empty" : null})"";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document53, 0);
+    GRD_DropCollectionInner(g_db, collectionNameVal, 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+
+    std::string documentNew1 = "{\"_id\" : ";
+    std::string documentNew2 = "\"";
+    std::string documentNew3 = "\"";
+    std::string documentNew4 = ", \"name\" : \"Ori\"}";
+    std::string document = documentNew1 + documentNew2 + documentData + documentNew3 + documentNew4;
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document.c_str(), 0);
+}
+
+static const char *DOCUMENT1 = "{\"_id\" : \"1\", \"name\":\"doc1\",\"item\":\"journal\",\"personInfo\":\
+    {\"school\":\"AB\", \"age\" : 51}}";
+static const char *DOCUMENT2 = "{\"_id\" : \"2\", \"name\":\"doc2\",\"item\": 1, \"personInfo\":\
+    [1, \"my string\", {\"school\":\"AB\", \"age\" : 51}, true, {\"school\":\"CD\", \"age\" : 15}, false]}";
+static const char *DOCUMENT3 = "{\"_id\" : \"3\", \"name\":\"doc3\",\"item\":\"notebook\",\"personInfo\":\
+    [{\"school\":\"C\", \"age\" : 5}]}";
+static const char *DOCUMENT4 = "{\"_id\" : \"4\", \"name\":\"doc4\",\"item\":\"paper\",\"personInfo\":\
+    {\"grade\" : 1, \"school\":\"A\", \"age\" : 18}}";
+static const char *DOCUMENT5 = "{\"_id\" : \"5\", \"name\":\"doc5\",\"item\":\"journal\",\"personInfo\":\
+    [{\"sex\" : \"woma\", \"school\" : \"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT6 = "{\"_id\" : \"6\", \"name\":\"doc6\",\"item\":false,\"personInfo\":\
+    [{\"school\":\"B\", \"teacher\" : \"mike\", \"age\" : 15},\
+    {\"school\":\"C\", \"teacher\" : \"moon\", \"age\" : 20}]}";
+
+static const char *DOCUMENT7 = "{\"_id\" : \"7\", \"name\":\"doc7\",\"item\":\"fruit\",\"other_Info\":\
+    [{\"school\":\"BX\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT8 = "{\"_id\" : \"8\", \"name\":\"doc8\",\"item\":true,\"personInfo\":\
+    [{\"school\":\"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 35}]}";
+static const char *DOCUMENT9 = "{\"_id\" : \"9\", \"name\":\"doc9\",\"item\": true}";
+static const char *DOCUMENT10 = "{\"_id\" : \"10\", \"name\":\"doc10\", \"parent\" : \"kate\"}";
+static const char *DOCUMENT11 = "{\"_id\" : \"11\", \"name\":\"doc11\", \"other\" : \"null\"}";
+static const char *DOCUMENT12 = "{\"_id\" : \"12\", \"name\":\"doc12\",\"other\" : null}";
+static const char *DOCUMENT13 = "{\"_id\" : \"13\", \"name\":\"doc13\",\"item\" : \"shoes\",\"personInfo\":\
+    {\"school\":\"AB\", \"age\" : 15}}";
+static const char *DOCUMENT14 = "{\"_id\" : \"14\", \"name\":\"doc14\",\"item\" : true,\"personInfo\":\
+    [{\"school\":\"B\", \"age\" : 15}, {\"school\":\"C\", \"age\" : 85}]}";
+static const char *DOCUMENT15 = "{\"_id\" : \"15\", \"name\":\"doc15\",\"personInfo\":[{\"school\":\"C\", \"age\" : "
+                                  "5}]}";
+static const char *DOCUMENT16 = "{\"_id\" : \"16\", \"name\":\"doc16\", \"nested1\":{\"nested2\":{\"nested3\":\
+    {\"nested4\":\"ABC\", \"field2\":\"CCC\"}}}}";
+static const char *DOCUMENT17 = "{\"_id\" : \"17\", \"name\":\"doc17\",\"personInfo\":\"oh,ok\"}";
+static const char *DOCUMENT18 = "{\"_id\" : \"18\", \"name\":\"doc18\",\"item\" : \"mobile phone\",\"personInfo\":\
+    {\"school\":\"DD\", \"age\":66}, \"color\":\"blue\"}";
+static const char *DOCUMENT19 = "{\"_id\" : \"19\", \"name\":\"doc19\",\"ITEM\" : true,\"PERSONINFO\":\
+    {\"school\":\"AB\", \"age\":15}}";
+static const char *DOCUMENT20 = "{\"_id\" : \"20\", \"name\":\"doc20\",\"ITEM\" : true,\"personInfo\":\
+    [{\"SCHOOL\":\"B\", \"AGE\":15}, {\"SCHOOL\":\"C\", \"AGE\":35}]}";
+static const char *DOCUMENT23 = "{\"_id\" : \"23\", \"name\":\"doc22\",\"ITEM\" : "
+                                  "true,\"personInfo\":[{\"school\":\"b\", \"age\":15}, [{\"school\":\"doc23\"}, 10, "
+                                  "{\"school\":\"doc23\"}, true, {\"school\":\"y\"}], {\"school\":\"b\"}]}";
+static std::vector<const char *> g_data = { DOCUMENT1, DOCUMENT2, DOCUMENT3, DOCUMENT4, DOCUMENT5,
+    DOCUMENT6, DOCUMENT7, DOCUMENT8, DOCUMENT9, DOCUMENT10, DOCUMENT11, DOCUMENT12, DOCUMENT13,
+    DOCUMENT14, DOCUMENT15, DOCUMENT16, DOCUMENT17, DOCUMENT18, DOCUMENT19, DOCUMENT20, DOCUMENT23 };
+
+namespace {
+static void InsertData(GRD_DB *g_db, const char *collectionName)
+{
+    for (const auto &item : g_data) {
+        GRD_InsertDocInner(g_db, collectionName, item, 0);
+    }
+}
+
+void SetUpTestCase()
+{
+    (void)RemoveDir(TEST_DB);
+    MakeDir(TEST_DB);
+    GRD_DBOpenInner(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &g_db);
+    InsertData(g_db, COLLECTION_NAME);
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+}
+
+void TearDownTestCase()
+{
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    GRD_DBCloseInner(g_db, GRD_DB_CLOSE);
+    (void)RemoveDir(TEST_DB);
+    g_db = nullptr;
+}
+
+void FindDocResultSetFuzz(const char *collName, const std::string filter, const std::string projectionInfo)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, collName, query, 1, &resultSet);
+    if (resultSet != nullptr) {
+        GRD_NextInner(resultSet);
+        char *valueResultSet = nullptr;
+        GRD_GetValueInner(resultSet, &valueResultSet);
+    }
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocWithFlagFuzz(const std::string filter, const std::string projectionInfo, int flag)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocNextTwiceFuzz(const std::string filter, const std::string projectionInfo)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocZeroFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : \"6\", \"name\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"name\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : \"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : 1}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : [\"" + input + "\", 1]}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : {\"" + input + "\" : \"1\"}}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    filter = "{\"_id\" : null}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+
+    const char *collName1 = "grd_type";
+    const char *collName2 = "GM_SYS_sysfff";
+    filter = "{\"_id\" : \"1\"}";
+    FindDocResultSetFuzz(collName1, filter, R"({})");
+    FindDocResultSetFuzz(collName2, filter, R"({})");
+
+    filter = "{\"_id\" : \"100\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+}
+
+void FindDocOneFuzz()
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_ResultSet *resultSet2 = nullptr;
+    Query query = { filter.c_str(), "{}" };
+    const char *collectionName = "DocumentDBFindTest024";
+    GRD_CreateCollectionInner(g_db, collectionName, "", 0);
+    InsertData(g_db, collectionName);
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FindDocInner(g_db, collectionName, query, 1, &resultSet2);
+
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+
+    GRD_NextInner(resultSet2);
+    char *value2 = nullptr;
+    GRD_GetValueInner(resultSet2, &value2);
+    GRD_FreeValueInner(value2);
+
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet2);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_GetValueInner(resultSet2, &value);
+    GRD_FreeResultSetInner(resultSet);
+    GRD_FreeResultSetInner(resultSet2);
+    GRD_DropCollectionInner(g_db, collectionName, 0);
+
+    filter = "{\"_id\" : \"16\"}";
+    resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": true, \"nested1.nested2.nested3.nested4\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeResultSetInner(resultSet);
+
+    projectionInfo = "{\"name\": true, \"nested1\":{\"nested2\":{\"nested3\":{\"nested4\":true}}}}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocTwoFuzz(const std::string &input)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": 0, \"nested1.nested2.nested3.nested4\":0}";
+    std::string filter = "{\"_id\" : \"16\"}";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+
+    projectionInfo = "{\"name\": \"" + input + "\", \"nested1.nested2.nested3.nested4\":\"" + input + "\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+
+    filter = "{\"_id\" : \"7\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"name\": true, \"other_Info\":true, \"non_exist_field\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+
+    projectionInfo = "{\"name\": true, \"other_Info\":true, \" item \":true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+}
+
+void FindDocThreeFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"7\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = "{\"name\": true, \"other_Info.non_exist_field\":true}";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+    projectionInfo = "{\"name\": true, \"other_Info\":{\"non_exist_field\":true}}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+    projectionInfo = "{\"name\": true, \"other_Info.0\": true}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+    filter = "{\"_id\" : \"4\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"personInfo\": true, \"personInfo.grade\": true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"non_exist_field\":true}";
+    int flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"name\":true, \"item\":true}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    projectionInfo = "{\"name\": " + input + ", \"item\": " + input + "}";
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"7\"}";
+    projectionInfo = "{\"name\":false, \"item\":false}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    flag = 1;
+    projectionInfo = "{\"name\": " + input + ", \"item\": " + input + "}";
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    filter = "{\"_id\" : \"4\"}";
+    projectionInfo = "{\"name\": " + input + ", \"personInfo.grade1\": " + input + ", \
+            \"personInfo.shool1\": " +
+        input + ", \"personInfo.age1\": " + input + "}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+    projectionInfo = "{\"name\": false, \"personInfo.grade1\": false, \
+            \"personInfo.shool1\": false, \"personInfo.age1\": false}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+}
+
+void FindDocFourFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"4\"}";
+    std::string projectionInfo =
+        "{\"name\": " + input + ", \"personInfo.school\": " + input + ", \"personInfo.age\": " + input + "}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, projectionInfo);
+
+    filter = "{\"_id\" : \"17\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter.c_str(), "{}" };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, GRD_DOC_ID_DISPLAY, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeResultSetInner(resultSet);
+
+    resultSet = nullptr;
+    query = { filter.c_str(), "{}" };
+    GRD_FindDocInner(g_db, "", query, 0, &resultSet);
+    GRD_FindDocInner(g_db, nullptr, query, 0, &resultSet);
+
+    filter = "{\"_id\" : \"4\"}";
+    resultSet = nullptr;
+    projectionInfo = "{\"name\":" + input + ", \"personInfo\":0, \"item\":" + input + "}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":true, \"personInfo\":0, \"item\":true}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":\"\", \"personInfo\":0, \"item\":\"\"}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":1, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":-1.123, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    projectionInfo = "{\"name\":false, \"personInfo\":true, \"item\":false";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+}
+
+void FindDocFiveFuzz(const std::string &input)
+{
+    std::string filter = "{\"_id\" : \"6\"}";
+    std::string projectionInfo = "{\"name\":false, \"personInfo\": 0, \"item\":0}";
+    int flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+
+    filter = "{\"_id\" : \"18\"}";
+    projectionInfo = "{\"name\":true, \"personInfo.age\": \"\", \"item\":1, \"color\":10, \"nonExist\" : "
+                     "-100}";
+    flag = 0;
+    FindDocWithFlagFuzz(filter, projectionInfo, flag);
+
+    GRD_ResultSet *resultSet = nullptr;
+    projectionInfo = "{\"personInfo\":[true, " + input + "]}";
+    flag = 1;
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    projectionInfo = "{\"personInfo\":null}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    resultSet = nullptr;
+    projectionInfo = "{\"Name\":true, \"personInfo.age\": \"\", \"item\":" + input + ", \"COLOR\":" + input +
+        ", \"nonExist\" : "
+        "" +
+        input + "}";
+    flag = 0;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, flag, &resultSet);
+    GRD_NextInner(resultSet);
+    GRD_FreeResultSetInner(resultSet);
+
+    resultSet = nullptr;
+    projectionInfo = "{\"Name\":" + input + ", \"personInfo.age\": false, \"personInfo.SCHOOL\": false, \"item\":\
+        false, \"COLOR\":false, \"nonExist\" : false}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    char *value = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_NextInner(resultSet);
+    GRD_FreeResultSetInner(resultSet);
+
+    filter = "{\"_id\" : \"18\"}";
+    resultSet = nullptr;
+    query = { filter.c_str(), "{}" };
+    std::string collectionName1(LESS_HALF_BYTES, 'a');
+    GRD_FindDocInner(g_db, collectionName1.c_str(), query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocSixFuzz(const std::string &input)
+{
+    std::string collectionName2(HALF_BYTES, 'a');
+    std::string filter = "{\"_id\" : \"18\"}";
+    Query query = { filter.c_str(), "{}" };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDocInner(g_db, collectionName2.c_str(), query, 1, &resultSet);
+    GRD_FindDocInner(g_db, "", query, 1, &resultSet);
+
+    resultSet = nullptr;
+    std::string projectionInfo = "{}";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, NUM_THREE, &resultSet);
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, INT_MAX, &resultSet);
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, INT_MIN, &resultSet);
+    GRD_FindDocInner(nullptr, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, nullptr);
+    query = { nullptr, nullptr };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+
+    std::string document1 = "{\"_id\" : ";
+    std::string document2 = "\"";
+    std::string document4 = "\"";
+    std::string document5 = "}";
+    std::string documentMiddle(MIDDLE_SIZE, 'k');
+    filter = document1 + document2 + documentMiddle + document4 + document5;
+    resultSet = nullptr;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    std::string documentMiddle2(LESS_MIDDLE_SIZE, 'k');
+    filter = document1 + document2 + documentMiddle2 + document4 + document5;
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+
+    filter = "{\"personInfo\" : {\"school\":\"" + input + "\"}}";
+    FindDocNextTwiceFuzz(filter, R"({})");
+
+    projectionInfo = "{\"version\": " + input + "}";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    projectionInfo = "({\"a00001\":" + input + ", \"a00001\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    projectionInfo = "({\"abc123_.\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+
+    filter = "({\"abc123_.\":" + input + "})";
+    FindDocNextTwiceFuzz(filter, projectionInfo);
+}
+
+void FindDocSevenFuzz(const std::string &input)
+{
+    std::string document064 = "{\"_id\" : \"64\", \"a\":" + input + ", \"doc64\" : " + input + "}";
+    std::string document063 = "{\"_id\" : \"63\", \"a\":" + input + ", \"doc63\" : " + input + "}";
+    std::string document062 = "{\"_id\" : \"62\", \"a\":" + input + ", \"doc62\" : " + input + "}";
+    std::string document061 = "{\"_id\" : \"61\", \"a\":" + input + ", \"doc61\" : " + input + "}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document064.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document063.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document062.c_str(), 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document061.c_str(), 0);
+    std::string filter = "{\"a\":" + input + "}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = R"({})";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void FindDocFuzzPlus(const std::string &input)
+{
+    FindDocZeroFuzz(input);
+    std::string filter = "{\"_id\" : \"6\"}";
+    FindDocResultSetFuzz(COLLECTION_NAME, filter, R"({})");
+    FindDocOneFuzz();
+    FindDocTwoFuzz(input);
+    FindDocThreeFuzz(input);
+    FindDocFourFuzz(input);
+    FindDocFiveFuzz(input);
+    FindDocSixFuzz(input);
+    FindDocSevenFuzz(input);
+
+    std::string document = "{\"a\":" + input + ", \"doc64\" : " + input + "}";
+    filter = "{\"b\":" + input + "}";
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, filter.c_str(), document.c_str(), 0);
+    filter = "{\"a\":" + input + "}";
+    GRD_ResultSet *resultSet = nullptr;
+    std::string projectionInfo = R"({})";
+    Query query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_NextInner(resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    filter = "{\"a\":" + input + "}";
+    resultSet = nullptr;
+    projectionInfo = R"({})";
+    query = { filter.c_str(), projectionInfo.c_str() };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    GRD_NextInner(resultSet);
+    char *valueNew = nullptr;
+    GRD_GetValueInner(resultSet, &valueNew);
+    GRD_FreeValueInner(valueNew);
+    GRD_FreeResultSetInner(resultSet);
+    filter = "{\"personInfo\" : {\"school\":" + input + "}" + "}";
+    FindDocNextTwiceFuzz(filter, R"({})");
+}
+} // namespace
+
+void FindDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"field\":\"" + input + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    Query query = { inputJson.c_str(), inputJson.c_str() };
+    GRD_ResultSet *resultSet = nullptr;
+    // ResultSet conflict
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, input.c_str(), query, size, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    GRD_FindDocInner(nullptr, input.c_str(), query, 1, &resultSet);
+    query.filter = nullptr;
+    GRD_FindDocInner(g_db, input.c_str(), query, 1, &resultSet);
+    inputJson = "{\"field\": 0, \"field2\":" + input + "}";
+    query.filter = "{}";
+    query.projection = inputJson.c_str();
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    inputJson = "{\"" + input + "\": 0}";
+    query.projection = inputJson.c_str();
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    inputJson = "{\"field\":[\"aaa\"," + input + "]}";
+    resultSet = nullptr;
+    query.projection = inputJson.c_str();
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    query.filter = "{\"field\": false}";
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_FreeResultSetInner(resultSet);
+    FindDocFuzzPlus(input);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+}
+
+void UpdateDocOneFuzz(std::string s, const std::string input)
+{
+    std::string inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc6\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc7\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc8\"}", inputJson.c_str(), 1);
+
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, input.c_str(), "{}", 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{}", input.c_str(), 0);
+    GRD_UpdateDocInner(nullptr, COLLECTION_NAME, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc6\"}", "{\"c0.c1\":false}", 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc7\"}", "{\"c0.c1\":null}", 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"name\":\"doc8\"}", "{\"c0.0\":\"ac\"}", 1);
+}
+
+void UpdateDocTwoFuzz(const char *newCollName, std::string s, const std::string input)
+{
+    std::string inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc6\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc7\"}", inputJson.c_str(), 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc8\"}", inputJson.c_str(), 1);
+
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDocInner(g_db, newCollName, input.c_str(), "{}", 0);
+    GRD_UpdateDocInner(g_db, newCollName, "{}", input.c_str(), 0);
+    GRD_UpdateDocInner(nullptr, newCollName, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    inputJson = "{\"field5\": \"" + s + "\"}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field5\": \"" + s + s + "\"}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": [\"field2\", {\"field3\":\"" + input + "\"}]}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"name\":\"doc6\", \"c0\" : {\"c1\" : true } }";
+    GRD_InsertDocInner(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc6\"}", "{\"c0.c1\":false}", 1);
+    inputJson = "{\"name\":\"doc7\", \"c0\" : {\"c1\" : null } }";
+    GRD_InsertDocInner(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc7\"}", "{\"c0.c1\":null}", 1);
+    inputJson = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    GRD_InsertDocInner(g_db, newCollName, inputJson.c_str(), 0);
+    GRD_UpdateDocInner(g_db, newCollName, "{\"name\":\"doc8\"}", "{\"c0.0\":\"ac\"}", 1);
+}
+
+void UpdateDocFilterFuzz()
+{
+    const char *filter = "{\"_id\" : \"1\"}";
+    const char *updata2 = "{\"objectInfo.child.child\" : {\"child\":{\"child\":null}}}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter, updata2, 0);
+
+    const char *filter1 = "{\"_id\" : \"1\"}";
+    const char *updata1 = "{\"_id\" : \"6\"}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter1, updata1, 0);
+
+    const char *filter2 = "{\"_id\" : \"1\"}";
+    const char *updata3 = "{\"age$\" : \"21\"}";
+    const char *updata4 = "{\"bonus..traffic\" : 100}";
+    const char *updata5 = "{\"0item\" : 100}";
+    const char *updata6 = "{\"item\" : 1.79769313486232e308}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter2, updata3, 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter2, updata4, 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter2, updata5, 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter2, updata6, 0);
+
+    const char *filter3 = "{\"_id\" : \"1\"}";
+    const char *updata7 = "{\"age\" : 21}";
+    GRD_UpdateDocInner(g_db, NULL, filter3, updata7, 0);
+    GRD_UpdateDocInner(g_db, "", filter3, updata7, 0);
+    GRD_UpdateDocInner(NULL, COLLECTION_NAME, filter3, updata7, 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, NULL, updata7, 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, filter3, NULL, 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+}
+
+void UpdateDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"_id\":\"2\", \"field\": \"aaa\", "
+                            "\"subject\":\"aaaaaaaaaaa\", \"test1\": true, "
+                            "\"test2\": null}";
+
+    GRD_UpdateDocInner(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, input.c_str(), "{}", 0);
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{}", input.c_str(), 0);
+    GRD_UpdateDocInner(nullptr, COLLECTION_NAME, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    std::string s;
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+    UpdateDocOneFuzz(s, input);
+
+    const char *newCollName = "./student";
+    GRD_UpdateDocInner(g_db, inputJson.c_str(), "{}", "{}", 0);
+    GRD_UpdateDocInner(g_db, newCollName, input.c_str(), "{}", 0);
+    GRD_UpdateDocInner(g_db, newCollName, "{}", input.c_str(), 0);
+    GRD_UpdateDocInner(nullptr, newCollName, "{}", "{}", 0);
+    inputJson = "{\"_id\":\"2\", \"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1.field2.field3.field4.field5.field6\":" + input + "}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field1\": {\"field2\": {\"field3\": {\"field4\": {\"field5\":" + input + "}}}}}";
+    GRD_UpdateDocInner(g_db, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    s.clear();
+    for (int i = 0; i < ((ONE_BYTES * ONE_BYTES) - 1) - NUM_FIFTEEN; i++) {
+        s += 'a';
+    }
+
+    UpdateDocTwoFuzz(newCollName, s, input);
+    UpdateDocFilterFuzz();
+}
+
+void UpsertDocNewFuzz(const std::string input, GRD_DB *db1)
+{
+    GRD_CreateCollectionInner(g_db, "student", "", 0);
+    std::string documentNew =
+        "{\"name\": {\"first\":[\"XXX\", \"BBB\", \"CCC\"], \"last\":\"moray\", \"field\":" + input + "}";
+    std::string updateDocNew = R""({"name.last.AA.B":"Mnado"})"";
+    GRD_UpsertDocInner(g_db, "student", R""({"_id":"10001"})"", documentNew.c_str(), 0);
+    GRD_UpsertDocInner(db1, "student", R""({"_id":"10001"})"", updateDocNew.c_str(), 1);
+    GRD_DropCollectionInner(g_db, "student", 0);
+
+    GRD_CreateCollectionInner(g_db, "student", "", 0);
+    documentNew = "{\"name\":[\"Tmn\", \"BB\", \"Alice\"], \"field\":" + input + "}";
+    updateDocNew = R""({"name.first":"GG"})"";
+    GRD_UpsertDocInner(g_db, "student", R""({"_id":"10002"})"", documentNew.c_str(), 0);
+    GRD_UpsertDocInner(db1, "student", R""({"_id":"10002"})"", updateDocNew.c_str(), 1);
+}
+
+void UpsertDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJsonNoId = "{\"name\":\"doc8\", \"c0\" : [\"" + input + "\", 123]}";
+    std::string inputJson = "{\"_id\":\"1\", \"field\": " + input + "}";
+
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_UpsertDocInner(g_db, input.c_str(), "{}", "{}", 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), "{}", 0);
+    inputJson = "{\"_id\":\"1\", \"field\":" + input + "}";
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"1\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(nullptr, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, nullptr, inputJson.c_str(), 1);
+    GRD_UpsertDocInner(g_db, COLLECTION_NAME, "{\"_id\":\"2\"}", inputJson.c_str(), BATCH_COUNT);
+
+    const char *newCollName = "./student";
+    GRD_DB *db1 = nullptr;
+    GRD_CreateCollectionInner(db1, newCollName, "", 0);
+    GRD_InsertDocInner(db1, newCollName, inputJson.c_str(), 0);
+    GRD_UpsertDocInner(db1, input.c_str(), "{}", "{}", 0);
+    GRD_UpsertDocInner(db1, newCollName, inputJson.c_str(), "{}", 0);
+    inputJson = "{\"_id\":\"1\", \"field\":" + input + "}";
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    inputJson = "{\"field\":" + input + "}";
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 0);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 0);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"1\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"newID1999\"}", inputJsonNoId.c_str(), 0);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"newID1999a\"}", inputJsonNoId.c_str(), 1);
+    GRD_UpsertDocInner(nullptr, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), 1);
+    GRD_UpsertDocInner(db1, newCollName, nullptr, inputJson.c_str(), 1);
+    GRD_UpsertDocInner(db1, newCollName, "{\"_id\":\"2\"}", inputJson.c_str(), BATCH_COUNT);
+    GRD_DropCollectionInner(db1, newCollName, 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+
+    UpsertDocNewFuzz(input, db1);
+}
+
+void DeleteDocResultFuzz(const std::string input)
+{
+    const char *filter = "{\"age\" : 15}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter, 0);
+    const char *filter1 = "{\"_id\" : \"1\", \"age\" : 15}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter1, 0);
+    std::string filter2 = "{\"_id\" : \"1\", \"name\" : " + input + "}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter2.c_str(), 1);
+    GRD_DeleteDocInner(g_db, NULL, filter2.c_str(), 0);
+    GRD_DeleteDocInner(g_db, "", filter2.c_str(), 1);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter2.c_str(), 0);
+
+    const char *filter3 = "{\"_id\" : \"1\"}";
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { filter3, "{}" };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter3, 0);
+
+    const char *filter4 = "{\"_id\" : \"1\"}";
+    std::string collectionName1(LESS_HALF_BYTES, 'a');
+    GRD_CreateCollectionInner(g_db, collectionName1.c_str(), "", 0);
+    GRD_DeleteDocInner(g_db, collectionName1.c_str(), filter4, 0);
+    GRD_DropCollectionInner(g_db, collectionName1.c_str(), 0);
+    GRD_FreeResultSetInner(resultSet);
+
+    GRD_DeleteDocInner(NULL, COLLECTION_NAME, filter2.c_str(), 0);
+    GRD_DeleteDocInner(g_db, NULL, filter2.c_str(), 0);
+    GRD_DeleteDocInner(g_db, "", filter2.c_str(), 0);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, NULL, 0);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, "", 0);
+    GRD_DeleteDocInner(g_db, "notExisted", filter2.c_str(), 0);
+
+    std::vector<std::string> filterVec = { R"({"_id" : 1})", R"({"_id":[1, 2]})", R"({"_id" : {"t1" : 1}})",
+        R"({"_id":null})", R"({"_id":true})", R"({"_id" : 1.333})", R"({"_id" : -2.0})" };
+    for (const auto &item : filterVec) {
+        GRD_DeleteDocInner(g_db, COLLECTION_NAME, item.c_str(), 0);
+    }
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter2.c_str(), 0);
+
+    std::string filter5 = "{\"subject.info\" : \"" + input + "\"}";
+    resultSet = nullptr;
+    query = { filter2.c_str(), "{}" };
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, filter5.c_str(), 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void DeleteDocFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{\"field\":" + input + "}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    GRD_DeleteDocInner(g_db, input.c_str(), "{}", 0);
+    GRD_DeleteDocInner(g_db, nullptr, "{}", 0);
+    std::string longName = "";
+    for (int i = 0; i < MORE_HALF_BYTES; i++) {
+        longName += 'a';
+    }
+    GRD_DeleteDocInner(g_db, "grd_name", "{}", 0);
+    GRD_DeleteDocInner(g_db, longName.c_str(), "{}", 0);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field1\":" + input + "}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field\":\"" + input + "\"}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    inputJson = "{\"field1\":\"" + input + "\"}";
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+
+    const char *document1 = "{  \
+        \"_id\" : \"1\", \
+        \"name\": \"xiaoming\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"math\", \"English\", \"music\", {\"info\" : \"exam\"}] \
+    }";
+    const char *document2 = "{  \
+        \"_id\" : \"2\", \
+        \"name\": \"ori\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"math\", \"English\", \"music\"] \
+    }";
+    const char *document3 = "{  \
+        \"_id\" : \"3\", \
+        \"name\": \"David\", \
+        \"address\": \"beijing\", \
+        \"age\" : 15, \
+        \"friend\" : {\"name\" : \"David\", \"sex\" : \"female\", \"age\" : 90}, \
+        \"subject\": [\"Sing\", \"Jump\", \"Rap\", \"BasketBall\"] \
+    }";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document1, 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document2, 0);
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document3, 0);
+    GRD_DeleteDocInner(g_db, COLLECTION_NAME, "{}", 0);
+
+    DeleteDocResultFuzz(input);
+}
+
+namespace {
+void FindAndRelease(Query query)
+{
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    char *value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+
+    const char *newCollName = "./student";
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, newCollName, query, 1, &resultSet);
+    GRD_NextInner(resultSet);
+    value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+    resultSet = nullptr;
+    GRD_FindDocInner(g_db, newCollName, query, 0, &resultSet);
+    GRD_NextInner(resultSet);
+    value = nullptr;
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+}
+} // namespace
+
+void FindAndReleaseFuzz(std::string document, std::string filter, Query query, const std::string input)
+{
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document.c_str(), 0);
+    query.filter = filter.c_str();
+    query.projection = "{\"field\": 0}";
+    FindAndRelease(query);
+    document = "{\"field1.field2\" [false], \"field1.field2.field3\": [3], "
+               "\"field1.field4\": [null]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document.c_str(), 0);
+    query.filter = document.c_str();
+    query.projection = "{\"field\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field.field2\": 1}";
+    FindAndRelease(query);
+    document = "{\"field1\": {\"field2\": [{\"field3\":\"" + input + "\"}]}}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, document.c_str(), 0);
+    filter = "{\"field1.field2.field3\":\"" + input + "\"}";
+    query.filter = filter.c_str();
+    query.projection = "{\"field1.field2\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field2\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field3\": 1}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field3\": 0}";
+    FindAndRelease(query);
+    query.projection = "{\"field1.field2.field3\": 0, \"field1.field2.field3\": 0}";
+    FindAndRelease(query);
+    std::string projection = "{\"field1\": \"" + input + "\"}";
+    query.projection = projection.c_str();
+    FindAndRelease(query);
+    projection = "{\"" + input + "\": true, \"" + input + "\": false}";
+    query.projection = projection.c_str();
+    FindAndRelease(query);
+}
+
+void NextFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{" + input + "}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    Query query = { inputJson.c_str(), "{}" };
+    FindAndRelease(query);
+    std::string stringJson2 = "{ \"_id\":\"1\", \"field\":\"" + input + "\"}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson2.c_str(), 0);
+    query.filter = "{\"_id\": \"1\"}";
+    FindAndRelease(query);
+    std::string filter2 = "{ \"_id\":\"1\", \"field\":\"" + input + " invalid\"}";
+    query.filter = filter2.c_str();
+    FindAndRelease(query);
+    query.filter = "{\"_id\": \"3\"}";
+    FindAndRelease(query);
+    std::string stringJson3 = "{ \"_id\":\"2\", \"field\": [\"field2\", null, \"abc\", 123]}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, stringJson3.c_str(), 0);
+    query.filter = "{\"field\": [\"field2\", null, \"abc\", 123]}";
+    FindAndRelease(query);
+    std::string document = "{\"field\": [\"" + input + "\",\"" + input + "\",\"" + input + "\"]}";
+    std::string filter = "{\"field." + std::to_string(size) + "\":\"" + input + "\"}";
+    FindAndReleaseFuzz(document, filter, query, input);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+}
+
+void GetValueFuzz(const uint8_t *data, size_t size)
+{
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, OPTION_STR, 0);
+    std::string input(reinterpret_cast<const char *>(data), size);
+    std::string inputJson = "{" + input + "}";
+    GRD_InsertDocInner(g_db, COLLECTION_NAME, inputJson.c_str(), 0);
+    char *value = nullptr;
+    Query query = { inputJson.c_str(), "{}" };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FindDocInner(g_db, COLLECTION_NAME, query, 1, &resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_NextInner(resultSet);
+    GRD_GetValueInner(resultSet, &value);
+    GRD_FreeValueInner(value);
+    GRD_FreeResultSetInner(resultSet);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+}
+
+void FreeResultSetFuzz()
+{
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_FreeResultSetInner(resultSet);
+    resultSet = new GRD_ResultSet;
+    resultSet->resultSet_ = DocumentDB::ResultSet();
+    GRD_FreeResultSetInner(resultSet);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+}
+
+void DbOpenOneFuzz(GRD_DB *dbVal)
+{
+    std::string path = "./documentFuzz.db";
+    GRD_DBOpenInner(path.c_str(), "", GRD_DB_OPEN_ONLY, &dbVal);
+    (void)remove(path.c_str());
+
+    path = "./document.db";
+    GRD_DBOpenInner(path.c_str(), R""({"pageSize":64, "redopubbufsize":4033})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBCloseInner(dbVal, 0);
+    GRD_DBOpenInner(path.c_str(), R""({"pageSize":64, "redopubbufsize":4032})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpenInner(path.c_str(), R""({"redopubbufsize":255})"", GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpenInner(path.c_str(), R""({"redopubbufsize":16385})"", GRD_DB_OPEN_CREATE, &dbVal);
+}
+
+void DbOpenFuzz(const uint8_t *data, size_t size)
+{
+    std::string dbFileData(reinterpret_cast<const char *>(data), size);
+    std::string realDbFileData = DB_DIR_PATH + dbFileData;
+    const char *dbFileVal = realDbFileData.data();
+    std::string configStrData(reinterpret_cast<const char *>(data), size);
+    const char *configStrVal = configStrData.data();
+    GRD_DB *dbVal = nullptr;
+
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    std::string stringMax = getMaxString();
+    const char *configStrMaxLen = stringMax.data();
+    GRD_DBOpenInner(dbFileVal, configStrMaxLen, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValue = "{\"bufferPoolSize\": \"1024.5\"}";
+    const char *configStrStringValue = fieldStringValue.data();
+    GRD_DBOpenInner(dbFileVal, configStrStringValue, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldBoolValue = "{\"bufferPoolSize\":}";
+    const char *configStrBool = fieldBoolValue.data();
+    GRD_DBOpenInner(dbFileVal, configStrBool, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueAppend = "{\"bufferPoolSize\":\"8192\"}";
+    const char *configStrStr = fieldStringValueAppend.data();
+    GRD_DBOpenInner(dbFileVal, configStrStr, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueFlush = "{\"bufferPoolSize\":\"8192\",\"redoFlushBtTrx\":\"1\"}";
+    const char *configStrFlush = fieldStringValueFlush.data();
+    GRD_DBOpenInner(dbFileVal, configStrFlush, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueRedoBufsize = "{\"bufferPoolSize\":\"8192\",\"redoBufSize\":\"16384\"}";
+    const char *configStrBs = fieldStringValueRedoBufsize.data();
+    GRD_DBOpenInner(dbFileVal, configStrBs, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldStringValueMaxConnNum = "{\"bufferPoolSize\":\"8192\",\"maxConnNum\":\"1024\"}";
+    const char *configStrMcn = fieldStringValueMaxConnNum.data();
+    GRD_DBOpenInner(dbFileVal, configStrMcn, GRD_DB_OPEN_CREATE, &dbVal);
+
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    std::string fieldStringValueAll = "{\"bufferPoolSize\":\"8192\",\"redoFlushBtTrx\":\"1\",\"redoBufSize\":"
+                                        "\"16384\",\"maxConnNum\":\"1024\"}";
+    const char *configStrAll = fieldStringValueAll.data();
+    GRD_DBOpenInner(dbFileVal, configStrAll, GRD_DB_OPEN_CREATE, &dbVal);
+
+    std::string fieldLowNumber = "{\"bufferPoolSize\": 102}";
+    const char *configStrLowNumber = fieldLowNumber.data();
+    GRD_DBOpenInner(dbFileVal, configStrLowNumber, GRD_DB_OPEN_CREATE, &dbVal);
+
+    GRD_DBOpenInner(nullptr, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBOpenInner(dbFileVal, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBCloseInner(nullptr, GRD_DB_CLOSE);
+    GRD_DBCloseInner(dbVal, GRD_DB_CLOSE);
+
+    DbOpenOneFuzz(dbVal);
+}
+
+void DbCloseFuzz(const uint8_t *data, size_t size)
+{
+    std::string dbFileData(reinterpret_cast<const char *>(data), size);
+    std::string realDbFileData = DB_DIR_PATH + dbFileData;
+    const char *dbFileVal = realDbFileData.data();
+    std::string configStrData(reinterpret_cast<const char *>(data), size);
+    const char *configStrVal = configStrData.data();
+    GRD_DB *dbVal = nullptr;
+    GRD_DBOpenInner(dbFileVal, configStrVal, GRD_DB_OPEN_CREATE, &dbVal);
+    GRD_DBCloseInner(dbVal, GRD_DB_CLOSE);
+}
+
+void DbCloseResultSetFuzz()
+{
+    GRD_DB *db = nullptr;
+    GRD_DB *db2 = nullptr;
+    GRD_DBOpenInner(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db);
+    GRD_DBOpenInner(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db2);
+    GRD_CreateCollectionInner(db, "collection1", "{\"maxdoc\" : 5}", 0);
+
+    GRD_ResultSet *resultSet = nullptr;
+    Query query = { "{}", "{}" };
+    GRD_FindDocInner(db, "collection1", query, 0, &resultSet);
+
+    GRD_FreeResultSetInner(resultSet);
+
+    GRD_DBCloseInner(db, GRD_DB_CLOSE);
+
+    GRD_DBCloseInner(db2, GRD_DB_CLOSE);
+}
+
+void CreateCollectionFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollectionInner(nullptr, collectionNameVal, optionStrVal, 0);
+    GRD_CreateCollectionInner(g_db, collectionNameVal, optionStrVal, 0);
+    const char *optionStr = nullptr;
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, optionStr, 0);
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, "{\"maxdoc\":5, \"unexpected_max_doc\":32}", 0);
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, "{}", 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    std::string optStr = "{\"maxdoc\":" + optionStrData + "}";
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, optStr.c_str(), 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, optStr.c_str(), MAX_SIZE_NUM);
+    optStr = "{\"maxdoc\": 5}";
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, optStr.c_str(), 0);
+    GRD_CreateCollectionInner(g_db, COLLECTION_NAME, optStr.c_str(), 1);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, 0);
+    GRD_DropCollectionInner(g_db, COLLECTION_NAME, MAX_SIZE_NUM);
+    GRD_DropCollectionInner(g_db, collectionNameVal, 0);
+}
+
+void DropCollectionFuzz(const uint8_t *data, size_t size)
+{
+    std::string collectionNameData(reinterpret_cast<const char *>(data), size);
+    const char *collectionNameVal = collectionNameData.data();
+    std::string optionStrData(reinterpret_cast<const char *>(data), size);
+    const char *optionStrVal = optionStrData.data();
+    GRD_CreateCollectionInner(g_db, collectionNameVal, optionStrVal, 0);
+    GRD_DropCollectionInner(nullptr, collectionNameVal, 0);
+    GRD_DropCollectionInner(g_db, collectionNameVal, 0);
+}
+
+void DbFlushFuzz(const uint8_t *data, size_t size)
+{
+    GRD_DB *db = nullptr;
+    GRD_DB *db2 = nullptr;
+    GRD_DBOpenInner(TEST_DB_FILE, CONFIG_STR, GRD_DB_OPEN_CREATE, &db);
+    GRD_FlushInner(db, 0);
+    GRD_FlushInner(db, 1);
+    GRD_FlushInner(db2, 0);
+    GRD_FlushInner(db2, 1);
+    GRD_DBCloseInner(db, GRD_DB_CLOSE);
+}
+
+void TestGrdDbApGrdGetItem002Fuzz()
+{
+    const char *config = CONFIG_STR;
+    GRD_DB *db = nullptr;
+    GRD_DBOpenInner(TEST_DB_FILE, config, GRD_DB_OPEN_CREATE, &db);
+    GRD_IndexPreloadInner(nullptr, COLLECTION_NAME);
+    GRD_IndexPreloadInner(nullptr, "invalid_name");
+    GRD_IndexPreloadInner(g_db, COLLECTION_NAME);
+    std::string smallPrefix = std::string(SMALL_PREFIX_LEN, 'a');
+    for (uint32_t i = 0; i < NUM_NINETY_EIGHT; ++i) {
+        std::string v = smallPrefix + std::to_string(i);
+        GRD_KVItemT key = { &i, sizeof(uint32_t) };
+        GRD_KVItemT value = { reinterpret_cast<void *>(v.data()), static_cast<uint32_t>(v.size()) + 1 };
+        GRD_KVPutInner(g_db, COLLECTION_NAME, &key, &value);
+
+        GRD_KVItemT getValue = { nullptr, 0 };
+        GRD_KVGetInner(g_db, COLLECTION_NAME, &key, &getValue);
+        GRD_KVFreeItemInner(&getValue);
+
+        GRD_KVDelInner(g_db, COLLECTION_NAME, &key);
+    }
+    GRD_FlushInner(g_db, 1);
+
+    uint32_t begin = 0, end = MAX_SIZE_NUM;
+    GRD_FilterOptionT option = {};
+    option.mode = KV_SCAN_RANGE;
+    option.begin = { &begin, sizeof(uint32_t) };
+    option.end = { &end, sizeof(uint32_t) };
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_KVFilterInner(g_db, COLLECTION_NAME, &option, &resultSet);
+
+    uint32_t keySize, valueSize;
+    GRD_KVGetSizeInner(resultSet, &keySize, &valueSize);
+
+    resultSet = nullptr;
+    uint32_t i = 32;
+    GRD_KVItemT key = { &i, sizeof(uint32_t) };
+    GRD_KVScanInner(g_db, COLLECTION_NAME, &key, KV_SCAN_EQUAL_OR_LESS_KEY, &resultSet);
+
+    GRD_PrevInner(resultSet);
+    GRD_NextInner(resultSet);
+
+    GRD_FreeResultSetInner(resultSet);
+}
+
+void TestGrdKvBatchCoupling003Fuzz()
+{
+    const char *config = CONFIG_STR;
+    GRD_DB *db = nullptr;
+    GRD_DBOpenInner(TEST_DB_FILE, config, GRD_DB_OPEN_CREATE, &db);
+
+    GRD_ResultSet *resultSet = nullptr;
+    GRD_KVScanInner(g_db, COLLECTION_NAME, nullptr, KV_SCAN_PREFIX, &resultSet);
+
+    for (uint32_t i = 0; i < CURSOR_COUNT; i++) {
+        GRD_NextInner(resultSet);
+    }
+
+    GRD_KVBatchT *batchDel = nullptr;
+    std::vector<std::string> keySet;
+    std::vector<std::string> valueSet;
+    for (uint32_t i = 0; i < VECTOR_SIZE; i++) {
+        std::string key(MAX_SIZE_NUM, 'a');
+        key += std::to_string(i);
+        keySet.emplace_back(key);
+        std::string value = std::to_string(i);
+        valueSet.emplace_back(value);
+    }
+
+    for (int j = 0; j < BATCH_COUNT; j++) {
+        GRD_KVBatchPrepareInner(BATCH_COUNT, &batchDel);
+        GRD_KVBatchPutInner(g_db, COLLECTION_NAME, batchDel);
+        for (uint16_t i = 0; i < BATCH_COUNT; i++) {
+            char *batchKey = const_cast<char *>(keySet[CURSOR_COUNT + j * BATCH_COUNT + i].c_str());
+            char *batchValue = const_cast<char *>(valueSet[CURSOR_COUNT + j * BATCH_COUNT + i].c_str());
+            GRD_KVBatchPushbackInner(static_cast<void *>(batchKey),
+                static_cast<uint32_t>(keySet[CURSOR_COUNT + j * BATCH_COUNT + i].length()) + 1,
+                static_cast<void *>(batchValue),
+                static_cast<uint32_t>(valueSet[CURSOR_COUNT + j * BATCH_COUNT + i].length()) + 1,
+                batchDel);
+        }
+
+        GRD_KVBatchDelInner(g_db, COLLECTION_NAME, batchDel);
+
+        GRD_KVBatchDestroyInner(batchDel);
+    }
+
+    GRD_NextInner(resultSet);
+    GRD_KVItemT keyItem = { nullptr, 0 };
+    GRD_KVItemT valueItem = { nullptr, 0 };
+    GRD_FetchInner(resultSet, &keyItem, &valueItem);
+    GRD_KVFreeItemInner(&keyItem);
+    GRD_KVFreeItemInner(&valueItem);
+    GRD_FreeResultSetInner(resultSet);
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" {
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::SetUpTestCase();
+
+    OHOS::DbOpenFuzz(data, size);
+    OHOS::CreateCollectionFuzz(data, size);
+    OHOS::DropCollectionFuzz(data, size);
+    OHOS::InsertDocFuzz(data, size);
+    OHOS::FindDocFuzz(data, size);
+    OHOS::UpdateDocFuzz(data, size);
+    OHOS::UpsertDocFuzz(data, size);
+    OHOS::DeleteDocFuzz(data, size);
+    OHOS::NextFuzz(data, size);
+    OHOS::GetValueFuzz(data, size);
+    OHOS::FreeResultSetFuzz();
+    OHOS::TestGrdDbApGrdGetItem002Fuzz();
+    OHOS::TestGrdKvBatchCoupling003Fuzz();
+    OHOS::DbCloseFuzz(data, size);
+    OHOS::DbCloseResultSetFuzz();
+    OHOS::DbFlushFuzz(data, size);
+
+    OHOS::TearDownTestCase();
+    return 0;
+}
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.h b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e69bc3bd9678b45a2a8c99dc5962ec87c07e746
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/jsoninner_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JSON_INNER_FUZZER_H
+#define JSON_INNER_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "JsonInner_fuzzer"
+
+#endif // JSON_INNER_FUZZER_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/project.xml b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..73736f01a8820f5deb20590a5655e6fbe62b6aa6
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/jsoninner_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>1800</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn
index 8886e7b71bab96460d2f477f3ccb76c82281a7e7..d66696d028fbc48c25b2592d1f1341d5ebe141f3 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("KvDelegateManagerFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer"
 
   sources = distributeddb_src
@@ -94,6 +99,7 @@ ohos_fuzztest("KvDelegateManagerFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp
index f087b2e26687150ce9e03644cfd78fb2d5224470..0a5fdcf3cf80a5bbd2b9282f63e188675eed9eb8 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvdelegatemanager_fuzzer/kvdelegatemanager_fuzzer.cpp
@@ -14,11 +14,15 @@
  */
 
 #include "kvdelegatemanager_fuzzer.h"
+#include <codecvt>
+#include <cstdio>
 #include <list>
 #include <securec.h>
+#include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_test.h"
 #include "kv_store_delegate_manager.h"
 #include "log_print.h"
+#include "runtime_config.h"
 
 class KvDelegateManagerFuzzer {
     /* Keep C++ file names the same as the class name. */
@@ -28,7 +32,10 @@ namespace OHOS {
 using namespace DistributedDB;
 using namespace DistributedDBTest;
 
-std::string GetRandomString(const uint8_t* data, size_t size, size_t len, uint32_t &start)
+KvStoreDelegateManager g_mgr("APP_ID", "USER_ID");
+const std::string DUMP_DISTRIBUTED_DB = "--database";
+
+std::string GetRandomString(const uint8_t *data, size_t size, size_t len, uint32_t &start)
 {
     std::string res;
     if (size == 0) {
@@ -51,7 +58,37 @@ void GetRandomAutoLaunchOption(const uint8_t* data, size_t size, AutoLaunchOptio
     option.storeObserver = nullptr;
 }
 
-void CombineTest(const uint8_t* data, size_t size)
+void RuntimeConfigFuzz()
+{
+    int handle = -1;
+    std::vector<std::u16string> params;
+    const std::u16string u16DumpParam = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.
+        from_bytes(DUMP_DISTRIBUTED_DB);
+    params.push_back(u16DumpParam);
+    RuntimeConfig::Dump(handle, params);
+}
+
+void CallbackFuzz(const uint8_t *data, std::string storeId)
+{
+    uint64_t diskSize = static_cast<uint64_t>(*data);
+    g_mgr.GetKvStoreDiskSize(storeId, diskSize);
+    bool isPermissionCheck = static_cast<bool>(*data);
+    auto permissionCheckCallback = [isPermissionCheck](const std::string &userId, const std::string &appId,
+        const std::string &storeId, uint8_t flag) -> bool { return isPermissionCheck; };
+    (void) KvStoreDelegateManager::SetPermissionCheckCallback(permissionCheckCallback);
+    auto permissionCheckCallbackV2 = [isPermissionCheck](const std::string &userId, const std::string &appId,
+        const std::string &storeId, const std::string &deviceId, uint8_t flag) -> bool {
+            return isPermissionCheck;
+    };
+    (void) KvStoreDelegateManager::SetPermissionCheckCallback(permissionCheckCallbackV2);
+    bool isSyncActivationCheck = static_cast<bool>(*data);
+    auto syncActivationCheck = [isSyncActivationCheck](const std::string &userId, const std::string &appId,
+        const std::string &storeId) -> bool { return isSyncActivationCheck; };
+    KvStoreDelegateManager::SetSyncActivationCheckCallback(syncActivationCheck);
+    KvStoreDelegateManager::NotifyUserChanged();
+}
+
+void CombineTest(const uint8_t *data, size_t size)
 {
     LOGD("Begin KvDelegateManagerFuzzer");
     std::string path;
@@ -73,15 +110,29 @@ void CombineTest(const uint8_t* data, size_t size)
         option.dataDir = path;
         (void) KvStoreDelegateManager::EnableKvStoreAutoLaunch(userId, appId, storeId, option, nullptr);
         (void) KvStoreDelegateManager::DisableKvStoreAutoLaunch(userId, appId, storeId);
+        CallbackFuzz(data, storeId);
+        std::string targetDev = GetRandomString(data, size, len, start);
+        bool isCheckOk = static_cast<bool>(*data);
+        auto databaseStatusNotifyCallback = [userId, appId, storeId, targetDev, &isCheckOk] (
+            const std::string &notifyUserId, const std::string &notifyAppId, const std::string &notifyStoreId,
+            const std::string &deviceId, bool onlineStatus) -> void {
+                if (notifyUserId == userId && notifyAppId == appId && notifyStoreId == storeId &&
+                    deviceId == targetDev && onlineStatus == true) {
+                    isCheckOk = true;
+                }
+            };
+        g_mgr.SetStoreStatusNotifier(databaseStatusNotifyCallback);
+        RuntimeConfigFuzz();
     }
+    KvStoreDelegateManager::SetKvStoreCorruptionHandler(nullptr);
     DistributedDBToolsTest::RemoveTestDbFiles(path);
     LOGD("End KvDelegateManagerFuzzer");
 }
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     OHOS::CombineTest(data, size);
     return 0;
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/BUILD.gn
index e6df43f1f25c199cd53ab877d8e6b275907299f8..b8f8e53f1def2e394926e871847351c13c0be03d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("KvStoreResultSetFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer"
 
   sources = distributeddb_src
@@ -94,6 +99,7 @@ ohos_fuzztest("KvStoreResultSetFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.cpp
index f88b8ded2b7745b85cfffd9372e4a3445b6dd383..a4a71e39e4915c3986b4cd2fa2f7edcc114baa02 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.cpp
@@ -63,7 +63,7 @@ void ResultSetFuzzer(const uint8_t* data, size_t size)
         if (size == 0) {
             return;
         }
-        auto pos = U32_AT(data) % size;
+        auto pos = KvStoreResultSetFuzzer::U32_AT(data) % size;
         readResultSet->MoveToPosition(pos++);
         readResultSet->Move(0 - pos);
         readResultSet->IsFirst();
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.h b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.h
index 05a8f768872ed15ba48b7d4346489f4c29d4c660..83576ab960cc970d5446af4dd916e23bdb469677 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.h
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/kvstoreresultset_fuzzer/kvstoreresultset_fuzzer.h
@@ -20,10 +20,15 @@
 
 #include <cstdint>
 
-static inline uint32_t U32_AT(const uint8_t * const &ptr)
-{
-    // 24 - 16 - 8 - 0, the 3th one no need to shift left
-    return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
-}
+namespace DistributedDB {
+class KvStoreResultSetFuzzer final {
+public:
+    static inline uint32_t U32_AT(const uint8_t * const &ptr)
+    {
+        // 24 - 16 - 8 - 0, the 3th one no need to shift left
+        return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+    }
+};
+} // namespace DistributedDB
 
 #endif // KVSTORERESULTSET_FUZZER_H
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
index 78bbd1d43f1c8fe53a365009acb81e9b01c7ae29..66bf82ae8471c4b6b9d84f9a9fe0e97a3ad4ff40 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/BUILD.gn
@@ -71,12 +71,18 @@ ohos_fuzztest("NbDelegateFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer"
 
   sources = distributeddb_src
   sources += [
+    "../../../test/fuzztest/common/fuzzer_data.cpp",
     "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/common/distributeddb_tools_test.cpp",
     "nbdelegate_fuzzer.cpp",
   ]
@@ -93,6 +99,7 @@ ohos_fuzztest("NbDelegateFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
index 0766f5e96ca098a284e0e91e18034cfecb7cbff5..6a8cb3c76cb33e7c41ce89e0a7556c8805eee1bd 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/nbdelegate_fuzzer/nbdelegate_fuzzer.cpp
@@ -16,6 +16,7 @@
 #include "nbdelegate_fuzzer.h"
 #include <list>
 #include "distributeddb_tools_test.h"
+#include "fuzzer_data.h"
 #include "kv_store_delegate.h"
 #include "kv_store_delegate_manager.h"
 #include "kv_store_observer.h"
@@ -104,7 +105,7 @@ bool KvStoreObserverFuzzTest::IsCleared() const
     return isCleared_;
 }
 
-std::vector<Entry> CreateEntries(const uint8_t* data, size_t size, std::vector<Key> &keys)
+std::vector<Entry> CreateEntries(const uint8_t *data, size_t size, std::vector<Key> &keys)
 {
     std::vector<Entry> entries;
     // key'length is less than 1024.
@@ -142,6 +143,20 @@ void FuzzSetInterceptorTest(KvStoreNbDelegate *kvNbDelegatePtr)
             return errCode;
         }
     );
+    kvNbDelegatePtr->SetReceiveDataInterceptor(
+        [](InterceptedData &data, const std::string &sourceID, const std::string &targetID) {
+            int errCode = OK;
+            auto entries = data.GetEntries();
+            for (size_t i = 0; i < entries.size(); i++) {
+                Key newKey;
+                errCode = data.ModifyKey(i, newKey);
+                if (errCode != OK) {
+                    return errCode;
+                }
+            }
+            return errCode;
+        }
+    );
 }
 
 void TestCRUD(const Key &key, const Value &value, KvStoreNbDelegate *kvNbDelegatePtr)
@@ -158,11 +173,47 @@ void TestCRUD(const Key &key, const Value &value, KvStoreNbDelegate *kvNbDelegat
     });
     std::vector<Entry> vect;
     kvNbDelegatePtr->GetEntries(key, vect);
+    vect.clear();
+    kvNbDelegatePtr->GetLocalEntries(key, vect);
+    std::vector<Key> vectKeys;
+    kvNbDelegatePtr->GetKeys(key, vectKeys);
     kvNbDelegatePtr->Delete(key);
     kvNbDelegatePtr->Get(key, valueRead);
 }
 
-void FuzzCURD(const uint8_t* data, size_t size, KvStoreNbDelegate *kvNbDelegatePtr)
+void GetDeviceEntriesTest(const uint8_t *data, size_t size, KvStoreNbDelegate *kvNbDelegatePtr)
+{
+    FuzzerData fuzzerData(data, size);
+    uint32_t len = fuzzerData.GetUInt32();
+    const int lenMod = 30; // 30 is mod for string vector size
+    std::string device = fuzzerData.GetString(len % lenMod);
+    kvNbDelegatePtr->GetWatermarkInfo(device);
+    kvNbDelegatePtr->GetSyncDataSize(device);
+    std::vector<Entry> vect;
+    kvNbDelegatePtr->GetDeviceEntries(device, vect);
+}
+
+void RandomModeRemoveDeviceData(const uint8_t *data, size_t size, KvStoreNbDelegate *kvNbDelegatePtr)
+{
+    if (size == 0) {
+        return;
+    }
+    auto mode = static_cast<ClearMode>(data[0]);
+    LOGI("[RandomModeRemoveDeviceData] select mode %d", static_cast<int>(mode));
+    if (mode == DEFAULT) {
+        return;
+    }
+    FuzzerData fuzzerData(data, size);
+    uint32_t len = fuzzerData.GetUInt32();
+    const int lenMod = 30; // 30 is mod for string vector size
+    std::string device = fuzzerData.GetString(len % lenMod);
+    std::string user = fuzzerData.GetString(len % lenMod);
+    kvNbDelegatePtr->RemoveDeviceData();
+    kvNbDelegatePtr->RemoveDeviceData(device, mode);
+    kvNbDelegatePtr->RemoveDeviceData(device, user, mode);
+}
+
+void FuzzCURD(const uint8_t *data, size_t size, KvStoreNbDelegate *kvNbDelegatePtr)
 {
     auto observer = new (std::nothrow) KvStoreObserverFuzzTest;
     if ((observer == nullptr) || (kvNbDelegatePtr == nullptr)) {
@@ -175,6 +226,7 @@ void FuzzCURD(const uint8_t* data, size_t size, KvStoreNbDelegate *kvNbDelegateP
         (void)data.GetType();
     });
     TestCRUD(key, value, kvNbDelegatePtr);
+    kvNbDelegatePtr->StartTransaction();
     std::vector<Key> keys;
     std::vector<Entry> tmp = CreateEntries(data, size, keys);
     kvNbDelegatePtr->PutBatch(tmp);
@@ -185,6 +237,8 @@ void FuzzCURD(const uint8_t* data, size_t size, KvStoreNbDelegate *kvNbDelegateP
         kvNbDelegatePtr->UnpublishToLocal(keys[0], deletePublic, updateTimestamp);
     }
     kvNbDelegatePtr->DeleteBatch(keys);
+    kvNbDelegatePtr->Rollback();
+    kvNbDelegatePtr->Commit();
     kvNbDelegatePtr->UnRegisterObserver(observer);
     delete observer;
     observer = nullptr;
@@ -202,12 +256,14 @@ void FuzzCURD(const uint8_t* data, size_t size, KvStoreNbDelegate *kvNbDelegateP
         kvNbDelegatePtr->PublishLocal(keys[0], deleteLocal, updateTimestamp, nullptr);
     }
     kvNbDelegatePtr->DeleteBatch(keys);
+    kvNbDelegatePtr->GetTaskCount();
     std::string rawString(reinterpret_cast<const char *>(data), size);
     kvNbDelegatePtr->RemoveDeviceData(rawString);
-    kvNbDelegatePtr->RemoveDeviceData();
+    RandomModeRemoveDeviceData(data, size, kvNbDelegatePtr);
+    GetDeviceEntriesTest(data, size, kvNbDelegatePtr);
 }
 
-void EncryptOperation(const uint8_t* data, size_t size, std::string &DirPath, KvStoreNbDelegate *kvNbDelegatePtr)
+void EncryptOperation(const uint8_t *data, size_t size, std::string &DirPath, KvStoreNbDelegate *kvNbDelegatePtr)
 {
     if (kvNbDelegatePtr == nullptr) {
         return;
@@ -223,7 +279,7 @@ void EncryptOperation(const uint8_t* data, size_t size, std::string &DirPath, Kv
     kvNbDelegatePtr->Import(mulitExportFileName, passwd);
 }
 
-void CombineTest(const uint8_t* data, size_t size, KvStoreNbDelegate::Option &option)
+void CombineTest(const uint8_t *data, size_t size, KvStoreNbDelegate::Option &option)
 {
     static auto kvManager = KvStoreDelegateManager("APP_ID", "USER_ID");
     KvStoreConfig config;
@@ -247,7 +303,7 @@ void CombineTest(const uint8_t* data, size_t size, KvStoreNbDelegate::Option &op
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     DistributedDB::KvStoreNbDelegate::Option option = {true, false, false};
     OHOS::CombineTest(data, size, option);
@@ -255,4 +311,3 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     OHOS::CombineTest(data, size, option);
     return 0;
 }
-
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/parseckeck_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/parseckeck_fuzzer/BUILD.gn
index 9b695612d442fc26ae978df77813701022f4f046..35e065f45cbe7d71d09f9773960cf1441e4c5531 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/parseckeck_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/parseckeck_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("ParseCkeckFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/parseckeck_fuzzer"
 
   sources = distributeddb_src
@@ -94,6 +99,7 @@ ohos_fuzztest("ParseCkeckFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/BUILD.gn
index 7b5ed335a4ab4f59a699d3ef2a58d022098453e3..dc37b3eee719fdd46dbb3203e5e4d629c662b1b7 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("QueryFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer"
 
   sources = distributeddb_src
@@ -93,6 +98,7 @@ ohos_fuzztest("QueryFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.cpp
index 022427e7fde48d1f15e9c600eeec524d2c3e3e1d..e8c8e4ed4ddb6de6567519101686ed198c20cbe4 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.cpp
@@ -39,7 +39,7 @@ void FuzzNotEqualTo(const uint8_t* data, size_t size)
 void FuzzGreaterThan(const uint8_t* data, size_t size)
 {
     std::string rawString(reinterpret_cast<const char *>(data), size);
-    Query query = Query::Select().GreaterThan(rawString, static_cast<int>(U32_AT(data)));
+    Query query = Query::Select().GreaterThan(rawString, static_cast<int>(QueryFuzzer::U32_AT(data)));
 }
 
 void FuzzLessThan(const uint8_t* data, size_t size)
@@ -69,7 +69,7 @@ void FuzzOrderBy(const uint8_t* data, size_t size)
 
 void FuzzLimit(const uint8_t* data, size_t size)
 {
-    Query query = Query::Select().Limit(static_cast<int>(size), static_cast<int>(U32_AT(data)));
+    Query query = Query::Select().Limit(static_cast<int>(size), static_cast<int>(QueryFuzzer::U32_AT(data)));
 }
 
 void FuzzLike(const uint8_t* data, size_t size)
@@ -89,7 +89,7 @@ void FuzzIn(const uint8_t* data, size_t size)
     std::string rawString(reinterpret_cast<const char *>(data), size);
     std::vector<std::string> values;
     // 512 max size
-    for (int i = 0; i < static_cast<int>(U32_AT(data) % 512); i++) {
+    for (int i = 0; i < static_cast<int>(QueryFuzzer::U32_AT(data) % 512); i++) {
         values.push_back(rawString);
     }
     Query query = Query::Select().In(TEST_FIELD_NAME, values);
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.h b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.h
index 78db522c77307c5e8a3f7bffcc8d46780254182c..0a89c59d6a86dd2ad45bad16da9376eecbd3e90f 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.h
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/query_fuzzer/query_fuzzer.h
@@ -20,10 +20,15 @@
 
 #include <cstdint>
 
-static inline uint32_t U32_AT(const uint8_t * const &ptr)
-{
-    // 24 - 16 - 8 - 0, the 3th one no need to shift left
-    return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
-}
+namespace DistributedDB {
+class QueryFuzzer final {
+public:
+    static inline uint32_t U32_AT(const uint8_t * const &ptr)
+    {
+        // 24 - 16 - 8 - 0, the 3th one no need to shift left
+        return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
+    }
+};
+} // namespace DistributedDB
 
 #endif // QUERY_FUZZER_H
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/rekey_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/rekey_fuzzer/BUILD.gn
index 7f15a5d15f0cb29633cc74311a5a72b83a30d5e9..34128d2f3ad3bda197cfef909d673ed7d3c6d254 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/rekey_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/rekey_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("ReKeyFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/rekey_fuzzer"
 
   sources = distributeddb_src
@@ -94,6 +99,7 @@ ohos_fuzztest("ReKeyFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn
index e4b6d0c5d9a8e943a27bd098f3a3a089f8f1b3a9..c683d4a92311441ff221d0d4b59ea124ddd4fb83 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("RelationalstoredelegateFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer"
 
   sources = distributeddb_src
@@ -97,6 +102,7 @@ ohos_fuzztest("RelationalstoredelegateFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_EXPORT_SYMBOLS",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp
index 157ab2e8f34ca570efb69740e6006a1b4b63937d..b484b62b9d04ff1164ad6ea19a215efacc6cf0af 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoredelegate_fuzzer/relationalstoredelegate_fuzzer.cpp
@@ -14,32 +14,34 @@
  */
 
 #include "relationalstoredelegate_fuzzer.h"
+#include "cloud/cloud_store_types.h"
 #include "distributeddb_data_generate_unit_test.h"
+#include "distributeddb/result_set.h"
 #include "distributeddb_tools_test.h"
-#include "log_print.h"
 #include "fuzzer_data.h"
+#include "log_print.h"
+#include "query.h"
 #include "relational_store_delegate.h"
 #include "relational_store_manager.h"
-#include "virtual_communicator_aggregator.h"
-#include "query.h"
-#include "store_types.h"
-#include "distributeddb/result_set.h"
 #include "runtime_context.h"
+#include "store_observer.h"
+#include "store_types.h"
+#include "virtual_communicator_aggregator.h"
 
 namespace OHOS {
 using namespace DistributedDB;
 using namespace DistributedDBTest;
 using namespace DistributedDBUnitTest;
 
-constexpr const char* DB_SUFFIX = ".db";
-constexpr const char* STORE_ID = "Relational_Store_ID";
+constexpr const char *DB_SUFFIX = ".db";
+constexpr const char *STORE_ID = "Relational_Store_ID";
 const std::string DEVICE_A = "DEVICE_A";
 std::string g_testDir;
 std::string g_dbDir;
 DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
 sqlite3 *g_db = nullptr;
 RelationalStoreDelegate *g_delegate = nullptr;
-VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+VirtualCommunicatorAggregator *g_communicatorAggregator = nullptr;
 const std::string NORMAL_CREATE_TABLE_SQL = "CREATE TABLE IF NOT EXISTS sync_data(" \
     "key         BLOB NOT NULL UNIQUE," \
     "value       BLOB," \
@@ -95,8 +97,38 @@ void TearDown()
     DistributedDBToolsTest::RemoveTestDbFiles(g_testDir);
 }
 
-void CombineTest(const uint8_t* data, size_t size)
+void MultiCombineTest(const uint8_t *data, const std::string &tableName, const std::string &extendColName,
+    std::set<std::string> trackerColNames, bool isDeleted)
+{
+    TrackerSchema schema;
+    schema.tableName = tableName;
+    schema.extendColName = extendColName;
+    schema.trackerColNames = trackerColNames;
+    g_delegate->SetTrackerTable(schema);
+    g_delegate->SetReference({});
+    g_delegate->CleanTrackerData(tableName, 0);
+    bool logicDelete = isDeleted;
+    auto pragmaData = static_cast<PragmaData>(&logicDelete);
+    auto pragmaCmd = static_cast<PragmaCmd>(data[0]);
+    g_delegate->Pragma(pragmaCmd, pragmaData);
+    VBucket records;
+    records[extendColName] = extendColName;
+    auto recordStatus = static_cast<RecordStatus>(data[0]);
+    g_delegate->UpsertData(tableName, { records }, recordStatus);
+    DistributedDB::SqlCondition sqlCondition;
+    std::vector<VBucket> sqlRecords;
+    g_delegate->ExecuteSql(sqlCondition, sqlRecords);
+}
+
+void CombineTest(const uint8_t *data, size_t size)
 {
+    auto observer = new (std::nothrow) DistributedDB::StoreObserver;
+    if (observer == nullptr) {
+        delete observer;
+        observer = nullptr;
+        return;
+    }
+    g_delegate->RegisterObserver(observer);
     if (g_delegate == nullptr) {
         LOGI("delegate is null");
         return;
@@ -118,6 +150,11 @@ void CombineTest(const uint8_t* data, size_t size)
     }
     SyncStatusCallback callback = nullptr;
     g_delegate->Sync(device, mode, query, callback, len % 2); // 2 is mod num for wait parameter
+    g_delegate->GetCloudSyncTaskCount();
+    std::string extendColName = fuzzerData.GetString(len % lenMod);
+    std::set<std::string> trackerColNames = fuzzerData.GetStringSet(len % lenMod);
+    bool isLogicDeleted = static_cast<bool>(*data);
+    MultiCombineTest(data, tableName, extendColName, trackerColNames, isLogicDeleted);
     std::string deviceId = device.size() > 0 ? device[0] : tableName;
     g_delegate->RemoveDeviceData();
     g_delegate->RemoveDeviceData(deviceId);
@@ -127,14 +164,19 @@ void CombineTest(const uint8_t* data, size_t size)
     std::shared_ptr<ResultSet> resultSet = nullptr;
     uint64_t timeout = len;
     g_delegate->RemoteQuery(deviceId, rc, timeout, resultSet);
+    g_delegate->UnRegisterObserver(observer);
+    g_delegate->RegisterObserver(observer);
+    g_delegate->UnRegisterObserver();
+    delete observer;
+    observer = nullptr;
 }
 }
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     OHOS::Setup();
     OHOS::CombineTest(data, size);
     OHOS::TearDown();
     return 0;
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn
index 6c97ac3448d49be483678b84693470416dc4e1ce..5269b5d77f51bb23df917cb43b0e430a174a9dba 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("RelationalstoremanagerFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer"
 
   sources = distributeddb_src
@@ -97,6 +102,7 @@ ohos_fuzztest("RelationalstoremanagerFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_EXPORT_SYMBOLS",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp
index c5fd1f9c82e0a40cb4e1a9d421b46d32816781c5..877a5e90e5be6a40fe05a3fba8c949ab21837513 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/relationalstoremanager_fuzzer/relationalstoremanager_fuzzer.cpp
@@ -20,6 +20,7 @@
 #include "relational_store_manager.h"
 #include "runtime_config.h"
 #include "store_changed_data.h"
+#include "store_types.h"
 #include "virtual_communicator_aggregator.h"
 
 namespace OHOS {
@@ -27,15 +28,14 @@ using namespace DistributedDB;
 using namespace DistributedDBTest;
 using namespace DistributedDBUnitTest;
 
-constexpr const char* DB_SUFFIX = ".db";
-constexpr const char* STORE_ID = "Relational_Store_ID";
-const std::string DEVICE_A = "DEVICE_A";
+constexpr const char *DB_SUFFIX = ".db";
+constexpr const char *STORE_ID = "Relational_Store_ID";
 std::string g_testDir;
 std::string g_dbDir;
 sqlite3 *g_db = nullptr;
 DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
 RelationalStoreDelegate *g_delegate = nullptr;
-VirtualCommunicatorAggregator* g_communicatorAggregator = nullptr;
+VirtualCommunicatorAggregator *g_communicatorAggregator = nullptr;
 
 void Setup()
 {
@@ -66,31 +66,95 @@ void TearDown()
     DistributedDBToolsTest::RemoveTestDbFiles(g_testDir);
 }
 
-void CombineTest(const uint8_t* data, size_t size)
+void RuntimeConfigTest(const uint8_t *data, size_t size)
 {
+    bool isPermissionCheck = static_cast<bool>(*data);
+    auto permissionCheckCallbackV2 = [isPermissionCheck](const std::string &userId, const std::string &appId,
+        const std::string &storeId, const std::string &deviceId, uint8_t flag) -> bool { return isPermissionCheck; };
+    RuntimeConfig::SetPermissionCheckCallback(permissionCheckCallbackV2);
+    auto permissionCheckCallbackV3 = [isPermissionCheck](const PermissionCheckParam &param, uint8_t flag) -> bool {
+        return isPermissionCheck;
+    };
+    RuntimeConfig::SetPermissionCheckCallback(permissionCheckCallbackV3);
+    bool isSyncActivationCheck = static_cast<bool>(*data);
+    auto syncActivationCheck = [isSyncActivationCheck](const std::string &userId, const std::string &appId,
+        const std::string &storeId) -> bool { return isSyncActivationCheck; };
+    RuntimeConfig::SetSyncActivationCheckCallback(syncActivationCheck);
+    auto syncActivationCheckV2 = [isSyncActivationCheck](const ActivationCheckParam &param) -> bool {
+        return isSyncActivationCheck;
+    };
+    RuntimeConfig::SetSyncActivationCheckCallback(syncActivationCheckV2);
     FuzzerData fuzzerData(data, size);
     uint32_t instanceId = fuzzerData.GetUInt32();
-    std::string appId = fuzzerData.GetString(instanceId % 30);
-    std::string userId = fuzzerData.GetString(instanceId % 30);
-    std::string storeId = fuzzerData.GetString(instanceId % 30);
+    const int lenMod = 30; // 30 is mod for string vector size
+    std::string userId = fuzzerData.GetString(instanceId % lenMod);
+    std::string subUserId = fuzzerData.GetString(instanceId % lenMod);
+    RuntimeConfig::SetPermissionConditionCallback([userId, subUserId](const PermissionConditionParam &param) {
+        std::map<std::string, std::string> res;
+        res.emplace(userId, subUserId);
+        return res;
+    });
+    RuntimeConfig::IsProcessSystemApiAdapterValid();
+    bool isAutoLaunch = static_cast<bool>(*data);
+    auto autoLaunchRequestCallback = [isAutoLaunch](const std::string &identifier, AutoLaunchParam &param) -> bool {
+        return isAutoLaunch;
+    };
+    auto dbType = static_cast<DBType>(data[0]);
+    RuntimeConfig::SetAutoLaunchRequestCallback(autoLaunchRequestCallback, dbType);
+    std::string appId = fuzzerData.GetString(instanceId % lenMod);
+    std::string storeId = fuzzerData.GetString(instanceId % lenMod);
+    RuntimeConfig::ReleaseAutoLaunch(userId, appId, storeId, dbType);
+    std::vector<DBInfo> dbInfos;
+    DBInfo dbInfo = {
+        userId,
+        appId,
+        storeId,
+        true,
+        true
+    };
+    dbInfos.push_back(dbInfo);
+    std::string device = fuzzerData.GetString(instanceId % lenMod);
+    RuntimeConfig::NotifyDBInfos({ device }, dbInfos);
+    RuntimeConfig::NotifyUserChanged();
+}
+
+void CombineTest(const uint8_t *data, size_t size)
+{
+    FuzzerData fuzzerData(data, size);
+    uint32_t instanceId = fuzzerData.GetUInt32();
+    const int lenMod = 30; // 30 is mod for string vector size
+    std::string appId = fuzzerData.GetString(instanceId % lenMod);
+    std::string userId = fuzzerData.GetString(instanceId % lenMod);
+    std::string storeId = fuzzerData.GetString(instanceId % lenMod);
     RelationalStoreManager::GetDistributedTableName(appId, userId);
     RelationalStoreManager mgr(appId, userId, instanceId);
     g_mgr.GetDistributedTableName(appId, userId);
+    g_mgr.GetDistributedLogTableName(userId);
     g_mgr.OpenStore(g_dbDir + appId + DB_SUFFIX, storeId, {}, g_delegate);
     g_mgr.GetRelationalStoreIdentifier(userId, appId, storeId, instanceId % 2); // 2 is mod num for last parameter
+    int type = fuzzerData.GetInt();
+    Bytes bytes = { type, type, type };
+    auto status = static_cast<DBStatus>(data[0]);
+    g_mgr.ParserQueryNodes(bytes, status);
+    std::string key = fuzzerData.GetString(instanceId % lenMod);
+    std::map<std::string, Type> primaryKey = {{ key, key }};
+    auto collateType = static_cast<CollateType>(data[0]);
+    std::map<std::string, CollateType> collateTypeMap = {{ key, collateType }};
+    g_mgr.CalcPrimaryKeyHash(primaryKey, collateTypeMap);
     RuntimeConfig::SetProcessLabel(appId, userId);
     RuntimeConfig::SetTranslateToDeviceIdCallback([](const std::string &oriDevId, const StoreInfo &info) {
         return oriDevId + "_" + info.appId;
     });
+    RuntimeConfigTest(data, size);
 }
 }
 
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     OHOS::Setup();
     OHOS::CombineTest(data, size);
     OHOS::TearDown();
     return 0;
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/BUILD.gn
index 97448c4e7244a7b854de3480b716222a7bd23554..26c13bcf8630a960047d6f4a61e1277755ce14b8 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer/BUILD.gn
@@ -70,7 +70,13 @@ ohos_fuzztest("SchemaDelegateFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
+
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/schemadelegate_fuzzer"
 
   sources = distributeddb_src
@@ -93,6 +99,7 @@ ohos_fuzztest("SchemaDelegateFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_ENABLE_DROPTABLE_CALLBACK",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/BUILD.gn
index 338f4efd31850b4c655a2360c27cb1f7600e476f..aa498b9a29bba17c70ecb10b990471701b0b5614 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/BUILD.gn
@@ -63,8 +63,13 @@ ohos_fuzztest("StorageFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "../storage_fuzzer"
 
   sources = distributeddb_src
@@ -87,6 +92,7 @@ ohos_fuzztest("StorageFuzzTest") {
     "LOW_LEVEL_MEM_DEV",
     "JSONCPP_USE_BUILDER",
     "OMIT_FLATBUFFER",
+    "OMIT_MULTI_VER",
     "RELATIONAL_STORE",
     "SQLITE_DISTRIBUTE_RELATIONAL",
     "SQLITE_EXPORT_SYMBOLS",
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/storage_fuzzer.cpp b/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/storage_fuzzer.cpp
index eaa5887474578ee4126a83cebe3de847e9cee07e..7abf7d7d99767119453ab691cc2e14117cb88f9d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/storage_fuzzer.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/storage_fuzzer/storage_fuzzer.cpp
@@ -26,10 +26,13 @@
 #include "distributeddb_tools_test.h"
 #include "log_print.h"
 #include "fuzzer_data.h"
+#include "relational_store_client.h"
 #include "relational_store_delegate.h"
 #include "relational_store_manager.h"
 #include "runtime_config.h"
 #include "storage_proxy.h"
+#include "store_observer.h"
+#include "store_types.h"
 #include "virtual_asset_loader.h"
 #include "virtual_cloud_data_translate.h"
 #include "virtual_cloud_db.h"
@@ -47,6 +50,18 @@ DistributedDB::RelationalStoreManager g_mgr(APP_ID, USER_ID);
 RelationalStoreDelegate *g_delegate = nullptr;
 IRelationalStore *g_store = nullptr;
 std::shared_ptr<StorageProxy> g_storageProxy = nullptr;
+static const char *STOREID = "CLIENT_STORE_ID";
+static const char *DBSUFFIX = ".db";
+static const std::string g_prefix = "naturalbase_rdb_aux_";
+static std::map<std::string, ChangeProperties> g_triggerTableData;
+static int g_triggeredCount = 0;
+static std::string g_dbDir;
+static std::string g_testDir;
+static std::mutex g_mutex;
+static std::condition_variable g_cv;
+static bool g_alreadyNotify = false;
+DistributedDB::StoreObserver::StoreChangedInfo g_changedData;
+static constexpr const int MOD = 1000; // 1000 is mod
 
 class StorageFuzzer {
 public:
@@ -192,6 +207,8 @@ void Setup()
         return;
     }
     g_storageFuzzerTest->SetUp();
+    DistributedDBToolsTest::TestDirInit(g_testDir);
+    g_dbDir = g_testDir + "/";
 }
 
 void TearDown()
@@ -202,6 +219,8 @@ void TearDown()
         delete g_storageFuzzerTest;
         g_storageFuzzerTest = nullptr;
     }
+    g_alreadyNotify = false;
+    DistributedDBToolsTest::RemoveTestDbFiles(g_testDir);
 }
 
 void CombineTest(const uint8_t* data, size_t size)
@@ -211,6 +230,140 @@ void CombineTest(const uint8_t* data, size_t size)
     }
     g_storageFuzzerTest->FuzzTest(data, size);
 }
+
+class ClientStoreObserver : public StoreObserver {
+public:
+    virtual ~ClientStoreObserver() {}
+    void OnChange(StoreChangedInfo &&data) override
+    {
+        g_changedData = data;
+        std::unique_lock<std::mutex> lock(g_mutex);
+        g_cv.notify_one();
+        g_alreadyNotify = true;
+    }
+};
+
+void ClientObserverFunc(ClientChangedData &clientChangedData)
+{
+    for (const auto &tableEntry : clientChangedData.tableData) {
+        LOGD("client observer failed, table: %s", tableEntry.first.c_str());
+        g_triggerTableData.insert_or_assign(tableEntry.first, tableEntry.second);
+    }
+    g_triggeredCount++;
+    {
+        std::unique_lock<std::mutex> lock(g_mutex);
+        g_alreadyNotify = true;
+    }
+    g_cv.notify_one();
+}
+
+void CreateTableForStoreObserver(sqlite3 *db, const std::string tableName)
+{
+    std::string sql = "create table " + tableName + "(id INTEGER primary key, name TEXT);";
+    RdbTestUtils::ExecSql(db, sql);
+    sql = "create table no_" + tableName + "(id INTEGER, name TEXT);";
+    RdbTestUtils::ExecSql(db, sql);
+    sql = "create table mult_" + tableName + "(id INTEGER, name TEXT, age int, ";
+    sql += "PRIMARY KEY (id, name));";
+    RdbTestUtils::ExecSql(db, sql);
+}
+
+void InitLogicDeleteData(sqlite3 *&db, const std::string &tableName, uint64_t num)
+{
+    for (size_t i = 0; i < num; ++i) {
+        std::string sql = "insert or replace into " + tableName + " VALUES('" + std::to_string(i) + "', 'zhangsan');";
+        RdbTestUtils::ExecSql(db, sql);
+    }
+    std::string sql = "update " + g_prefix + tableName + "_log" + " SET flag = flag | 0x08";
+    RdbTestUtils::ExecSql(db, sql);
+}
+
+void InitDataStatus(const std::string &tableName, int count, sqlite3 *db)
+{
+    int type = 4; // the num of different status
+    for (int i = 1; i <= type * count; i++) {
+        std::string sql = "INSERT INTO " + tableName + " VALUES(" + std::to_string(i) + ", 'zhangsan" +
+            std::to_string(i) + "');";
+        RdbTestUtils::ExecSql(db, sql);
+    }
+    std::string countStr = std::to_string(count);
+    std::string sql = "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET status=(CASE WHEN data_key<=" +
+        countStr + " THEN 0 WHEN data_key>" + countStr + " AND data_key<=2*" + countStr + " THEN 1 WHEN data_key>2*" +
+        countStr + " AND data_key<=3*" + countStr + " THEN 2 ELSE 3 END)";
+    RdbTestUtils::ExecSql(db, sql);
+}
+
+void GetHashKey(const std::string &tableName, const std::string &condition, sqlite3 *db,
+    std::vector<std::vector<uint8_t>> &hashKey)
+{
+    sqlite3_stmt *stmt = nullptr;
+    std::string sql = "select hash_key from " + DBCommon::GetLogTableName(tableName) + " where " + condition;
+    SQLiteUtils::GetStatement(db, sql, stmt);
+    while (SQLiteUtils::StepWithRetry(stmt) == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
+        std::vector<uint8_t> blob;
+        SQLiteUtils::GetColumnBlobValue(stmt, 0, blob);
+        hashKey.push_back(blob);
+    }
+    int errCode;
+    SQLiteUtils::ResetStatement(stmt, true, errCode);
+}
+
+void ClientObserverFuzz(std::string tableName)
+{
+    sqlite3 *db = RdbTestUtils::CreateDataBase(g_dbDir + STOREID + DBSUFFIX);
+    ClientObserver clientObserver = [](ClientChangedData &data) { return ClientObserverFunc(data); };
+    RegisterClientObserver(db, clientObserver);
+    std::string sql = "insert into " + tableName + " VALUES(1, 'zhangsan'), (2, 'lisi'), (3, 'wangwu');";
+    RdbTestUtils::ExecSql(db, sql);
+    UnRegisterClientObserver(db);
+    sqlite3_close_v2(db);
+}
+
+void StoreObserverFuzz(std::string tableName)
+{
+    sqlite3 *db = RdbTestUtils::CreateDataBase(g_dbDir + STOREID + DBSUFFIX);
+    RdbTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;");
+    CreateTableForStoreObserver(db, tableName);
+    auto storeObserver = std::make_shared<ClientStoreObserver>();
+    RegisterStoreObserver(db, storeObserver);
+    UnregisterStoreObserver(db);
+    auto storeObserver1 = std::make_shared<ClientStoreObserver>();
+    RegisterStoreObserver(db, storeObserver1);
+    UnregisterStoreObserver(db, storeObserver1);
+    sqlite3_close_v2(db);
+}
+
+void DropLogicDeletedDataFuzz(std::string tableName, uint64_t num)
+{
+    sqlite3 *db = RdbTestUtils::CreateDataBase(g_dbDir + STOREID + DBSUFFIX);
+    InitLogicDeleteData(db, tableName, num);
+    DropLogicDeletedData(db, tableName, 0u);
+    sqlite3_close_v2(db);
+}
+
+void LockAndUnLockFuzz(std::string tableName, int count)
+{
+    sqlite3 *db = RdbTestUtils::CreateDataBase(g_dbDir + STOREID + DBSUFFIX);
+    InitDataStatus(tableName, count, db);
+    std::vector<std::vector<uint8_t>> hashKey;
+    GetHashKey(tableName, " 1=1 ", db, hashKey);
+    Lock(tableName, hashKey, db);
+    UnLock(tableName, hashKey, db);
+    sqlite3_close_v2(db);
+}
+
+void CombineClientFuzzTest(const uint8_t *data, size_t size)
+{
+    FuzzerData fuzzerData(data, size);
+    uint32_t len = fuzzerData.GetUInt32() % MOD;
+    std::string tableName = fuzzerData.GetString(len);
+    ClientObserverFuzz(tableName);
+    StoreObserverFuzz(tableName);
+    uint64_t num = fuzzerData.GetUInt64();
+    DropLogicDeletedDataFuzz(tableName, num);
+    int count = fuzzerData.GetInt();
+    LockAndUnLockFuzz(tableName, count);
+}
 }
 
 /* Fuzzer entry point */
@@ -218,6 +371,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     OHOS::Setup();
     OHOS::CombineTest(data, size);
+    OHOS::CombineClientFuzzTest(data, size);
     OHOS::TearDown();
     return 0;
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn b/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn
index f990cf6b7c3c1a9a0ad6bec7e6d42a9d1ace9185..02d0af3fd9b0a30a3681718711c4ffbbd67ae916 100644
--- a/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn
+++ b/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer/BUILD.gn
@@ -71,8 +71,13 @@ ohos_fuzztest("SyncFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "--coverage",
   ]
 
+  ldflags = [ "--coverage" ]
+
+  cflags_cc = [ "--coverage" ]
+
   fuzz_config_file = "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/test/fuzztest/sync_fuzzer"
 
   sources = distributeddb_src
diff --git a/kv_store/frameworks/libs/distributeddb/test/moduletest/src/distributeddb_nb_observer_test.cpp b/kv_store/frameworks/libs/distributeddb/test/moduletest/src/distributeddb_nb_observer_test.cpp
index c5f3b9d485d238634ded5fe5003f38cf368d2b32..2048716912052b0cb80583af46fb06e115a0e87c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/moduletest/src/distributeddb_nb_observer_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/moduletest/src/distributeddb_nb_observer_test.cpp
@@ -2219,4 +2219,4 @@ HWTEST_F(DistributeddbNbObserverTest, RekeyNbDb002, TestSize.Level1)
      */
     EXPECT_TRUE(g_nbObserverDelegate->Rekey(g_passwd1) == BUSY);
 }
-}
+}
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_common_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_common_test.cpp
index 02985cedaab37d390a91d04a8b69a8e49c5dfa54..9e2f6633cb1335a9588dbdc7a122170d7b359439 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_common_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_common_test.cpp
@@ -18,8 +18,13 @@
 #include "db_errno.h"
 #include "db_common.h"
 #include "distributeddb_data_generate_unit_test.h"
+#include "lock_status_observer.h"
 #include "log_print.h"
 #include "platform_specific.h"
+#include "task_queue.h"
+#include "time_tick_monitor.h"
+#include "user_change_monitor.h"
+#include "runtime_context_impl.h"
 
 using namespace testing::ext;
 using namespace DistributedDB;
@@ -571,4 +576,255 @@ HWTEST_F(DistributedDBCommonTest, PerformanceAnalysisTest001, TestSize.Level1)
     EXPECT_EQ(count1, count1);
     EXPECT_EQ(count1, threadCount);
 }
+
+/**
+ * @tc.name: PerformanceAnalysisTest002
+ * @tc.desc: Test PerformanceAnalysis interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, PerformanceAnalysisTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Get PerformanceAnalysis instance and call interfaces.
+     * @tc.expected: step1. success.
+     */
+    PerformanceAnalysis *performance = PerformanceAnalysis::GetInstance(5); // 5 is stepNum
+    ASSERT_NE(performance, nullptr);
+    performance->SetFileName("test");
+    performance->OpenPerformanceAnalysis();
+    performance->TimeRecordStart();
+    performance->TimeRecordEnd();
+
+    /**
+     * @tc.steps: step2. Call interfaces with the para is greater than stepNum.
+     * @tc.expected: step2. success;
+     */
+    performance->StepTimeRecordStart(RECORD_ACK_RECV_TO_USER_CALL_BACK);
+    performance->StepTimeRecordEnd(RECORD_ACK_RECV_TO_USER_CALL_BACK);
+    performance->ClosePerformanceAnalysis();
+    performance->GetStatistics();
+}
+
+/**
+ * @tc.name: UserChangeMonitorTest
+ * @tc.desc: Test UserChangeMonitor interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, UserChangeMonitorTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Start UserChangeMonitor.
+     * @tc.expected: step1. success.
+     */
+    UserChangeMonitor monitor;
+    EXPECT_EQ(monitor.Start(), E_OK);
+    monitor.NotifyUserChanged();
+
+    /**
+     * @tc.steps: step2. Call RegisterUserChangedListener with null action.
+     * @tc.expected: step2. -E_INVALID_ARGS.
+     */
+    int errCode = E_OK;
+    DistributedDB::UserChangedAction action = nullptr;
+    NotificationChain::Listener *ptr = monitor.RegisterUserChangedListener(action,
+        monitor.USER_ACTIVE_TO_NON_ACTIVE_EVENT, errCode);
+    ASSERT_EQ(ptr, nullptr);
+    EXPECT_EQ(errCode, -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step3. Second start UserChangeMonitor.
+     * @tc.expected: step3. success.
+     */
+    EXPECT_EQ(monitor.Start(), E_OK);
+    monitor.Stop();
+    monitor.NotifyUserChanged();
+}
+
+/**
+ * @tc.name: ValueObjectConstructorTest
+ * @tc.desc: Test ValueObjectTest.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, ValueObjectConstructorTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call the default constructor of ValueObject.
+     * @tc.expected: step1. success.
+     */
+    ValueObject valueObj;
+    EXPECT_EQ(valueObj.IsValid(), false);
+
+    /**
+     * @tc.steps: step2. Call constructor of ValueObject.
+     * @tc.expected: step2. success.
+     */
+    ValueObject valueObj1(valueObj);
+    EXPECT_EQ(valueObj1.IsValid(), false);
+    valueObj = valueObj1;
+}
+
+/**
+ * @tc.name: TimeTickMonitorTest
+ * @tc.desc: Test TimeTickMonitor interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, TimeTickMonitorTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Start TimeTickMonitor.
+     * @tc.expected: step1. success.
+     */
+    TimeTickMonitor monitor;
+    EXPECT_EQ(monitor.StartTimeTickMonitor(), E_OK);
+
+    /**
+     * @tc.steps: step2. Call RegisterTimeChangedLister with null para.
+     * @tc.expected: step2. -E_INVALID_ARGS.
+     */
+    int errCode = E_OK;
+    DistributedDB::UserChangedAction action = nullptr;
+    TimeFinalizeAction finalize = nullptr;
+    NotificationChain::Listener *ptr = monitor.RegisterTimeChangedLister(action, finalize, errCode);
+    ASSERT_EQ(ptr, nullptr);
+    EXPECT_EQ(errCode, -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step3. Call RegisterTimeChangedLister after Stop TimeTickMonitor.
+     * @tc.expected: step3. success;
+     */
+    EXPECT_EQ(monitor.StartTimeTickMonitor(), E_OK);
+    monitor.StopTimeTickMonitor();
+    monitor.NotifyTimeChange(0);
+
+    ptr = monitor.RegisterTimeChangedLister(action, finalize, errCode);
+    ASSERT_EQ(ptr, nullptr);
+    EXPECT_EQ(errCode, -E_NOT_INIT);
+}
+
+/**
+ * @tc.name: LockStatusObserverTest
+ * @tc.desc: Test LockStatusObserver interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, LockStatusObserverTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call RegisterLockStatusChangedLister with null para.
+     * @tc.expected: step1. -E_INVALID_ARGS.
+     */
+    LockStatusObserver observer;
+    EXPECT_EQ(observer.Start(), E_OK);
+
+    int errCode = E_OK;
+    DistributedDB::UserChangedAction action = nullptr;
+    NotificationChain::Listener *ptr = observer.RegisterLockStatusChangedLister(action, errCode);
+    ASSERT_EQ(ptr, nullptr);
+    EXPECT_EQ(errCode, -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step2. Call RegisterLockStatusChangedLister after stop observer.
+     * @tc.expected: step2. -E_NOT_INIT.
+     */
+    EXPECT_EQ(observer.Start(), E_OK);
+    observer.Stop();
+    observer.OnStatusChange(true);
+
+    ptr = observer.RegisterLockStatusChangedLister(action, errCode);
+    ASSERT_EQ(ptr, nullptr);
+    EXPECT_EQ(errCode, -E_NOT_INIT);
+}
+
+/**
+ * @tc.name: TaskQueueTest
+ * @tc.desc: Test TaskQueue interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, TaskQueueTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Create TaskQueue object whose para is true.
+     * @tc.expected: step1. Create success.
+     */
+    TaskQueue taskObj1(true);
+    const Task task1;
+    taskObj1.PutTask(task1);
+    EXPECT_EQ(taskObj1.IsEmptyAndUnlocked(), true);
+    EXPECT_EQ(taskObj1.CanGetTask(), false);
+
+    /**
+     * @tc.steps: step2. Create TaskQueue object whose para is false.
+     * @tc.expected: step2. Create success.
+     */
+    TaskQueue taskObj2(false);
+    EXPECT_EQ(taskObj2.IsEmptyAndUnlocked(), true);
+    EXPECT_EQ(taskObj2.CanGetTask(), false);
+}
+
+/**
+ * @tc.name: AbnormalTrackerTableTest
+ * @tc.desc: Test LockStatusObserver interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCommonTest, AbnormalTrackerTableTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call GetDiffIncCursorSql interface when TrackerTable is not init.
+     * @tc.expected: step1. return empty string.
+     */
+    TrackerTable trackerObj1;
+    std::string str = trackerObj1.GetDiffIncCursorSql("test1");
+    const std::string emptyStr = "";
+    EXPECT_TRUE(str.compare(0, str.length(), emptyStr) == 0);
+
+    /**
+     * @tc.steps: step2. Call GetCreateTempTriggerSql interface when para is NONE.
+     * @tc.expected: step2. return empty string.
+     */
+    std::string str1 = trackerObj1.GetCreateTempTriggerSql(TriggerMode::TriggerModeEnum::DELETE);
+    EXPECT_TRUE(str1.compare(0, str1.length(), emptyStr) != 0);
+    std::string str2 = trackerObj1.GetCreateTempTriggerSql(TriggerMode::TriggerModeEnum::NONE);
+    EXPECT_TRUE(str2.compare(0, str2.length(), emptyStr) == 0);
+
+    /**
+     * @tc.steps: step3. Call ReBuildTempTrigger interface when db is nullptr.
+     * @tc.expected: step3. return -E_INVALID_DB.
+     */
+    int ret = trackerObj1.ReBuildTempTrigger(nullptr, TriggerMode::TriggerModeEnum::NONE, nullptr);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+
+    /**
+     * @tc.steps: step4. Test IsChanging interface after setting schema info.
+     * @tc.expected: step4. return true.
+     */
+    const TrackerSchema schema = {
+        .tableName = "table1",
+        .extendColName = "extendCol1",
+        .trackerColNames = {"trackerCol1"},
+    };
+    trackerObj1.Init(schema);
+    EXPECT_EQ(trackerObj1.IsChanging(schema), false);
+
+    const std::set<std::string> trackerNames = {"trackerCol"};
+    trackerObj1.SetTrackerNames(trackerNames);
+    EXPECT_EQ(trackerObj1.IsChanging(schema), true);
+    const std::string colName = "col";
+    trackerObj1.SetExtendName(colName);
+    std::string str3 = trackerObj1.GetExtendName();
+    EXPECT_TRUE(str3.compare(0, str3.length(), colName) == 0);
+    EXPECT_EQ(trackerObj1.IsChanging(schema), true);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp
index d0bce30f17129bb45ea6c4c3d1c4665959c40dc1..0daa8bbfdbb6453dff77a3134965c272b9d0012a 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.cpp
@@ -90,4 +90,18 @@ void GenerateRecords(int recordNum, std::vector<Entry> &entries, std::vector<Key
         entry.value.clear();
     }
 }
+
+void GenerateNumberEntryVector(int entryNum, std::vector<Entry> &entries)
+{
+    if (entryNum <= 0) {
+        return;
+    }
+    for (int i = 1; i <= entryNum; i++) {
+        Entry entry;
+        std::string cntStr = std::to_string(i);
+        entry.key.assign(cntStr.begin(), cntStr.end());
+        entry.value.assign(cntStr.begin(), cntStr.end());
+        entries.push_back(entry);
+    }
+}
 } // namespace DistributedDBUnitTest
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.h
index a40130524806b8851ea6ba54f6e039c07dd648c9..6857e05caa89c6bad9ddb015aed8f5078cb6a3ca 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_data_generate_unit_test.h
@@ -113,6 +113,8 @@ void GenerateEntryVector(int entryVectorCount, int entryCount, std::vector<Distr
 
 void GenerateRecords(int recordNum, std::vector<DistributedDB::Entry> &entries, std::vector<DistributedDB::Key> &keys,
     int keySize = DEFAULT_NB_KEY_VALUE_SIZE, int valSize = DEFAULT_NB_KEY_VALUE_SIZE);
+
+void GenerateNumberEntryVector(int entryNum, std::vector<DistributedDB::Entry> &entries);
 } // namespace DistributedDBUnitTest
 
 #endif // DISTRIBUTEDDB_DATA_GENERATE_UNIT_H
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_parcel_unit_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_parcel_unit_test.cpp
index afc2b4b17118bce946cebee1ba6727b2ebc3711a..69b156b6850177f7add3d3b6f8706920b92cabe7 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_parcel_unit_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_parcel_unit_test.cpp
@@ -677,4 +677,79 @@ HWTEST_F(DistributedDBParcelTest, WriteString006, TestSize.Level2)
     delete []buf;
     EXPECT_TRUE(ret != EOK);
 }
+
+/**
+ * @tc.name: WriteBoolTest
+ * @tc.desc: write and read a bool.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBParcelTest, WriteBoolTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. create a bool, and write it into a buffer;
+     * @tc.expected: step1. write ok;
+     */
+    bool writeData = true;
+    uint32_t len = Parcel::GetBoolLen();
+    len = Parcel::GetEightByteAlign(len);
+    uint8_t *buf = new(nothrow) uint8_t[len];
+    ASSERT_NE(buf, nullptr);
+
+    Parcel writeParcel(buf, len);
+    EXPECT_EQ(writeParcel.WriteBool(writeData), EOK);
+
+    /**
+     * @tc.steps: step2. read the bool, the bool should same as written bool;
+     * @tc.expected: step2. read out readData same as written writeData;
+     */
+    bool readData;
+    Parcel readParcel(buf, len);
+    uint32_t readLen = readParcel.ReadBool(readData);
+    EXPECT_TRUE(readLen == Parcel::GetBoolLen());
+    EXPECT_TRUE(!readParcel.IsError());
+    EXPECT_TRUE(readData == writeData);
+    delete []buf;
+}
+
+/**
+ * @tc.name: ParcelErrTest
+ * @tc.desc: write and read a bool.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBParcelTest, ParcelErrTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. WriteDouble when Parcel para is null;
+     * @tc.expected: step1. return -E_PARSE_FAIL;
+     */
+    uint8_t *buf = nullptr;
+    Parcel parcel(buf, 0);
+    EXPECT_TRUE(parcel.IsError());
+
+    int ret = parcel.WriteDouble(0);
+    EXPECT_EQ(ret, -E_PARSE_FAIL);
+    double val;
+    uint32_t expectedVal = 0;
+    EXPECT_EQ(parcel.ReadDouble(val), expectedVal);
+
+    /**
+     * @tc.steps: step2. WriteBlob when para is null;
+     * @tc.expected: step2. return -E_INVALID_ARGS;
+     */
+    ret = parcel.WriteBlob(nullptr, 0);
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+    EXPECT_EQ(parcel.ReadBlob(nullptr, 0), expectedVal);
+
+    /**
+     * @tc.steps:step3. WriteDouble when Parcel para is null;
+     * @tc.expected: step3. return -E_PARSE_FAIL;
+     */
+    ret = parcel.WriteBlob("", 1);
+    EXPECT_EQ(ret, -E_PARSE_FAIL);
+    EXPECT_EQ(parcel.ReadBlob("", 1), expectedVal);
+}
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_relational_schema_object_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_relational_schema_object_test.cpp
index 52c140b14daba87ce9f21f4c9d8c606f7af238b4..4cc98103d235ca1790058be9b66ac43b29bc8e4c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_relational_schema_object_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_relational_schema_object_test.cpp
@@ -838,4 +838,110 @@ HWTEST_F(DistributedDBRelationalSchemaObjectTest, TableCompareTest002, TestSize.
     db = nullptr;
 }
 } // namespace
+
+/**
+ * @tc.name: FieldInfoCompareTest
+ * @tc.desc: Test field info compare
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBRelationalSchemaObjectTest, FieldInfoCompareTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. call CompareWithField when storageType is different
+     * @tc.expected: step1. return false.
+     */
+    FieldInfo field1;
+    field1.SetStorageType(StorageType::STORAGE_TYPE_INTEGER);
+    FieldInfo field2;
+    EXPECT_EQ(field2.CompareWithField(field1, true), false);
+
+    /**
+     * @tc.steps: step2. call CompareWithField when fieldName is different
+     * @tc.expected: step2. return false.
+     */
+    field1.SetFieldName("test1");
+    field1.SetFieldName("test2");
+    EXPECT_EQ(field2.CompareWithField(field1, true), false);
+}
+
+/**
+ * @tc.name: TableInfoInterfacesTest
+ * @tc.desc: Test TableInfo interfaces
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBRelationalSchemaObjectTest, TableInfoInterfacesTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. GetFieldName with empty TableInfo class
+     * @tc.expected: step1. return empty string.
+     */
+    TableInfo table1;
+    std::string str1 = table1.GetFieldName(0);
+    const std::string expectStr1 = "";
+    EXPECT_TRUE(str1.compare(0, expectStr1.length(), expectStr1) == 0);
+    table1.ToTableInfoString("");
+
+    /**
+     * @tc.steps: step2. Set and get tableId.
+     * @tc.expected: step2. success.
+     */
+    int inputId = 1;
+    table1.SetTableId(inputId);
+    int outputId = table1.GetTableId();
+    EXPECT_EQ(outputId, inputId);
+}
+
+/**
+ * @tc.name: SchemaTableCompareTest
+ * @tc.desc: Test LiteSchemaTable Compare
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBRelationalSchemaObjectTest, SchemaTableCompareTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Set key index of SetPrimaryKey to an invalid value
+     * @tc.expected: step1. fieldName vector is null.
+     */
+    TableInfo table1;
+    int keyIndex = -1;
+    table1.SetPrimaryKey("test", keyIndex);
+    CompositeFields vec = table1.GetIdentifyKey();
+    uint32_t expectedVal = 0;
+    EXPECT_EQ(vec.size(), expectedVal);
+
+    /**
+     * @tc.steps: step2. Compare table when fieldName of SetPrimaryKey is set to'rowid'
+     * @tc.expected: step2. compare return -E_RELATIONAL_TABLE_INCOMPATIBLE.
+     */
+    const std::vector<CompositeFields> uniqueDefine = {{"test0", "test1"}};
+    table1.SetUniqueDefine(uniqueDefine);
+    const std::map<int, FieldName> keyName1 = {{0, "rowid"}};
+    table1.SetPrimaryKey(keyName1);
+
+    vec = table1.GetIdentifyKey();
+    EXPECT_EQ(vec.size(), uniqueDefine[0].size());
+    int ret = table1.CompareWithLiteSchemaTable(table1);
+    EXPECT_EQ(ret, -E_RELATIONAL_TABLE_INCOMPATIBLE);
+
+    /**
+     * @tc.steps: step3. Compare table when fieldName of SetPrimaryKey is not set to "rowid".
+     * @tc.expected: step3. compare return E_OK.
+     */
+    FieldInfo field1;
+    table1.AddField(field1);
+    const std::map<int, FieldName> keyName2 = {{0, "test0"}, {1, "test1"}};
+    table1.SetPrimaryKey(keyName2);
+
+    vec = table1.GetIdentifyKey();
+    EXPECT_EQ(vec.size(), keyName2.size());
+    field1.SetFieldName("test1");
+    ret = table1.CompareWithLiteSchemaTable(table1);
+    EXPECT_EQ(ret, E_OK);
+}
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_object_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_object_test.cpp
index f7520db5a0767d6873732590094c716ca28db1e1..b492092fc69ae701f860d3620f4615b71741b97d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_object_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_object_test.cpp
@@ -1087,4 +1087,88 @@ HWTEST_F(DistributedDBSchemaObjectTest, ValueLackField002, TestSize.Level1)
         theValue), E_OK);
     EXPECT_EQ(theValue.stringValue == std::string("3.1415"), true);
 }
+
+/**
+ * @tc.name: SchemaObjectErrTest
+ * @tc.desc: Parse Schema Object err scene
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call GetExtractFuncName interface with NONE SchemaType.
+     * @tc.expected: step1. Get non-JSON string.
+     */
+    SchemaObject schema;
+    std::string str1 = schema.GetExtractFuncName(SchemaType::NONE);
+    const std::string expectStr1 = "flatbuffer_extract_by_path";
+    EXPECT_TRUE(str1.compare(0, expectStr1.length(), expectStr1) == 0);
+
+    /**
+     * @tc.steps: step2. Call interfaces with empty FieldPath.
+     * @tc.expected: step2. return -E_INVALID_ARGS.
+     */
+    FieldPath inFieldpath1 = {};
+    std::string str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath1, FieldType::LEAF_FIELD_BOOL, 0, "");
+    const std::string expectStr2 = "";
+    EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
+    FieldType schemaFieldType = FieldType::LEAF_FIELD_BOOL;
+    int ret = schema.CheckQueryableAndGetFieldType(inFieldpath1, schemaFieldType);
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step3. Call interfaces with LEAF_FIELD_NULL FieldType.
+     * @tc.expected: step3. return -E_NOT_FOUND.
+     */
+    FieldPath inFieldpath2 = {"test"};
+    str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath2, FieldType::LEAF_FIELD_NULL, 0, "");
+    EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
+    ret = schema.CheckQueryableAndGetFieldType(inFieldpath2, schemaFieldType);
+    EXPECT_EQ(ret, -E_NOT_FOUND);
+}
+
+/**
+ * @tc.name: SchemaObjectErrTest002
+ * @tc.desc: Parse Schema Object err scene
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call interfaces without Schema Parse.
+     * @tc.expected: step1. return -E_NOT_PERMIT.
+     */
+    SchemaObject schema;
+    IndexDifference indexDiffer;
+    int ret = schema.CompareAgainstSchemaObject(schema, indexDiffer);
+    EXPECT_EQ(ret, -E_NOT_PERMIT);
+    ValueObject inValue;
+    ret = schema.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, inValue);
+    EXPECT_EQ(ret, -E_NOT_PERMIT);
+
+    const Value val = {0};
+    ret = schema.VerifyValue(ValueSource::FROM_LOCAL, val);
+    EXPECT_EQ(ret, -E_NOT_PERMIT);
+
+    /**
+     * @tc.steps: step2. Call VerifyValue interface when RawValue first para is nullptr.
+     * @tc.expected: step2. return -E_INVALID_ARGS.
+     */
+    ret = schema.VerifyValue(ValueSource::FROM_LOCAL, RawValue{nullptr, 0});
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step3. Parse twice same schema.
+     * @tc.expected: step3. second return -E_NOT_PERMIT.
+     */
+    SchemaObject schema1;
+    int stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
+    EXPECT_EQ(stepOne, E_OK);
+    stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
+    EXPECT_EQ(stepOne, -E_NOT_PERMIT);
+}
 #endif
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_unit_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_unit_test.cpp
index 8f6a58261172e60d48abd2c5cf24efba22edff52..8cb1e704bdeb953c5b9081174e52a4652dd45b50 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_unit_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_schema_unit_test.cpp
@@ -510,4 +510,40 @@ HWTEST_F(DistributedDBSchemalTest, ParseAndCheckFieldPath002, TestSize.Level1)
         FieldPath ans;
         EXPECT_EQ(SchemaUtils::ParseAndCheckFieldPath(iter, ans), -E_SCHEMA_PARSE_FAIL);
     }
+}
+
+/**
+ * @tc.name: ParseTrackerSchemaAndName
+ * @tc.desc: Correctly identify illegal shema index fields
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBSchemalTest, ParseTrackerSchemaAndName, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Trans TrackerSchema to Lower.
+     * @tc.expected: step1. Trans success.
+     */
+    const TrackerSchema srcSchema = {"Test", "Col", {"Col1", "Col2"}};
+    TrackerSchema destSchema;
+    SchemaUtils::TransTrackerSchemaToLower(srcSchema, destSchema);
+    TrackerSchema expectedSchema = {"test", "col", {"col1", "col2"}};
+    EXPECT_TRUE(destSchema.tableName.compare(0, expectedSchema.tableName.length(), expectedSchema.tableName) == 0);
+    EXPECT_TRUE(
+        destSchema.extendColName.compare(0, expectedSchema.extendColName.length(), expectedSchema.extendColName) == 0);
+
+    /**
+     * @tc.steps: step2. Strip space from name.
+     * @tc.expected: step2. Success.
+     */
+    const std::string inputName1 = "test1";
+    std::string expectedName1 = "test1";
+    std::string outputName1 = SchemaUtils::StripNameSpace(inputName1);
+    EXPECT_TRUE(outputName1.compare(0, expectedName1.length(), expectedName1) == 0);
+
+    const std::string inputName2 = "test1.test2";
+    std::string expectedName2 = "test2";
+    std::string outputName2 = SchemaUtils::StripNameSpace(inputName2);
+    EXPECT_TRUE(outputName2.compare(0, expectedName2.length(), expectedName2) == 0);
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
index 8ac8962b55f715136cf8c78deb2659d1b914068f..b28f832f3a6a87a7d8dc4b4fadfb3d78dbe30158 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.cpp
@@ -990,6 +990,43 @@ DBStatus DistributedDBToolsUnitTest::SyncTest(KvStoreNbDelegate* delegate,
     return callStatus;
 }
 
+bool CheckStatusAndSyncProcess(DBStatus status, std::map<std::string, DeviceSyncProcess> &syncProcessMap)
+{
+    if (status != OK) {
+        return true;
+    }
+    if (syncProcessMap.empty()) {
+        return false;
+    }
+    for (const auto &entry : syncProcessMap) {
+        if (entry.second.process < ProcessStatus::FINISHED) {
+            return false;
+        }
+    }
+    return true;
+}
+
+DBStatus DistributedDBToolsUnitTest::SyncTest(KvStoreNbDelegate *delegate, DeviceSyncOption option,
+    std::map<std::string, DeviceSyncProcess> &syncProcessMap)
+{
+    syncProcessMap.clear();
+    DeviceSyncProcessCallback onProcess =
+        [&syncProcessMap, this](const std::map<std::string, DeviceSyncProcess> &processMap) {
+            syncProcessMap = processMap;
+            std::unique_lock<std::mutex> innerLock(this->syncLock_);
+            this->syncCondVar_.notify_one();
+        };
+    DBStatus status = delegate->Sync(option, onProcess);
+
+    if (!option.isWait) {
+        std::unique_lock<std::mutex> lock(this->syncLock_);
+        this->syncCondVar_.wait(lock, [status, &syncProcessMap]() {
+            return CheckStatusAndSyncProcess(status, syncProcessMap);
+        });
+    }
+    return status;
+}
+
 void KvStoreCorruptInfo::CorruptCallBack(const std::string &appId, const std::string &userId,
     const std::string &storeId)
 {
@@ -1378,6 +1415,7 @@ DistributedDB::DBStatus RelationalTestUtils::InsertCloudRecord(int64_t begin, in
             asset.name = assetNameBegin + "_" + std::to_string(j);
             asset.status = AssetStatus::INSERT;
             asset.hash = "DEC";
+            asset.assetId = std::to_string(j);
             assets.push_back(asset);
         }
         data.insert_or_assign("assets", assets);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
index 08b34de5c0dcbb6d5d408894ba3261f6298fbcd1..cc2f3bd8b5d2887bbea38d60d70f4fb05ab57666 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/common/distributeddb_tools_unit_test.h
@@ -158,6 +158,10 @@ public:
         const std::vector<std::string>& devices, DistributedDB::SyncMode mode,
         std::map<std::string, DistributedDB::DBStatus>& statuses, const DistributedDB::Query &query);
 
+    DistributedDB::DBStatus SyncTest(DistributedDB::KvStoreNbDelegate *delegate,
+        DistributedDB::DeviceSyncOption option,
+        std::map<std::string, DistributedDB::DeviceSyncProcess> &syncProcessMap);
+        
     static void GetRandomKeyValue(std::vector<uint8_t> &value, uint32_t defaultSize = 0);
 
     static bool IsValueEqual(const DistributedDB::Value &read, const DistributedDB::Value &origin);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_deep_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_deep_test.cpp
index 347bc4a82ff9bdb64c31929c774485ba6455fab4..03d0a988d0bd41c49503263292d9d9472dd530b1 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_deep_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_deep_test.cpp
@@ -541,7 +541,11 @@ HWTEST_F(DistributedDBCommunicatorDeepTest, Fragment004, TestSize.Level2)
     std::this_thread::sleep_for(std::chrono::seconds(1)); // Wait 1s to make sure send done
     g_envDeviceA.adapterHandle->SimulateSendRetry(DEVICE_NAME_B);
     g_envDeviceA.adapterHandle->SimulateSendRetryClear(DEVICE_NAME_B);
-    std::this_thread::sleep_for(std::chrono::seconds(5)); // Wait 5s to make sure send done
+    int reTryTimes = 5;
+    while (recvMsgForBB == nullptr && reTryTimes > 0) {
+        std::this_thread::sleep_for(std::chrono::seconds(3));
+        reTryTimes--;
+    }
     ASSERT_NE(recvMsgForBB, nullptr);
     ASSERT_EQ(recvMsgForBB->GetMessageId(), REGED_GIANT_MSG_ID);
     /**
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
index a1f514a67e047b9964ab8a8a5aea726b7a14312c..1d8f1aac9136c8111a28f6851fc8a57f54674a71 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/communicator/distributeddb_communicator_test.cpp
@@ -425,7 +425,11 @@ void TestRemoteRestart()
      * @tc.expected: step6. communicatorE has callback;
      */
     AdapterStub::ConnectAdapterStub(envDeviceD.adapterHandle, envDeviceE.adapterHandle);
-    std::this_thread::sleep_for(std::chrono::seconds(1));
+    int reTryTimes = 5;
+    while (onlineForEE.onlineDevices.size() != 1 && reTryTimes > 0) {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        reTryTimes--;
+    }
     EXPECT_EQ(onlineForEE.onlineDevices.size(), static_cast<size_t>(1));
     // Clean up and disconnect
     envDeviceD.commAggrHandle->ReleaseCommunicator(commDD);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_reference_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_reference_test.cpp
index c0a36439f08dd7f8f579424a2d3a1ea2b6a3ceea..7448fdf79ed6eb88e1afea5e8eda77842460e4cb 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_reference_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_reference_test.cpp
@@ -415,7 +415,7 @@ namespace {
             RelationalSchemaObject obj;
             EXPECT_EQ(obj.ParseFromSchemaString(schemaStr), E_OK);
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 1);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_ext_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_ext_test.cpp
index 54418f093910e5534599e7e453fe634077353abc..26cbe1fde4dacbe8010731aff2c59b95fe85bf97 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_ext_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_ext_test.cpp
@@ -193,7 +193,7 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, GetRawSysTimeTest001, Te
     EXPECT_EQ(errCode, E_OK);
     errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [curTime] (sqlite3_stmt *stmt) {
         EXPECT_GT(static_cast<uint64_t>(sqlite3_column_int64(stmt, 0)), curTime);
-        return OK;
+        return E_OK;
     });
     EXPECT_EQ(errCode, SQLITE_OK);
     EXPECT_EQ(sqlite3_close_v2(db), E_OK);
@@ -290,7 +290,7 @@ void InsertTriggerTest(DistributedDB::TableSyncType tableSyncType)
             EXPECT_EQ(sqlite3_column_int(stmt, 5), 2); // 5 is column index flag == 2
         }
         resultCount++;
-        return OK;
+        return E_OK;
     });
     EXPECT_EQ(errCode, SQLITE_OK);
     EXPECT_EQ(resultCount, 1);
@@ -374,7 +374,7 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, InsertTriggerTest003, Te
         EXPECT_EQ(SQLiteUtils::GetColumnTextValue(stmt, 4, gidStr), E_OK); // 4 is column index
         EXPECT_EQ(gid, gidStr);
         resultCount++;
-        return OK;
+        return E_OK;
     });
     EXPECT_EQ(errCode, SQLITE_OK);
     EXPECT_EQ(resultCount, 1);
@@ -441,7 +441,7 @@ void UpdateTriggerTest(bool primaryKeyIsRowId)
         EXPECT_TRUE(static_cast<int64_t>(curTime - timestamp) < diff);
 
         resultCount++;
-        return OK;
+        return E_OK;
     });
     EXPECT_EQ(errCode, SQLITE_OK);
     EXPECT_EQ(resultCount, 1);
@@ -533,7 +533,7 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, DeleteTriggerTest001, Te
         EXPECT_TRUE(static_cast<int64_t>(curTime - timestamp) < diff);
 
         resultCount++;
-        return OK;
+        return E_OK;
     });
     EXPECT_EQ(errCode, SQLITE_OK);
     EXPECT_EQ(resultCount, 1);
@@ -1292,20 +1292,20 @@ void InitDataStatus(const std::string &tableName, int count, sqlite3 *db)
 {
     int type = 4; // the num of different status
     for (int i = 1; i <= type * count; i++) {
-        std::string sql = "insert into " + tableName + " VALUES(" + std::to_string(i) + ", 'zhangsan" +
+        std::string sql = "INSERT INTO " + tableName + " VALUES(" + std::to_string(i) + ", 'zhangsan" +
             std::to_string(i) + "');";
         EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), E_OK);
     }
     std::string countStr = std::to_string(count);
-    std::string sql = "update " + DBCommon::GetLogTableName(tableName) + " SET status=(case when data_key<=" +
-        countStr + " then 0 when data_key>" + countStr + " and data_key<=2*" + countStr + " then 1 when data_key>2*" +
-        countStr + " and data_key<=3*" + countStr + " then 2 else 3 end)";
+    std::string sql = "UPDATE " + DBCommon::GetLogTableName(tableName) + " SET status=(CASE WHEN data_key<=" +
+        countStr + " THEN 0 WHEN data_key>" + countStr + " AND data_key<=2*" + countStr + " THEN 1 WHEN data_key>2*" +
+        countStr + " AND data_key<=3*" + countStr + " THEN 2 ELSE 3 END)";
     EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), E_OK);
 }
 
 void CheckDataStatus(const std::string &tableName, const std::string &condition, sqlite3 *db, int64_t expect)
 {
-    std::string sql = "select count(1) from " + DBCommon::GetLogTableName(tableName) + " where " + condition;
+    std::string sql = "SELECT count(1) FROM " + DBCommon::GetLogTableName(tableName) + " WHERE " + condition;
     sqlite3_stmt *stmt = nullptr;
     EXPECT_EQ(SQLiteUtils::GetStatement(db, sql, stmt), E_OK);
     while (SQLiteUtils::StepWithRetry(stmt) == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
@@ -1517,7 +1517,7 @@ void CheckChangedData(int num, int times = 0, int offset = 0)
         }
         for (size_t i = 1; i <= g_changedData[num].primaryData[ChangeType::OP_DELETE].size(); i++) {
             EXPECT_EQ(std::get<int64_t>(g_changedData[num].primaryData[ChangeType::OP_DELETE][i - 1][0]),
-                static_cast<int64_t>(i + offset));
+                static_cast<int64_t>(i + offset + 5)); // 5 is offset
         }
         return;
     }
@@ -1720,4 +1720,110 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, RegisterStoreObserverTes
     EXPECT_EQ(RegisterStoreObserver(db, storeObserver), OK);
     EXPECT_EQ(RegisterStoreObserver(db, storeObserver), INVALID_ARGS);
 }
-}
\ No newline at end of file
+
+/**
+ * @tc.name: AbnormalDelegateImplTest001
+ * @tc.desc: Test delegateImpl interface after delegate is closed
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, AbnormalDelegateImplTest001, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. create db and open store.
+     * @tc.expected: step1. return ok.
+     */
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+    EXPECT_EQ(sqlite3_close_v2(db), E_OK);
+    RelationalStoreDelegate *delegate = nullptr;
+    DBStatus status = g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID, {}, delegate);
+    EXPECT_EQ(status, OK);
+    ASSERT_NE(delegate, nullptr);
+
+   /**
+     * @tc.steps: step2. close delegate.
+     * @tc.expected: step2. return ok.
+     */
+    auto delegateImpl = static_cast<RelationalStoreDelegateImpl *>(delegate);
+    status = delegateImpl->Close();
+    EXPECT_EQ(status, OK);
+
+    /**
+     * @tc.steps: step3. test DelegateImpl interface after delegate is closed.
+     * @tc.expected: step3. return DB_ERROR.
+     */
+    const RemoteCondition condition;
+    std::shared_ptr<ResultSet> result = nullptr;
+    DBStatus ret = delegateImpl->RemoteQuery("", condition, 0, result);
+    EXPECT_EQ(ret, DB_ERROR);
+    EXPECT_EQ(delegateImpl->RemoveDeviceData(), DB_ERROR);
+
+    StoreObserver observer;
+    EXPECT_EQ(delegateImpl->RegisterObserver(&observer), DB_ERROR);
+    EXPECT_EQ(delegateImpl->UnRegisterObserver(&observer), DB_ERROR);
+    DistributedDB::SqlCondition sqlCondition;
+    std::vector<VBucket> records = {};
+    EXPECT_EQ(delegateImpl->ExecuteSql(sqlCondition, records), DB_ERROR);
+    EXPECT_EQ(delegateImpl->UpsertData("", records, RecordStatus::WAIT_COMPENSATED_SYNC), DB_ERROR);
+    const CloudSyncConfig config;
+    EXPECT_EQ(delegateImpl->SetCloudSyncConfig(config), DB_ERROR);
+
+    /**
+     * @tc.steps: step4. close store.
+     * @tc.expected: step4. return ok.
+     */
+    EXPECT_EQ(g_mgr.CloseStore(delegate), OK);
+    delegate = nullptr;
+}
+
+/**
+ * @tc.name: AbnormalDelegateImplTest002
+ * @tc.desc: Test delegate interface after delegate is closed
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCloudInterfacesRelationalExtTest, AbnormalDelegateImplTest002, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. create db and open store.
+     * @tc.expected: step1. return ok.
+     */
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+    EXPECT_EQ(sqlite3_close_v2(db), E_OK);
+    RelationalStoreDelegate *delegate = nullptr;
+    DBStatus status = g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID, {}, delegate);
+    EXPECT_EQ(status, OK);
+    ASSERT_NE(delegate, nullptr);
+
+    /**
+     * @tc.steps: step2. test DelegateImpl interface when para is err.
+     * @tc.expected: step2. return INVALID_ARGS or NOT_FOUND.
+     */
+    auto delegateImpl = static_cast<RelationalStoreDelegateImpl *>(delegate);
+    const CloudSyncConfig config;
+    EXPECT_EQ(delegateImpl->SetCloudSyncConfig(config), OK);
+
+    DistributedDB::SqlCondition sqlCondition;
+    std::vector<VBucket> records = {};
+    EXPECT_EQ(delegateImpl->ExecuteSql(sqlCondition, records), INVALID_ARGS);
+    EXPECT_EQ(delegateImpl->UpsertData("", records, RecordStatus::WAIT_COMPENSATED_SYNC), INVALID_ARGS);
+    EXPECT_EQ(delegateImpl->CleanTrackerData("", 0), INVALID_ARGS);
+    TrackerSchema schema;
+    EXPECT_EQ(delegateImpl->SetTrackerTable(schema), INVALID_ARGS);
+    schema = {.tableName = "test", .extendColName = "", .trackerColNames = {}};
+    EXPECT_EQ(delegateImpl->SetTrackerTable(schema), NOT_FOUND);
+
+    /**
+     * @tc.steps: step3. close store.
+     * @tc.expected: step3. return ok.
+     */
+    EXPECT_EQ(g_mgr.CloseStore(delegate), OK);
+    delegate = nullptr;
+}
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_remove_device_data_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_remove_device_data_test.cpp
index ab14085e5d7d448eb4c76d18de8f1f5bd70b2d35..08cbc88c0b967e265d086b59e445b4e7b994cbac 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_remove_device_data_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_relational_remove_device_data_test.cpp
@@ -242,6 +242,21 @@ namespace {
             ") , worker2[primary key]:[%" PRId64 "- %" PRId64")", begin, count, begin, count);
     }
 
+    void UpdateUserTableRecord(sqlite3 *&db, int64_t begin, int64_t count)
+    {
+        for (size_t i = 0; i < g_tables.size(); i++) {
+            string updateAge = "UPDATE " + g_tables[i] + " SET height = 111.11 where " + g_tablesPKey[i] + " in (";
+            for (int64_t j = begin; j < count; ++j) {
+                updateAge += "'" + g_prefix[i] + std::to_string(j) + "',";
+            }
+            updateAge.pop_back();
+            updateAge += ");";
+            ASSERT_EQ(RelationalTestUtils::ExecSql(db, updateAge), SQLITE_OK);
+        }
+        LOGD("update local record worker1[primary key]:[local%" PRId64 " - local%" PRId64
+            ") , worker2[primary key]:[%" PRId64 "- %" PRId64")", begin, count, begin, count);
+    }
+
     void DeleteCloudTableRecordByGid(int64_t begin, int64_t count)
     {
         for (int64_t i = begin; i < begin + count; ++i) {
@@ -314,8 +329,8 @@ namespace {
     {
         int i = 0;
         for (const auto &tableName: tableList) {
-            std::string sql = "select count(*) from " + DBCommon::GetLogTableName(tableName) +
-                " where device = 'cloud'" + " and cloud_gid is not null and cloud_gid != '' and flag & 0x2 = 0;";
+            std::string sql = "select count(*) from " + DBCommon::GetLogTableName(tableName) +" where device = 'cloud'";
+            sql += " and cloud_gid is not null and cloud_gid != '' and (flag & 0x2 = 0 or flag & 0x20 = 0);";
             EXPECT_EQ(sqlite3_exec(db, sql.c_str(), QueryCountCallback,
                 reinterpret_cast<void *>(countList[i]), nullptr), SQLITE_OK);
             i++;
@@ -333,6 +348,18 @@ namespace {
         }
     }
 
+    void CheckLogoutLogCount(sqlite3 *&db, const std::vector<std::string> &tableList, const std::vector<int> &countList)
+    {
+        int i = 0;
+        for (const auto &tableName: tableList) {
+            std::string sql = "select count(*) from " + DBCommon::GetLogTableName(tableName) +
+                " where flag & 0x800 = 0x800";
+            EXPECT_EQ(sqlite3_exec(db, sql.c_str(), QueryCountCallback,
+                reinterpret_cast<void *>(countList[i]), nullptr), SQLITE_OK);
+            i++;
+        }
+    }
+
     void CheckCleanLogNum(sqlite3 *&db, const std::vector<std::string> tableList, int count)
     {
         for (const auto &tableName: tableList) {
@@ -345,12 +372,23 @@ namespace {
             EXPECT_EQ(sqlite3_exec(db, sql2.c_str(), QueryCountCallback,
                 reinterpret_cast<void *>(count), nullptr), SQLITE_OK);
             std::string sql3 = "select count(*) from " + DBCommon::GetLogTableName(tableName) +
-                " where flag & 0x02 = 0;";
+                " where (flag & 0x02 = 0 or flag & 0x20 = 0);";
             EXPECT_EQ(sqlite3_exec(db, sql3.c_str(), QueryCountCallback,
                 reinterpret_cast<void *>(count), nullptr), SQLITE_OK);
         }
     }
 
+    void CheckCleanDataNum(sqlite3 *&db, const std::vector<std::string> &tableList, const std::vector<int> &countList)
+    {
+        int i = 0;
+        for (const auto &tableName: tableList) {
+            std::string sql = "select count(*) from " + tableName;
+            EXPECT_EQ(sqlite3_exec(db, sql.c_str(), QueryCountCallback,
+                reinterpret_cast<void *>(countList[i]), nullptr), SQLITE_OK);
+            i++;
+        }
+    }
+
     void CheckCleanDataAndLogNum(sqlite3 *&db, const std::vector<std::string> tableList, int count,
         std::vector<int> localNum)
     {
@@ -365,7 +403,7 @@ namespace {
             EXPECT_EQ(sqlite3_exec(db, sql2.c_str(), QueryCountCallback,
                 reinterpret_cast<void *>(count), nullptr), SQLITE_OK);
             std::string sql3 = "select count(*) from " + DBCommon::GetLogTableName(tableName) +
-                " where flag & 0x02 = 0;";
+                " where (flag & 0x02 = 0 or flag & 0x20 = 0);";
             EXPECT_EQ(sqlite3_exec(db, sql3.c_str(), QueryCountCallback,
                 reinterpret_cast<void *>(count), nullptr), SQLITE_OK);
             std::string local_sql = "select count(*) from " + tableName +";";
@@ -493,6 +531,7 @@ namespace {
 
     void CloseDb()
     {
+        g_delegate->UnRegisterObserver(g_observer);
         delete g_observer;
         g_virtualCloudDb = nullptr;
         if (g_delegate != nullptr) {
@@ -1086,5 +1125,235 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudD
     }
     CloseDb();
 }
+
+/*
+ * @tc.name: CleanCloudDataTest012
+ * @tc.desc: Test modify data will not be deleted before upload to cloud when remove device data.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: wangxiangdong
+ */
+HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudDataTest012, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. make data: 20 records on local
+     */
+    int64_t paddingSize = 20;
+    int localCount = 20;
+    InsertUserTableRecord(db, 0, localCount, paddingSize, false);
+    /**
+     * @tc.steps: step2. call Sync with cloud merge strategy, and after that, local will has 20 records.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    /**
+     * @tc.steps: step3. modify local data
+     * @tc.expected: OK.
+     */
+    InsertUserTableRecord(db, 20, localCount, paddingSize, false);
+    UpdateUserTableRecord(db, 5, 10);
+    DeleteUserTableRecord(db, 10, 15);
+    /**
+     * @tc.steps: step4. check cloud record data and remove device data.
+     * @tc.expected: OK.
+     */
+    CheckCloudRecordNum(db, g_tables, {0, 0});
+    std::string device;
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {25, 25});
+    CheckLocalLogCount(db, g_tables, {30, 30});
+    /**
+     * @tc.steps: step5. do sync again and remove device data, then check local data and log.
+     * @tc.expected: OK.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {0, 0});
+    CheckLocalLogCount(db, g_tables, {0, 0});
+    CloseDb();
+}
+
+/*
+ * @tc.name: CleanCloudDataTest013
+ * @tc.desc: Test modify data will not be deleted before upload to cloud when remove device data when set logicDelete.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: wangxiangdong
+ */
+HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudDataTest013, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. Set data is logicDelete
+     */
+    bool logicDelete = true;
+    auto data = static_cast<PragmaData>(&logicDelete);
+    g_delegate->Pragma(LOGIC_DELETE_SYNC_DATA, data);
+    /**
+     * @tc.steps: step2. make data: 20 records on local
+     */
+    int64_t paddingSize = 20;
+    int localCount = 20;
+    InsertUserTableRecord(db, 0, localCount, paddingSize, false);
+    /**
+     * @tc.steps: step3. call Sync with cloud merge strategy, and after that, local will has 20 records.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    /**
+     * @tc.steps: step4. modify local data
+     * @tc.expected: OK.
+     */
+    InsertUserTableRecord(db, 20, localCount, paddingSize, false);
+    UpdateUserTableRecord(db, 5, 10);
+    DeleteUserTableRecord(db, 10, 15);
+    /**
+     * @tc.steps: step5. check cloud record data and remove device data.
+     * @tc.expected: OK.
+     */
+    CheckCloudRecordNum(db, g_tables, {0, 0});
+    std::string device;
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {35, 35});
+    CheckLocalLogCount(db, g_tables, {40, 40});
+    CheckLogoutLogCount(db, g_tables, {10, 10});
+    /**
+     * @tc.steps: step6. do sync again and remove device data, then check local data and log.
+     * @tc.expected: OK.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {40, 35});
+    CheckLocalLogCount(db, g_tables, {40, 40});
+    CheckLogoutLogCount(db, g_tables, {15, 10});
+    CloseDb();
+}
+
+/*
+ * @tc.name: CleanCloudDataTest014
+ * @tc.desc: Test when remove device data at flag only mode.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: wangxiangdong
+**/
+HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudDataTest014, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. make data: 20 records on local
+     */
+    int64_t paddingSize = 20;
+    int localCount = 20;
+    InsertUserTableRecord(db, 0, localCount, paddingSize, false);
+    /**
+     * @tc.steps: step2. call Sync with cloud merge strategy, and after that, local will has 20 records.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    /**
+     * @tc.steps: step3. modify local data
+     * @tc.expected: OK.
+     */
+    InsertUserTableRecord(db, 20, localCount, paddingSize, false);
+    UpdateUserTableRecord(db, 5, 10);
+    DeleteUserTableRecord(db, 10, 15);
+    /**
+     * @tc.steps: step4. check cloud record data and remove device data.
+     * @tc.expected: OK.
+     */
+    CheckCloudRecordNum(db, g_tables, {0, 0});
+    std::string device;
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_ONLY), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {35, 35});
+    CheckLogoutLogCount(db, g_tables, {40, 40});
+    CloseDb();
+}
+
+/*
+ * @tc.name: CleanCloudDataTest015
+ * @tc.desc: Test get schema from db is ok when local has not been set.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: wangxiangdong
+**/
+HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudDataTest015, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. Set data is logicDelete
+     */
+    bool logicDelete = true;
+    auto data = static_cast<PragmaData>(&logicDelete);
+    g_delegate->Pragma(LOGIC_DELETE_SYNC_DATA, data);
+    /**
+     * @tc.steps: step2. make data: 10 records on local
+     */
+    int64_t paddingSize = 20;
+    int localCount = 10;
+    InsertUserTableRecord(db, 0, localCount, paddingSize, false);
+    /**
+     * @tc.steps: step3. call Sync with cloud merge strategy, and after that, local will has 20 records.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    /**
+     * @tc.steps: step4. remove and check
+     * @tc.expected: OK.
+     */
+    CheckCloudRecordNum(db, g_tables, {0, 0});
+    std::string device;
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
+    CheckCleanDataNum(db, g_tables, {10, 10});
+    CheckLocalLogCount(db, g_tables, {10, 10});
+    CheckLogoutLogCount(db, g_tables, {10, 10});
+    CloseDb();
+}
+
+/*
+ * @tc.name: CleanCloudDataTest022
+ * @tc.desc: Test conflict, not dound, exis errCode will deal.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: wangxiangdong
+ */
+HWTEST_F(DistributedDBCloudInterfacesRelationalRemoveDeviceDataTest, CleanCloudDataTest022, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. Set data is logicDelete
+     */
+    bool logicDelete = true;
+    auto data = static_cast<PragmaData>(&logicDelete);
+    g_delegate->Pragma(LOGIC_DELETE_SYNC_DATA, data);
+    /**
+     * @tc.steps: step2. make data: 20 records on local.
+     */
+    int64_t paddingSize = 20;
+    int localCount = 20;
+    InsertUserTableRecord(db, 0, localCount, paddingSize, false);
+    /**
+     * @tc.steps: step3. make 2-5th data errCode.
+     */
+    int upIdx = 0;
+    g_virtualCloudDb->ForkUpload([&upIdx](const std::string &tableName, VBucket &extend) {
+        LOGD("cloud db upload index:%d", ++upIdx);
+        if (upIdx == 2) {
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_ALREADY_EXISTED);
+        }
+        if (upIdx == 3) {
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_EXIST_CONFLICT);
+        }
+        if (upIdx == 4) {
+            // CLOUD_RECORD_NOT_FOUND means cloud and terminal is consitenct
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_NOT_FOUND);
+        }
+        if (upIdx == 5) {
+            // CLOUD_RECORD_NOT_FOUND means no error
+            extend[CloudDbConstant::ERROR_FIELD] = std::string("x");
+        }
+    });
+    /*
+     * @tc.steps: step4. call Sync, and check consitency.
+     */
+    CloudDBSyncUtilsTest::callSync(g_tables, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, g_delegate);
+    g_virtualCloudDb->ForkUpload(nullptr);
+    std::string sql = "select count() from " + DBCommon::GetLogTableName(g_tables[0]) +
+        " where flag & 0x20 = 0;";
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(18), nullptr), SQLITE_OK);
+    CloseDb();
+}
 }
 #endif // RELATIONAL_STORE
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_set_cloud_schema_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_set_cloud_schema_test.cpp
index 9518d62553a6654893eaff59e901a5696c017260..7716d6455baf6a0b5e30556b6df7e2cdd9f17991 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_set_cloud_schema_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_cloud_interfaces_set_cloud_schema_test.cpp
@@ -23,6 +23,7 @@
 #include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_unit_test.h"
 #include "relational_store_client.h"
+#include "relational_store_delegate_impl.h"
 #include "relational_store_manager.h"
 #include "runtime_config.h"
 #include "time_helper.h"
@@ -1853,4 +1854,29 @@ namespace {
         EXPECT_EQ(sqlite3_exec(db_, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
             reinterpret_cast<void *>(cloudCount), nullptr), SQLITE_OK);
     }
+
+    /**
+     * @tc.name: SetCloudDbSchemaTest018
+     * @tc.desc: Check SetCloudDBSchema while conn is nullptr.
+     * @tc.type: FUNC
+     * @tc.require:
+     * @tc.author: caihaoting
+    */
+    HWTEST_F(DistributedDBCloudInterfacesSetCloudSchemaTest, SetCloudDbSchemaTest018, TestSize.Level0)
+    {
+        /**
+         * @tc.steps:step1. use SetCloudDBSchema while conn is nullptr
+         * @tc.expected: step1. return DB_ERROR
+         */
+        DataBaseSchema dataBaseSchema;
+        TableSchema tableSchema = {
+            .name = g_tableName1,
+            .sharedTableName = g_sharedTableName1,
+            .fields = g_cloudField1
+        };
+        dataBaseSchema.tables.push_back(tableSchema);
+        auto relationalStoreImpl = static_cast<RelationalStoreDelegateImpl *>(g_delegate);
+        EXPECT_EQ(relationalStoreImpl->Close(), OK);
+        EXPECT_EQ(g_delegate->SetCloudDbSchema(dataBaseSchema), DBStatus::DB_ERROR);
+    }
 } // namespace
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_data_value_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_data_value_test.cpp
index aead282fb4174e19557cbdc73c764b778ed79d57..1f017c957b72392feac222d0f88d3e8d19c83148 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_data_value_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_data_value_test.cpp
@@ -167,7 +167,7 @@ HWTEST_F(DistributedDBInterfacesDataValueTest, DataValueCheck002, TestSize.Level
         DataValue dataValue;
         for (uint32_t i = 0; i < g_checkFuncList.size(); i++) {
             uint32_t index = static_cast<uint32_t>((lastWriteIndex + i + 1) %
-                static_cast<uint32_t>(g_checkFuncList.size()));
+                             static_cast<uint32_t>(g_checkFuncList.size()));
             g_checkFuncList[index](dataValue);
         }
     }
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_rd_kernel_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_rd_kernel_test.cpp
index 0f1c1039af3febddc370649470c3903f9da1cb24..6676d063de645def7730046a36b7e60efd79d875 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_rd_kernel_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_rd_kernel_test.cpp
@@ -46,7 +46,6 @@ namespace {
     KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
     auto g_kvNbDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback,
         placeholders::_1, placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvNbDelegatePtr));
-    static const char *g_syncMMapFile = "./share_mem";
 #ifndef OMIT_JSON
     void GenerateValidSchemaString(std::string &string, int num = SCHEMA_TYPE1)
     {
@@ -666,7 +665,7 @@ HWTEST_F(DistributedDBInterfacesDatabaseRdKernelTest, GetDBWhileOpened001, TestS
      * @tc.expected: step3. Returns E_OK.
      */
     auto connection3 = KvDBManager::GetDatabaseConnection(property, errCode, true);
-    EXPECT_EQ(errCode, OK);
+    EXPECT_EQ(errCode, E_OK);
     EXPECT_NE(connection3, nullptr);
 
     KvDBManager::ReleaseDatabaseConnection(connection1);
@@ -885,114 +884,4 @@ HWTEST_F(DistributedDBInterfacesDatabaseRdKernelTest, DataInterceptor1, TestSize
     g_kvNbDelegatePtr = nullptr;
     EXPECT_EQ(g_mgr.DeleteKvStore(storeId), OK);
 }
-
-int *GetProcessSyncMemory(int *fd)
-{
-    *fd = open(g_syncMMapFile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
-    if (*fd <= 0) {
-        return NULL;
-    }
-    if (ftruncate(*fd, sizeof(int)) < 0) {
-        return NULL;
-    }
-    int *step = (int *)mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, *fd, 0);
-    if (step == MAP_FAILED) {
-        return NULL;
-    }
-    *step = 0;
-    return step;
-}
-
-void ClearProcessSyncMemory(int fd, int *buffer)
-{
-    ASSERT_GE(munmap(buffer, sizeof(int)), 0);
-    ASSERT_EQ(close(fd), 0);
-    ASSERT_GE(unlink(g_syncMMapFile), 0);
-}
-
-void WaitCondition(int *X, int Y)
-{
-    while (*X != Y) {
-        usleep(10000);  // sleep 10000 microseconds
-    }
-}
-
-KvStoreNbDelegate::Option GetWriteOption()
-{
-    KvStoreNbDelegate::Option option;
-    option.storageEngineType = GAUSSDB_RD;
-    option.rdconfig.readOnly = false;
-    return option;
-}
-
-/**
- * @tc.name: MultiProcessOpenDb001
- * @tc.desc: Test 2 processes concurrently start the same KvStoreNbDelegate
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: huangboxin
- */
-HWTEST_F(DistributedDBInterfacesDatabaseRdKernelTest, MultiProcessOpenDb001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Create shared variable memory to share variables
-     * @tc.expected: step1. OK
-     */
-    int fd = 0;
-    int *step = GetProcessSyncMemory(&fd);
-    /**
-     * @tc.steps: step2. use 2 process to get kv store
-     * @tc.expected: step2. Returns OK and OVER_MAX_LIMITS
-     */
-    DBStatus result;
-    KvStoreNbDelegate::Option writeOption = GetWriteOption();
-    pid_t pid = fork();
-    ASSERT_GE(pid, 0);
-    if (pid == 0) {
-        (*step)++;
-        WaitCondition(step, 1);
-
-        KvStoreDelegateManager mgr1(APP_ID, USER_ID);
-        KvStoreNbDelegate *delegate1 = nullptr;
-        mgr1.SetKvStoreConfig(g_config);
-        auto delegateCallback1 = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback,
-        placeholders::_1, placeholders::_2, std::ref(result), std::ref(delegate1));
-        mgr1.GetKvStore("multiprocess_getkvstore_001", writeOption, delegateCallback1);
-        ASSERT_TRUE(delegate1 != nullptr);
-
-        if (result != OK) {
-            EXPECT_EQ(result, OVER_MAX_LIMITS);
-        }
-        (*step)++;
-        WaitCondition(step, 3);
-        if (delegate1 != nullptr) {
-            EXPECT_EQ(mgr1.CloseKvStore(delegate1), OK);
-            delegate1 = nullptr;
-        }
-        // quit the child process
-        exit(0);
-    } else {
-        WaitCondition(step, 1);
-
-        KvStoreDelegateManager mgr2(APP_ID, USER_ID);
-        KvStoreNbDelegate *delegate2 = nullptr;
-        mgr2.SetKvStoreConfig(g_config);
-        auto delegateCallback2 = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback,
-        placeholders::_1, placeholders::_2, std::ref(result), std::ref(delegate2));
-        mgr2.GetKvStore("multiprocess_getkvstore_001", writeOption, delegateCallback2);
-
-        if (result != OK) {
-            EXPECT_EQ(result, OVER_MAX_LIMITS);
-        }
-        (*step)++;
-        WaitCondition(step, 3);
-        if (delegate2 != nullptr) {
-            EXPECT_EQ(mgr2.CloseKvStore(delegate2), OK);
-            delegate2 = nullptr;
-        }
-    }
-    waitpid(pid, NULL, 0);
-    ClearProcessSyncMemory(fd, step);
-}
-
-#endif // USE_RD_KERNEL
+#endif // USE_RD_KERNEL
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_test.cpp
index 3858f45e94f40a3cf54b621bd49183552895f95a..77952bc66b44ee214f2343d2ffa16be0706cc543 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_database_test.cpp
@@ -1278,7 +1278,7 @@ HWTEST_F(DistributedDBInterfacesDatabaseTest, GetDBWhileOpened001, TestSize.Leve
      * @tc.expected: step3. Returns E_OK.
      */
     auto connection3 = KvDBManager::GetDatabaseConnection(property, errCode, true);
-    EXPECT_EQ(errCode, OK);
+    EXPECT_EQ(errCode, E_OK);
     EXPECT_NE(connection3, nullptr);
 
     KvDBManager::ReleaseDatabaseConnection(connection1);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_rd_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_rd_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2119fddcb40415ef211cbe71e52379b28113c543
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_rd_test.cpp
@@ -0,0 +1,1298 @@
+/*
+ * Copyright (c) Huawei Device Co., Ltd. 2024. All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifdef USE_RD_KERNEL
+#ifndef OMIT_ENCRYPT
+#include <gtest/gtest.h>
+#include <fcntl.h>
+
+#include "db_common.h"
+#include "distributeddb_data_generate_unit_test.h"
+#include "platform_specific.h"
+#include "process_communicator_test_stub.h"
+#include "process_system_api_adapter_impl.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace DistributedDB;
+using namespace DistributedDBUnitTest;
+
+namespace {
+    // define some variables to init a KvStoreDelegateManager object.
+    KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
+    string g_testDir;
+    KvStoreConfig g_config;
+    std::string g_exportFileDir;
+    std::vector<std::string> g_junkFilesList;
+
+    // define the g_kvNbDelegateCallback, used to get some information when open a kv store.
+    DBStatus g_kvDelegateStatus = INVALID_ARGS;
+    KvStoreNbDelegate *g_kvNbDelegatePtr = nullptr;
+    KvStoreNbDelegate *g_kvNbDelegatePtrWithoutPasswd = nullptr;
+
+#ifndef OMIT_MULTI_VER
+    KvStoreDelegate *g_kvDelegatePtr = nullptr;
+    KvStoreDelegate *g_kvDelegatePtrWithoutPasswd = nullptr;
+    // the type of g_kvDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
+    auto g_kvDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreDelegateCallback, placeholders::_1,
+        placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvDelegatePtr));
+    KvStoreDelegate::Option g_option;
+#endif // OMIT_MULTI_VER
+
+    const size_t MAX_PASSWD_SIZE = 128;
+    // define the g_valueCallback, used to query a value object data from the kvdb.
+    DBStatus g_valueStatus = INVALID_ARGS;
+    Value g_value;
+
+    CipherPassword g_passwd1;
+    CipherPassword g_passwd2;
+    CipherPassword g_passwd3;
+    CipherPassword g_passwd4;
+    // the type of g_valueCallback is function<void(DBStatus, Value)>
+    auto g_valueCallback = bind(&DistributedDBToolsUnitTest::ValueCallback,
+        placeholders::_1, placeholders::_2, std::ref(g_valueStatus), std::ref(g_value));
+
+    // the type of g_kvNbDelegateCallback is function<void(DBStatus, KvStoreDelegate*)>
+    auto g_kvNbDelegateCallback = bind(&DistributedDBToolsUnitTest::KvStoreNbDelegateCallback, placeholders::_1,
+        placeholders::_2, std::ref(g_kvDelegateStatus), std::ref(g_kvNbDelegatePtr));
+
+    void RemoveJunkFile(const std::vector<std::string> &fileList)
+    {
+        for (auto &junkFile : fileList) {
+            std::ifstream file(junkFile);
+            if (file) {
+                file.close();
+                int result = remove(junkFile.c_str());
+                if (result < 0) {
+                    LOGE("failed to delete the db file:%d", errno);
+                }
+            }
+        }
+        return;
+    }
+}
+
+class DistributedDBInterfacesImportAndExportRdTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    int ModifyDataInPage(int modifyPos, char newVal, const char *modifyFile);
+};
+
+void DistributedDBInterfacesImportAndExportRdTest::SetUpTestCase(void)
+{
+    g_mgr.SetProcessLabel("6666", "8888");
+    g_mgr.SetProcessCommunicator(std::make_shared<ProcessCommunicatorTestStub>());
+    DistributedDBToolsUnitTest::TestDirInit(g_testDir);
+    g_config.dataDir = g_testDir;
+    g_mgr.SetKvStoreConfig(g_config);
+
+    g_exportFileDir = g_testDir + "/ExportDir";
+    OS::MakeDBDirectory(g_exportFileDir);
+    vector<uint8_t> passwdBuffer1(5, 1);  // 5 and 1 as random password.
+    int errCode = g_passwd1.SetValue(passwdBuffer1.data(), passwdBuffer1.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    vector<uint8_t> passwdBuffer2(5, 2);  // 5 and 2 as random password.
+    errCode = g_passwd2.SetValue(passwdBuffer2.data(), passwdBuffer2.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    vector<uint8_t> passwdBuffer3(5, 3);  // 5 and 3 as random password.
+    errCode = g_passwd3.SetValue(passwdBuffer3.data(), passwdBuffer3.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    vector<uint8_t> passwdBuffer4(5, 4);  // 5 and 4 as random password.
+    errCode = g_passwd4.SetValue(passwdBuffer4.data(), passwdBuffer4.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+}
+
+void DistributedDBInterfacesImportAndExportRdTest::TearDownTestCase(void)
+{
+    OS::RemoveDBDirectory(g_exportFileDir);
+    if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
+        LOGE("rm test db files error!");
+    }
+    RuntimeContext::GetInstance()->StopTaskPool(); // wait for all thread exit
+}
+
+void DistributedDBInterfacesImportAndExportRdTest::SetUp(void)
+{
+    DistributedDBToolsUnitTest::PrintTestCaseInfo();
+    g_junkFilesList.clear();
+    g_kvDelegateStatus = INVALID_ARGS;
+    g_kvNbDelegatePtr = nullptr;
+#ifndef OMIT_MULTI_VER
+    g_kvDelegatePtr = nullptr;
+#endif // OMIT_MULTI_VER
+}
+
+void DistributedDBInterfacesImportAndExportRdTest::TearDown(void)
+{
+    RemoveJunkFile(g_junkFilesList);
+}
+
+/**
+  * @tc.name: NormalExport001
+  * @tc.desc: The data of the current version of the board is exported and the package file is single.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, NormalExport001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleExportFileName = g_exportFileDir + "/singleNormalExport001.$$";
+    std::string singleStoreId = "distributed_SingleNormalExport_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Specify the path to export the non-encrypted board database.
+     * @tc.expected: step2. Returns OK
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+#ifndef OMIT_MULTI_VER
+    std::string mulitExportFileName = g_exportFileDir + "/mulitNormalExport001.$$";
+    std::string multiStoreId = "distributed_MultiNormalExport_001";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step3. Specify the path to export the multi-version non-encrypted database.
+     * @tc.expected: step3. Returns OK
+     */
+    EXPECT_EQ(g_kvDelegatePtr->Export(mulitExportFileName, passwd), OK);
+
+    // clear resource
+    g_junkFilesList.push_back(mulitExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+#endif // OMIT_MULTI_VER
+    g_junkFilesList.push_back(singleExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+/**
+  * @tc.name: ImportTxtFile001
+  * @tc.desc: Check Txt file type when import
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ImportTxtFile001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleExportFileName = g_exportFileDir + "/importTxtFile001.$$";
+    std::string singleStoreId = "import_TxtFile_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Import a.txt in the right path.
+     * @tc.expected: step2. Returns INVALID_FILE
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    std::string filePath = g_exportFileDir + "/a.txt";
+    ofstream createFile(filePath);
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(filePath, passwd), INVALID_FILE);
+
+    if (createFile) {
+        createFile << '1' << endl;
+        createFile.close();
+    }
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(filePath, passwd), INVALID_FILE);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+/**
+  * @tc.name: ImportDamagedFile001
+  * @tc.desc: Test import damaged file.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+int DistributedDBInterfacesImportAndExportRdTest::ModifyDataInPage(int modifyPos, char newVal, const char *modifyFile)
+{
+    FILE *fp = fopen(modifyFile, "rb+");
+    if (fp == nullptr) {
+        printf("Failed to open file");
+        return 1;
+    }
+    if (fseek(fp, modifyPos, SEEK_SET) != 0) {
+        printf("Failed to seek to position");
+        fclose(fp);
+        return 1;
+    }
+    size_t ret = fwrite(&newVal, sizeof(char), 1, fp);
+    if (ret != 1) {
+        printf("Failed to write file");
+        return 1;
+    }
+    if (fclose(fp) == EOF) {
+        printf("Failed to close file");
+        return 1;
+    }
+    return 0;
+}
+
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ImportDamagedFile001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleExportFileName = g_exportFileDir + "/importDamagedFile001.$$";
+    std::string singleStoreId = "import_DamagedFile_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Specify the path to export the non-encrypted board database.
+     * @tc.expected: step2. Returns OK
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. Import damaged file.
+     * @tc.expected: step3. Returns INVALID_FILE
+     */
+    ModifyDataInPage(50086, '0', singleExportFileName.c_str());
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), INVALID_FILE);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+/**
+  * @tc.name: ReadOnlyNotExport001
+  * @tc.desc: Export is not supported when option.rdconfig.type is true.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ReadOnlyNotExport001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleExportFileName = g_exportFileDir + "/readOnlyNotExport001.$$";
+    std::string singleStoreId = "distributed_readOnlyNotExport_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+
+    /**
+     * @tc.steps: step2. Specify the path to export the non-encrypted board database.
+     * @tc.expected: step2. Returns OK
+     */
+
+    option.rdconfig.readOnly = true;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), READ_ONLY);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+/**
+  * @tc.name: UndisturbedlSingleExport001
+  * @tc.desc: Check that the export action is an independent transaction.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, UndisturbedlSingleExport001, TestSize.Level1)
+{
+    std::string singleStoreId = "undistributed_SingleExport_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step1. Three known data records are preset in the board database.
+     */
+    g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
+    g_kvNbDelegatePtr->Put(KEY_2, VALUE_2);
+    g_kvNbDelegatePtr->Put(KEY_3, VALUE_3);
+
+    /**
+     * @tc.steps: step2. Execute the export action.
+     */
+    std::string singleExportFileName = g_exportFileDir + "/UndisturbedlSingleExport001.$$";
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. Insert multiple new data records into the database.
+     */
+    g_kvNbDelegatePtr->Put(KEY_4, VALUE_4);
+    g_kvNbDelegatePtr->Put(KEY_5, VALUE_5);
+
+    /**
+     * @tc.steps: step4.  Import backup data.
+     * @tc.expected: step4. Returns OK.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step5. Check whether the imported data is the preset content in step 1.
+     * @tc.expected: step5. Three preset data records are found.
+     */
+    Value readValue;
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), OK);
+    EXPECT_EQ(readValue, VALUE_1);
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_2, readValue), OK);
+    EXPECT_EQ(readValue, VALUE_2);
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_3, readValue), OK);
+    EXPECT_EQ(readValue, VALUE_3);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_4, readValue), NOT_FOUND);
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_5, readValue), NOT_FOUND);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+    g_junkFilesList.push_back(singleExportFileName);
+}
+
+#ifndef OMIT_MULTI_VER
+static void GetSnapshotUnitTest(KvStoreDelegate *&kvDelegatePtr, KvStoreSnapshotDelegate *&snapshotDelegatePtr)
+{
+    DBStatus snapshotDelegateStatus = INVALID_ARGS;
+    auto snapshotDelegateCallback = bind(&DistributedDBToolsUnitTest::SnapshotDelegateCallback,
+        placeholders::_1, placeholders::_2, std::ref(snapshotDelegateStatus), std::ref(snapshotDelegatePtr));
+
+    kvDelegatePtr->GetKvStoreSnapshot(nullptr, snapshotDelegateCallback);
+    EXPECT_TRUE(snapshotDelegateStatus == OK);
+    ASSERT_TRUE(snapshotDelegatePtr != nullptr);
+}
+
+/**
+  * @tc.name: UndisturbedlMultiExport001
+  * @tc.desc: Check that the export action is an independent transaction.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, UndisturbedlMultiExport001, TestSize.Level1)
+{
+    std::string multiStoreId = "undistributed_MultiExport_001";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step1. Three known data records are preset in the board database.
+     */
+    g_kvDelegatePtr->Put(KEY_1, VALUE_1);
+    g_kvDelegatePtr->Put(KEY_2, VALUE_2);
+    g_kvDelegatePtr->Put(KEY_3, VALUE_3);
+
+    /**
+     * @tc.steps: step2. Execute the export action.
+     */
+    std::string mulitExportFileName = g_exportFileDir + "/UndisturbedlMultiExport001.$$";
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvDelegatePtr->Export(mulitExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. Insert multiple new data records into the database.
+     */
+    g_kvDelegatePtr->Put(KEY_4, VALUE_4);
+    g_kvDelegatePtr->Put(KEY_5, VALUE_5);
+
+    /**
+     * @tc.steps: step4.  Import backup data.
+     * @tc.expected: step4. Returns OK.
+     */
+    EXPECT_EQ(g_kvDelegatePtr->Import(mulitExportFileName, passwd), OK);
+
+    KvStoreSnapshotDelegate *snapshotDelegatePtr = nullptr;
+    GetSnapshotUnitTest(g_kvDelegatePtr, snapshotDelegatePtr);
+    ASSERT_TRUE(snapshotDelegatePtr != nullptr);
+
+    /**
+     * @tc.steps: step5. Check whether the imported data is the preset content in step 1.
+     * @tc.expected: step5. Three preset data records are found.
+     */
+    snapshotDelegatePtr->Get(KEY_1, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, OK);
+    EXPECT_EQ(g_value, VALUE_1);
+    snapshotDelegatePtr->Get(KEY_2, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, OK);
+    EXPECT_EQ(g_value, VALUE_2);
+    snapshotDelegatePtr->Get(KEY_3, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, OK);
+    EXPECT_EQ(g_value, VALUE_3);
+
+    snapshotDelegatePtr->Get(KEY_4, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, NOT_FOUND);
+    snapshotDelegatePtr->Get(KEY_5, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, NOT_FOUND);
+
+    EXPECT_TRUE(g_kvDelegatePtr->ReleaseKvStoreSnapshot(snapshotDelegatePtr) == OK);
+    snapshotDelegatePtr = nullptr;
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+    g_junkFilesList.push_back(mulitExportFileName);
+}
+#endif // OMIT_MULTI_VER
+
+/**
+  * @tc.name: ExportParameterCheck001
+  * @tc.desc: Check the verification of abnormal interface parameters.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ExportParameterCheck001, TestSize.Level1)
+{
+    std::string singleStoreId = "distributed_ParameterCheck_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
+
+    /**
+     * @tc.steps: step1. The filePath path does not exist.
+     * @tc.expected: step1. Return INVALID_ARGS.
+     */
+    std::string invalidFileName = g_exportFileDir + "/tempNotCreated/" + "/ExportParameterCheck001.$$";
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(invalidFileName, passwd), INVALID_ARGS);
+
+    /**
+     * @tc.steps: step2. Password length MAX_PASSWD_SIZE + 1
+     * @tc.expected: step2. Return INVALID_ARGS.
+     */
+    vector<uint8_t> passwdBuffer(MAX_PASSWD_SIZE + 1, MAX_PASSWD_SIZE);
+    int errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OVERSIZE);
+    /**
+     * @tc.steps: step3. Password length MAX_PASSWD_SIZE
+     * @tc.expected: step3. Return OK.
+     */
+    passwdBuffer.resize(MAX_PASSWD_SIZE, MAX_PASSWD_SIZE);
+    errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    std::string singleExportFileName = g_exportFileDir + "/ExportParameterCheck001.$$";
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), NOT_SUPPORT);
+
+    /**
+     * @tc.steps: step5. Use the password to import the file again,
+     * @tc.expected: step5. Return OK.
+     */
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+#ifndef OMIT_MULTI_VER
+/**
+  * @tc.name: ExportParameterCheck002
+  * @tc.desc: Check the verification of abnormal interface parameters.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ExportParameterCheck002, TestSize.Level1)
+{
+    std::string multiStoreId = "distributed_ParameterCheck_002";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    g_kvDelegatePtr->Put(KEY_1, VALUE_1);
+
+    /**
+     * @tc.steps: step1. The filePath path does not exist.
+     * @tc.expected: step1. Return INVALID_ARGS.
+     */
+    std::string invalidExportFileName = g_exportFileDir + "/tempNotCreated/" + "/ExportParameterCheck002.$$";
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvDelegatePtr->Export(invalidExportFileName, passwd), INVALID_ARGS);
+
+    /**
+     * @tc.steps: step2. Password length MAX_PASSWD_SIZE + 1
+     * @tc.expected: step2. Return INVALID_ARGS.
+     */
+    vector<uint8_t> passwdBuffer(MAX_PASSWD_SIZE + 1, MAX_PASSWD_SIZE);
+    int errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OVERSIZE);
+    /**
+     * @tc.steps: step3. Password length MAX_PASSWD_SIZE
+     * @tc.expected: step3. Return OK.
+     */
+    passwdBuffer.resize(MAX_PASSWD_SIZE, MAX_PASSWD_SIZE);
+    errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    std::string multiExportFileName = g_exportFileDir + "/ExportParameterCheck002.$$";
+    EXPECT_EQ(g_kvDelegatePtr->Export(multiExportFileName, passwd), NOT_SUPPORT);
+
+    /**
+     * @tc.steps: step4. Use the password to import the file again,
+     * @tc.expected: step4. Return OK.
+     */
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+}
+#endif // OMIT_MULTI_VER
+
+/**
+  * @tc.name: ReadOnlyNotImport001
+  * @tc.desc: Import is not supported when option.rdconfig.readOnly is true.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ReadOnlyNotImport001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleExportFileName = g_exportFileDir + "/readOnlyNotImport001.$$";
+    std::string singleStoreId = "distributed_readOnlyNotImport_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Import an authorized path with an incorrect password.
+     * @tc.expected: step2. Return INVALID_FILE.
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+
+    /**
+     * @tc.steps: step3. Import a permission path without a password.
+     * @tc.expected: step3. Return OK.
+     */
+    option.rdconfig.readOnly = true;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), READ_ONLY);
+
+    // clear resource
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+/**
+  * @tc.name: NormalImport001
+  * @tc.desc: Normal import capability for single version, parameter verification capability
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, NormalImport001, TestSize.Level1)
+{
+    std::string singleExportFileName = g_exportFileDir + "/NormalImport001.$$";
+    std::string singleStoreId = "distributed_Importmulti_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step1. Import the invalid path.
+     * @tc.expected: step1. Return INVALID_ARGS.
+     */
+    std::string invalidPath = g_exportFileDir + "sdad" + "/NormalImport001.$$";
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(invalidPath, passwd), INVALID_ARGS);
+
+    /**
+     * @tc.steps: step2. Import an authorized path with an incorrect password.
+     * @tc.expected: step2. Return INVALID_FILE.
+     */
+    vector<uint8_t> passwdBuffer(MAX_PASSWD_SIZE, MAX_PASSWD_SIZE);
+    int errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), NOT_SUPPORT);
+
+    /**
+     * @tc.steps: step3. Import a permission path without a password.
+     * @tc.expected: step3. Return OK.
+     */
+    errCode = passwd.Clear();
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step4. Check whether the data is the same as the backup database.
+     * @tc.expected: step4. Same database data.
+     */
+    Value readValue;
+    g_kvNbDelegatePtr->Get(KEY_1, readValue);
+    EXPECT_EQ(readValue, VALUE_1);
+
+    // clear resource
+    g_junkFilesList.push_back(singleExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+#ifndef OMIT_MULTI_VER
+/**
+  * @tc.name: NormalImport002
+  * @tc.desc: Normal import capability for multi version, parameter verification capability
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, NormalImport002, TestSize.Level1)
+{
+    std::string multiExportFileName = g_exportFileDir + "/NormalImport002.$$";
+    std::string multiStoreId = "distributed_ImportSingle_002";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvDelegatePtr->Put(KEY_1, VALUE_1);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvDelegatePtr->Export(multiExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step1. Import the invalid path.
+     * @tc.expected: step1. Return INVALID_ARGS.
+     */
+    std::string invalidPath = g_exportFileDir + "sdad" + "/NormalImport002.$$";
+    EXPECT_EQ(g_kvDelegatePtr->Import(invalidPath, passwd), INVALID_ARGS);
+
+    /**
+     * @tc.steps: step2. Import an authorized path with an incorrect password.
+     * @tc.expected: step2. Return INVALID_FILE.
+     */
+    vector<uint8_t> passwdBuffer(MAX_PASSWD_SIZE, MAX_PASSWD_SIZE);
+    int errCode = passwd.SetValue(passwdBuffer.data(), passwdBuffer.size());
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    EXPECT_EQ(g_kvDelegatePtr->Import(multiExportFileName, passwd), INVALID_FILE);
+
+    g_kvDelegatePtr->Delete(KEY_1);
+    /**
+     * @tc.steps: step3. Import a permission path without a password.
+     * @tc.expected: step3. Return OK.
+     */
+    errCode = passwd.Clear();
+    ASSERT_EQ(errCode, CipherPassword::ErrorCode::OK);
+    EXPECT_EQ(g_kvDelegatePtr->Import(multiExportFileName, passwd), OK);
+
+    KvStoreSnapshotDelegate *snapshotDelegatePtr = nullptr;
+    GetSnapshotUnitTest(g_kvDelegatePtr, snapshotDelegatePtr);
+    ASSERT_TRUE(snapshotDelegatePtr != nullptr);
+
+    /**
+     * @tc.steps: step4. Check whether the data is the same as the backup database.
+     * @tc.expected: step4. Same database data.
+     */
+    snapshotDelegatePtr->Get(KEY_1, g_valueCallback);
+    EXPECT_EQ(g_valueStatus, OK);
+    EXPECT_EQ(g_value, VALUE_1);
+
+    EXPECT_TRUE(g_kvDelegatePtr->ReleaseKvStoreSnapshot(snapshotDelegatePtr) == OK);
+    snapshotDelegatePtr = nullptr;
+
+    // clear resource
+    g_junkFilesList.push_back(multiExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+}
+#endif // OMIT_MULTI_VER
+
+/**
+  * @tc.name: ExceptionFileImport001
+  * @tc.desc: Normal import capability for single version, parameter verification capability
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ExceptionFileImport001, TestSize.Level1)
+{
+    std::string singleExportFileName = g_exportFileDir + "/ExceptionFileImport001.$$";
+    std::string singleStoreId = "distributed_ImportExceptionsigle_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvNbDelegatePtr->Put(KEY_2, VALUE_2);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step1. Repeat import backup file to same database.
+     * @tc.expected: step1. Return OK.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step2. Change the name of file1 to file2.
+     */
+    std::string newSingleExportFileName = g_exportFileDir + "/newExceptionFileImport001.$$";
+    EXPECT_EQ(rename(singleExportFileName.c_str(), newSingleExportFileName.c_str()), 0);
+
+    /**
+     * @tc.steps: step3. Import file1 into the database.
+     * @tc.expected: step3. Return INVALID_FILE.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), INVALID_FILE);
+
+    /**
+     * @tc.steps: step4. Import file2 into the database.
+     * @tc.expected: step4. Return INVALID_FILE.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(newSingleExportFileName, passwd), OK);
+
+    // clear resource
+    g_junkFilesList.push_back(singleExportFileName);
+    g_junkFilesList.push_back(newSingleExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+
+#ifndef OMIT_MULTI_VER
+/**
+  * @tc.name: ExceptionFileImport002
+  * @tc.desc: Normal import capability for multi version, parameter verification capability
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ExceptionFileImport002, TestSize.Level1)
+{
+    std::string multiExportFileName = g_exportFileDir + "/ExceptionFileImport002.$$";
+    std::string multiStoreId = "distributed_ImportExceptionMulti_001";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvDelegatePtr->Put(KEY_1, VALUE_1);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvDelegatePtr->Export(multiExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step1. Import the backup file that has been tampered with to the multi-version database.
+     * @tc.expected: step1. Return INVALID_FILE.
+     */
+    EXPECT_EQ(DistributedDBToolsUnitTest::ModifyDatabaseFile(multiExportFileName), 0);
+    EXPECT_EQ(g_kvDelegatePtr->Import(multiExportFileName, passwd), INVALID_FILE);
+
+    // clear resource
+    g_junkFilesList.push_back(multiExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+}
+
+/**
+  * @tc.name: ExceptionFileImport003
+  * @tc.desc: The data of the current version of the board is exported and the package file is single.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ExceptionFileImport003, TestSize.Level1)
+{
+    std::string singleExportFileName = g_exportFileDir + "/singleExceptionFileImport003.$$";
+    std::string singleStoreId = "distributed_ExportSingle_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    std::string mulitExportFileName = g_exportFileDir + "/mulitExceptionFileImport003.$$";
+    std::string multiStoreId = "distributed_ExportMulit_001";
+    g_mgr.GetKvStore(multiStoreId, g_option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    EXPECT_EQ(g_kvDelegatePtr->Export(mulitExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step1. Use the single ver import interface. The file path is a multi-version backup file.
+     * @tc.expected: step1. Return INVALID_FILE.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(mulitExportFileName, passwd), INVALID_FILE);
+
+    /**
+     * @tc.steps: step2.  Use the single ver import interface. The file path is a single-version backup file.
+     * @tc.expected: step2. Return OK.
+     */
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3.  Use the multi-version import interface. The file path is a single-version backup file.
+     * @tc.expected: step3. Return INVALID_FILE.
+     */
+    EXPECT_EQ(g_kvDelegatePtr->Import(singleExportFileName, passwd), INVALID_FILE);
+
+    /**
+     * @tc.steps: step4.  Use the multi-version import interface. The file path is a multi-version backup file.
+     * @tc.expected: step4. Return INVALID_FILE.
+     */
+    EXPECT_EQ(g_kvDelegatePtr->Import(mulitExportFileName, passwd), OK);
+
+    // clear resource
+    g_junkFilesList.push_back(singleExportFileName);
+    g_junkFilesList.push_back(mulitExportFileName);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(multiStoreId), OK);
+}
+#endif // OMIT_MULTI_VER
+
+static void TryDbForPasswordIndependence001()
+{
+    std::string singleStoreIdNoPasswd = "distributed_DbForPasswordIndependence_001";
+    std::string singleStoreId = "distributed_DbForPasswordIndependence_001";
+
+    /**
+     * @tc.steps: step4. Run the p3 command to open the database db1.
+     * @tc.expected: step4. Return ERROR.
+     */
+    KvStoreNbDelegate::Option option = {true, false, true, CipherType::DEFAULT, g_passwd3};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreIdNoPasswd, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+    EXPECT_NE(g_kvDelegateStatus, OK);
+
+    /**
+     * @tc.steps: step5. Run the p4 command to open the database db2.
+     * @tc.expected: step5. Return ERROR.
+     */
+    option = {true, false, true, CipherType::DEFAULT, g_passwd4};
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus != OK);
+
+    /**
+     * @tc.steps: step6. Open the db1 directly.
+     * @tc.expected: step6. Return OK.
+     */
+    option = {true, false, false, CipherType::DEFAULT, g_passwd3};
+    g_mgr.GetKvStore(singleStoreIdNoPasswd, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus == OK);
+    g_kvNbDelegatePtrWithoutPasswd = g_kvNbDelegatePtr;
+
+    /**
+     * @tc.steps: step7. Open the db1 directly
+     * @tc.expected: step7. Return ERROR.
+     */
+    option = {true, false, false, CipherType::DEFAULT, g_passwd3};
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus != OK);
+
+    /**
+     * @tc.steps: step8. Run the p2 command to open the db2 file.
+     * @tc.expected: step8. Return ERROR.
+     */
+    option = {true, false, true, CipherType::DEFAULT, g_passwd2};
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus == OK);
+}
+
+/**
+  * @tc.name: PasswordIndependence001
+  * @tc.desc: The data of the current version of the board is exported and the package file is single.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, PasswordIndependence001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Back up a single database db1 No password backup password p3
+     */
+    std::string singleExportFileNameNoPasswd = g_exportFileDir + "/passwordIndependence001.$$";
+    std::string singleStoreIdNoPasswd = "distributed_PasswordIndependence_001";
+
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreIdNoPasswd, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvNbDelegatePtrWithoutPasswd = g_kvNbDelegatePtr;
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileNameNoPasswd, g_passwd3), NOT_SUPPORT);
+}
+
+#ifndef OMIT_MULTI_VER
+static void TryDbForPasswordIndependence002()
+{
+    std::string multiStoreIdNoPasswd = "distributed_DbForPasswordIndependence_002";
+    std::string multiStoreId = "distributed_DbForPasswordIndependence_002";
+
+    KvStoreDelegate::Option option = {true, false, true, CipherType::DEFAULT, g_passwd3};
+    g_mgr.GetKvStore(multiStoreIdNoPasswd, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr == nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus != OK);
+
+    option = {true, false, true, CipherType::DEFAULT, g_passwd4};
+    g_mgr.GetKvStore(multiStoreId, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr == nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus != OK);
+
+    option = {true, false, false, CipherType::DEFAULT, g_passwd3};
+    g_mgr.GetKvStore(multiStoreIdNoPasswd, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus == OK);
+    g_kvDelegatePtrWithoutPasswd = g_kvDelegatePtr;
+
+    option = {true, false, false, CipherType::DEFAULT, g_passwd3};
+    g_mgr.GetKvStore(multiStoreId, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr == nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus != OK);
+
+    option = {true, false, true, CipherType::DEFAULT, g_passwd2};
+    g_mgr.GetKvStore(multiStoreId, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    ASSERT_TRUE(g_kvDelegateStatus == OK);
+}
+
+/**
+  * @tc.name: PasswordIndependence002
+  * @tc.desc: The data of the current version of the board is exported and the package file is single.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, PasswordIndependence002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Back up a single database db1 No password backup password p3
+     */
+    std::string multiExportFileNameNoPasswd = g_exportFileDir + "/passwordIndependence002.$$";
+    std::string multiStoreIdNoPasswd = "distributed_PasswordIndependence_002";
+    KvStoreDelegate::Option option;
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(multiStoreIdNoPasswd, option, g_kvDelegateCallback);
+    ASSERT_TRUE(g_kvDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    g_kvDelegatePtrWithoutPasswd = g_kvDelegatePtr;
+
+    EXPECT_EQ(g_kvDelegatePtr->Export(multiExportFileNameNoPasswd, g_passwd3), NOT_SUPPORT);
+}
+#endif // OMIT_MULTI_VER
+
+/**
+  * @tc.name: PasswordIndependence002
+  * @tc.desc: The data of the current version of the board is exported and the package file is single.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, PasswordIndependence003, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Back up the (passwd1) encryption single-version (passwd2) database.
+     */
+    std::string singleExportFileName = g_exportFileDir + "/passwordIndependence003.$$";
+    std::string singleStoreId = "distributed_ExportSingle_009";
+    KvStoreNbDelegate::Option option = {true, false, true, CipherType::DEFAULT, g_passwd2};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+}
+
+/**
+  * @tc.name: SeparaDbExportAndImport
+  * @tc.desc: Import and export after Separate database.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, SeparaDbExportAndImport, TestSize.Level1)
+{
+    std::shared_ptr<ProcessSystemApiAdapterImpl> adapter = std::make_shared<ProcessSystemApiAdapterImpl>();
+    EXPECT_TRUE(adapter != nullptr);
+    RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(adapter);
+
+    std::string singleExportFileName = g_exportFileDir + "/SeparaDbExportAndImport.$$";
+    std::string singleStoreId = "distributed_ExportSingle_010";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    SecurityOption secOption{SecurityLabel::S3, SecurityFlag::SECE};
+    option.secOption = secOption;
+
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+
+    g_kvNbDelegatePtr->Put(KEY_1, VALUE_1);
+
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    g_kvNbDelegatePtr->Put(KEY_2, VALUE_2);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleExportFileName, passwd), OK);
+    Value valueRead;
+    g_kvNbDelegatePtr->Get(KEY_2, valueRead);
+    EXPECT_EQ(valueRead, Value());
+    g_kvNbDelegatePtr->Get(KEY_1, valueRead);
+    EXPECT_EQ(valueRead, VALUE_1);
+    g_kvNbDelegatePtr->Put(KEY_3, VALUE_3);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Rekey(g_passwd1), NOT_SUPPORT);
+    g_kvNbDelegatePtr->Get(KEY_3, valueRead);
+    EXPECT_EQ(valueRead, VALUE_3);
+
+    // clear resource
+    g_junkFilesList.push_back(singleExportFileName);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+
+    option.passwd = g_passwd1;
+    option.isEncryptedDb = true;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+}
+
+/**
+  * @tc.name: SeparaDbExportAndImport
+  * @tc.desc: Import and export after Separate database.
+  * @tc.type: FUNC
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, SeparaDbNoPasswdRekey, TestSize.Level1)
+{
+    std::shared_ptr<ProcessSystemApiAdapterImpl> adapter = std::make_shared<ProcessSystemApiAdapterImpl>();
+    EXPECT_TRUE(adapter != nullptr);
+    RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(adapter);
+
+    KvStoreNbDelegate::Option option = {true, false, true};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    SecurityOption secOption{SecurityLabel::S3, SecurityFlag::SECE};
+    option.secOption = secOption;
+    option.passwd = g_passwd1;
+    g_mgr.GetKvStore("SeparaDbNoPasswdRekey", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr == nullptr);
+}
+
+/**
+  * @tc.name: ForceExportTest001
+  * @tc.desc: Force export to an existing file.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: lianhuix
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ForceExportTest001, TestSize.Level1)
+{
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore("ForceExportTest001", option, g_kvNbDelegateCallback);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_1), OK);
+
+    CipherPassword passwd;
+    std::string exportFileName = g_exportFileDir + "ForceExportTest001.back";
+
+    int fd = open(exportFileName.c_str(), (O_WRONLY | O_CREAT), (S_IRUSR | S_IWUSR | S_IRGRP));
+    ASSERT_TRUE(fd >= 0);
+    std::string text = "Hello world.";
+    write(fd, text.c_str(), text.length());
+    close(fd);
+
+    chmod(exportFileName.c_str(), S_IRWXU);
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(exportFileName, passwd, true), OK);
+
+    uint32_t filePermission = 0;
+    struct stat fileStat;
+    EXPECT_EQ(stat(exportFileName.c_str(), &fileStat), 0);
+    filePermission = fileStat.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
+    EXPECT_EQ(filePermission, static_cast<uint32_t>(S_IRWXU));
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+    EXPECT_EQ(g_mgr.DeleteKvStore("ForceExportTest001"), OK);
+
+    g_mgr.GetKvStore(STORE_ID_1, option, g_kvNbDelegateCallback);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(exportFileName, passwd), OK);
+    Value val;
+    g_kvNbDelegatePtr->Get(KEY_1, val);
+    EXPECT_EQ(val, VALUE_1);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+    EXPECT_EQ(g_mgr.DeleteKvStore(STORE_ID_1), OK);
+}
+
+/**
+  * @tc.name: abortHandle001
+  * @tc.desc: Intercept obtaining new write handles during Import.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: bty
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, abortHandle001, TestSize.Level1)
+{
+    std::string singleStoreId = "ExportAbortHandle_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step1. Init data for export.
+     */
+    std::string str(1024, 'k');
+    Value value(str.begin(), str.end());
+    for (int i = 0; i < 1000; ++i) {
+        Key key;
+        DBCommon::StringToVector(std::to_string(i), key);
+        g_kvNbDelegatePtr->Put(key, value);
+    }
+
+    /**
+     * @tc.steps: step2. Execute the export action.
+     */
+    std::string singleExportFileName = g_exportFileDir + "/UnExportAbortHandle001.$$";
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleExportFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. Multi threads to occupy write handles.
+     */
+    for (int i = 0; i < 10; ++i) { // 10 is run times
+        vector<thread> threads;
+        threads.emplace_back(thread([&]() {
+            g_kvNbDelegatePtr->CheckIntegrity();
+        }));
+        threads.emplace_back(&KvStoreNbDelegate::Import, g_kvNbDelegatePtr, singleExportFileName, passwd);
+        threads.emplace_back(thread([&i]() {
+            std::this_thread::sleep_for(std::chrono::milliseconds(i));
+            g_kvNbDelegatePtr->CheckIntegrity();
+        }));
+        for (auto &th: threads) {
+            th.join();
+        }
+    }
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+    g_junkFilesList.push_back(singleExportFileName);
+}
+
+/**
+  * @tc.name: ImportTest001
+  * @tc.desc: Verify that it will allow to import backup file again during it is importing.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportRdTest, ImportTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleFileName = g_exportFileDir + "/ImportTest001.$$";
+    std::string singleStoreId = "distributed_ImportSingle_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    option.storageEngineType = DistributedDB::GAUSSDB_RD;
+    option.rdconfig.type = HASH;
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Specify the path to export the non-encrypted board database.
+     * @tc.expected: step2. Returns OK
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. start subthread to import the backup file.
+     * @tc.expected: step3. start successfully.
+     */
+    std::atomic<bool> readyFlag(false);
+    readyFlag.store(false);
+    std::condition_variable backupVar;
+    thread subThread([&singleFileName, &passwd, &readyFlag, &backupVar]() {
+        EXPECT_EQ(g_kvNbDelegatePtr->Import(singleFileName, passwd), OK);
+        readyFlag.store(true);
+        backupVar.notify_one();
+    });
+    subThread.detach();
+
+    /**
+     * @tc.steps: step4. import the backup file during the subthread is importing with empty password.
+     * @tc.expected: step4. import successfully and return OK.
+     */
+    const static int millsecondsPerSecond = 1000;
+    std::this_thread::sleep_for(std::chrono::microseconds(millsecondsPerSecond));
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleFileName, passwd), OK);
+
+    std::mutex rekeyMtx;
+    std::unique_lock<std::mutex> lck(rekeyMtx);
+    backupVar.wait(lck, [&]{ return readyFlag.load(); });
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
+#endif // OMIT_ENCRYPT
+#endif // USE_RD_KERNEL
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
index 5c3a6340066a2ba41e45326fe4b460e6dc9ac31f..d2e28ae87021da367587ecd8950d071dda68d79e 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_import_and_export_test.cpp
@@ -1225,7 +1225,7 @@ HWTEST_F(DistributedDBInterfacesImportAndExportTest, ImportWithTimeChange001, Te
     sqlite3 *db = RelationalTestUtils::CreateDataBase(dbPath);
     ASSERT_NE(db, nullptr);
     std::string fakeSql = "UPDATE sync_data SET timestamp = 3270281552768731970, w_timestamp = 3270281552768731970";
-    EXPECT_EQ(RelationalTestUtils::ExecSql(db, fakeSql), OK);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, fakeSql), E_OK);
     EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
     db = nullptr;
 
@@ -1312,4 +1312,61 @@ HWTEST_F(DistributedDBInterfacesImportAndExportTest, abortHandle001, TestSize.Le
     EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
     g_junkFilesList.push_back(singleExportFileName);
 }
+
+/**
+  * @tc.name: ImportTest001
+  * @tc.desc: Verify that it will allow to import backup file again during it is importing.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: chenguoliang
+  */
+HWTEST_F(DistributedDBInterfacesImportAndExportTest, ImportTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Pre-create folder dir
+     */
+    std::string singleFileName = g_exportFileDir + "/ImportTest001.$$";
+    std::string singleStoreId = "distributed_ImportSingle_001";
+    KvStoreNbDelegate::Option option = {true, false, false};
+    g_mgr.GetKvStore(singleStoreId, option, g_kvNbDelegateCallback);
+
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Specify the path to export the non-encrypted board database.
+     * @tc.expected: step2. Returns OK
+     */
+    CipherPassword passwd;
+    EXPECT_EQ(g_kvNbDelegatePtr->Export(singleFileName, passwd), OK);
+
+    /**
+     * @tc.steps: step3. start subthread to import the backup file.
+     * @tc.expected: step3. start successfully.
+     */
+    std::atomic<bool> readyFlag(false);
+    readyFlag.store(false);
+    std::condition_variable backupVar;
+    thread subThread([&singleFileName, &passwd, &readyFlag, &backupVar]() {
+        EXPECT_EQ(g_kvNbDelegatePtr->Import(singleFileName, passwd), OK);
+        readyFlag.store(true);
+        backupVar.notify_one();
+    });
+    subThread.detach();
+
+    /**
+     * @tc.steps: step4. import the backup file during the subthread is importing with empty password.
+     * @tc.expected: step4. import successfully and return OK.
+     */
+    const static int millsecondsPerSecond = 1000;
+    std::this_thread::sleep_for(std::chrono::microseconds(millsecondsPerSecond));
+    EXPECT_EQ(g_kvNbDelegatePtr->Import(singleFileName, passwd), OK);
+
+    std::mutex rekeyMtx;
+    std::unique_lock<std::mutex> lck(rekeyMtx);
+    backupVar.wait(lck, [&]{ return readyFlag.load(); });
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore(singleStoreId), OK);
+}
 #endif // OMIT_ENCRYPT
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_local_batch_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_local_batch_test.cpp
index 2e646938d2607183f60c49cdbeb0476dfca47ad6..047c3b47d99463a2bb2e3c0f69a9f34c825e90f1 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_local_batch_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_local_batch_test.cpp
@@ -20,6 +20,7 @@
 #include "db_errno.h"
 #include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_unit_test.h"
+#include "kv_store_nb_delegate_impl.h"
 #include "log_print.h"
 #include "sqlite_single_ver_natural_store.h"
 
@@ -169,6 +170,49 @@ HWTEST_F(DistributedDBInterfacesNBDelegateLocalBatchTest, PutLocalBatch001, Test
     g_kvNbDelegatePtr = nullptr;
 }
 
+/**
+  * @tc.name: PutLocalBatch002
+  * @tc.desc: This testCase use to verify the PutLocalBatch and DeleteLocalBatch function while conn is nullptr
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateLocalBatchTest, PutLocalBatch002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Get singleVer kvStore by GetKvStore.
+     * @tc.expected: step1. Get database success.
+     */
+    const KvStoreNbDelegate::Option option = {true, true};
+    g_mgr.SetKvStoreConfig(g_config);
+    g_mgr.GetKvStore("distributed_PutLocalBatch_002", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. PutLocalBatch and DeleteLocalBatch 10 records into database while conn is nullptr.
+     * @tc.expected: step2. DB_ERROR.
+     */
+    vector<Entry> entries;
+    for (int i = 0; i < BATCH_PRESET_SIZE_TEST; i++) {
+        Entry entry;
+        entry.key.push_back(i);
+        entry.value.push_back(i);
+        entries.push_back(entry);
+    }
+
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->PutLocalBatch(entries), DB_ERROR);
+    vector<Key> keys;
+    vector<Value> values;
+    CreatEntrys(BATCH_PRESET_SIZE_TEST, keys, values, entries);
+    EXPECT_EQ(g_kvNbDelegatePtr->DeleteLocalBatch(keys), DB_ERROR);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
 /**
   * @tc.name: SingleVerPutLocalBatch001
   * @tc.desc: Check for illegal parameters
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_rd_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_rd_test.cpp
index 668dd5d39c1746bdfe997ab7ff6359eb582723d9..d5f71900b8dee7574d25498b2078eb97276773be 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_rd_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_rd_test.cpp
@@ -1867,7 +1867,7 @@ void PutRangeDataIntoDB()
   * @tc.require: AR.SR.IR20230714002092.017.001
   * @tc.author: mazhao
   */
-HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery001, TestSize.Level0)
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery001, TestSize.Level1)
 {
     /**
      * @tc.steps:step1. Get the nb delegate, and put key {'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'} into db.
@@ -1951,7 +1951,7 @@ void ChkRangeResultSet(KvStoreResultSet *resultSet, int beginNum, int EndNum)
   * @tc.require: AR.SR.IR20230714002092.017.001
   * @tc.author: mazhao
   */
-HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery002, TestSize.Level0)
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery002, TestSize.Level1)
 {
     /**
      * @tc.steps:step1. Get the nb delegate,  and put key {'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'} into db.
@@ -2031,7 +2031,7 @@ HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery002, TestSize.Leve
   * @tc.require: AR.SR.IR20230714002092.017.001
   * @tc.author: mazhao
   */
-HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery003, TestSize.Level0)
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery003, TestSize.Level1)
 {
     /**
      * @tc.steps:step1. Get the nb delegate.
@@ -2110,7 +2110,7 @@ void ChkRangeResultSetMoveFuc(KvStoreResultSet *resultSet, int beginNum, int end
   * @tc.require: AR.SR.IR20230714002092.017.001
   * @tc.author: mazhao
   */
-HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery004, TestSize.Level0)
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery004, TestSize.Level1)
 {
     /**
      * @tc.steps:step1. Get the nb delegate, and put key {'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'} into db.
@@ -2231,5 +2231,93 @@ HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdRangeQuery005, TestSize.Leve
     EXPECT_EQ(g_mgr.DeleteKvStore("RdRangeQuery005"), OK);
     g_kvNbDelegatePtr = nullptr;
 }
+
+/**
+  * @tc.name: RdSync001
+  * @tc.desc:Test sync func with rd.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdSync001, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. Get the nb delegate.
+     * @tc.expected: step1. Get results OK and non-null delegate.
+     */
+    g_mgr.GetKvStore("RdSync001", g_option, g_kvNbDelegateCallback);
+    ASSERT_NE(g_kvNbDelegatePtr, nullptr);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    /**
+     * @tc.steps:step2. Sync
+     * @tc.expected: step2. Return NOT_SUPPORT.
+     */
+    std::mutex dataMutex;
+    std::condition_variable cv;
+    bool finish = false;
+    auto callback = [&cv, &dataMutex, &finish](const std::map<std::string, SyncProcess> &process) {
+        for (const auto &item: process) {
+            if (item.second.process == DistributedDB::FINISHED) {
+                {
+                    std::lock_guard<std::mutex> autoLock(dataMutex);
+                    finish = true;
+                }
+                cv.notify_one();
+            }
+        }
+    };
+    CloudSyncOption syncOption = {
+        .devices = {"deviceName"},
+        .mode = SYNC_MODE_CLOUD_MERGE,
+        .query = {},
+        .waitTime = 0,
+        .priorityTask = false,
+        .compensatedSyncOnly = false,
+        .users = {USER_ID}
+    };
+    auto res = g_kvNbDelegatePtr->Sync(syncOption, callback);
+    EXPECT_EQ(res, NOT_SUPPORT);
+    /**
+     * @tc.steps:step3. Close and delete KV store
+     * @tc.expected: step3. Returns OK.
+     */
+    g_mgr.CloseKvStore(g_kvNbDelegatePtr);
+    EXPECT_EQ(g_mgr.DeleteKvStore("RdSync001"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
+/**
+  * @tc.name: RdSetCloudDB001
+  * @tc.desc:Test set cloudDB func with rd.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateRdTest, RdSetCloudDB001, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. Get the nb delegate.
+     * @tc.expected: step1. Get results OK and non-null delegate.
+     */
+    g_mgr.GetKvStore("RdSetCloudDB001", g_option, g_kvNbDelegateCallback);
+    ASSERT_NE(g_kvNbDelegatePtr, nullptr);
+    EXPECT_EQ(g_kvDelegateStatus, OK);
+    /**
+     * @tc.steps:step2. Set cloudDB
+     * @tc.expected: step2. Return NOT_SUPPORT.
+     */
+    std::shared_ptr<VirtualCloudDb> virtualCloudDb = std::make_shared<VirtualCloudDb>();
+    std::map<std::string, std::shared_ptr<ICloudDb>> cloudDbs;
+    cloudDbs[USER_ID] = virtualCloudDb;
+    auto res = g_kvNbDelegatePtr->SetCloudDB(cloudDbs);
+    EXPECT_EQ(res, NOT_SUPPORT);
+    /**
+     * @tc.steps:step3. Close and delete KV store
+     * @tc.expected: step3. Returns OK.
+     */
+    g_mgr.CloseKvStore(g_kvNbDelegatePtr);
+    EXPECT_EQ(g_mgr.DeleteKvStore("RdSetCloudDB001"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
 }
 #endif // USE_RD_KERNEL
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
index 2423057c5973e99f4a364bea2292968188417180..420da19e94bd54b77f6ea763e9b3f0940bf19879 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_delegate_test.cpp
@@ -30,6 +30,8 @@
 #ifdef DB_DEBUG_ENV
 #include "system_time.h"
 #endif // DB_DEBUG_ENV
+#include "kv_store_result_set_impl.h"
+#include "kv_store_nb_delegate_impl.h"
 #include "kv_virtual_device.h"
 #include "virtual_communicator_aggregator.h"
 
@@ -713,6 +715,53 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, PutBatchVerify001, TestSize.Leve
     g_kvNbDelegatePtr = nullptr;
 }
 
+/**
+  * @tc.name: PutBatchVerify002
+  * @tc.desc: This test case use to verify the putBatch interface function while conn is nullptr
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, PutBatchVerify002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Get singleVer kvStore by GetKvStore.
+     * @tc.expected: step1. Get database success.
+     */
+    const KvStoreNbDelegate::Option option = {true, true};
+    g_mgr.SetKvStoreConfig(g_config);
+    g_mgr.GetKvStore("PutBatchVerify002", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+
+    /**
+     * @tc.steps: step2. Insert 10 records into database while conn is nullptr.
+     * @tc.expected: step2. DB_ERROR.
+     */
+    vector<Entry> entries;
+    for (int i = 0; i < BATCH_PRESET_SIZE_TEST; i++) {
+        Entry entry;
+        entry.key.push_back(i);
+        entry.value.push_back(i);
+        entries.push_back(entry);
+    }
+
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entries), DB_ERROR);
+
+    for (int i = 0; i < BATCH_PRESET_SIZE_TEST; i++) {
+        Key key;
+        key.push_back(i);
+        Value value;
+        g_kvNbDelegatePtr->Get(key, value);
+        EXPECT_NE(key, value);
+    }
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
 /**
   * @tc.name: SingleVerPutBatch001
   * @tc.desc: Check for illegal parameters
@@ -1180,6 +1229,44 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, SingleVerDeleteBatch002, TestSiz
     g_kvNbDelegatePtr = nullptr;
 }
 
+/**
+  * @tc.name: SingleVerDeleteBatch007
+  * @tc.desc: Check normal delete batch while conn is nullptr.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, SingleVerDeleteBatch007, TestSize.Level1)
+{
+    const KvStoreNbDelegate::Option option = {true, false};
+    g_mgr.SetKvStoreConfig(g_config);
+    g_mgr.GetKvStore("SingleVerDeleteBatch007", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    /**
+     * @tc.steps: step1. Create a group of vector <Entry>, containing a total of 10 data keys1 ~ 10, Value1 ~ 10,
+     *  call the Putbatch interface to insert data.
+     * @tc.expected: step1. Insert to database successfully.
+     */
+    vector<Entry> entries;
+    vector<Key> keysBase;
+    vector<Value> values;
+    CreatEntrys(BATCH_PRESET_SIZE_TEST, keysBase, values, entries);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->PutBatch(entries), OK);
+    /**
+     * @tc.steps: step2. DeleteBatch operates on sets of data while conn is nullptr.
+     * @tc.expected: step2. return DB_ERROR.
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->DeleteBatch(keysBase), DB_ERROR);
+
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("SingleVerDeleteBatch007"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
 /**
   * @tc.name: SingleVerPutBatchObserver001
   * @tc.desc: Test the observer function of PutBatch() interface.
@@ -2871,6 +2958,56 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, InvalidQueryTest001, TestSize.Le
     EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(inValidQuery, entries), NOT_SUPPORT);
 }
 
+/**
+  * @tc.name: InvalidQueryTest002
+  * @tc.desc: Test GetEntries with range query filter by sqlite while conn is nullptr.
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, InvalidQueryTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. initialize result set.
+     * @tc.expected: step1. Success.
+     */
+    KvStoreNbDelegate::Option option = {true, false, false};
+    g_mgr.GetKvStore("InvalidQueryTest002", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    InitResultSet();
+
+    /**
+     * @tc.steps: step2. get entries using result set while conn is nullptr.
+     * @tc.expected: step2. DB_ERROR.
+     */
+    KvStoreResultSet *readResultSet = nullptr;
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(g_keyPrefix, readResultSet), DB_ERROR);
+    ASSERT_TRUE(readResultSet == nullptr);
+
+    std::vector<Entry> entries;
+    Query query = Query::Select().PrefixKey({'a', 'c'});
+    EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(query, entries), DB_ERROR);
+    EXPECT_EQ(entries.size(), 0UL);
+
+    EXPECT_EQ(g_kvNbDelegatePtr->GetEntries(query, readResultSet), DB_ERROR);
+    ASSERT_TRUE(readResultSet == nullptr);
+
+    int count = -1;
+    EXPECT_EQ(g_kvNbDelegatePtr->GetCount(query, count), DB_ERROR);
+    EXPECT_EQ(count, -1);
+
+    /**
+     * @tc.steps: step3. close kvStore.
+     * @tc.expected: step3. Success.
+     */
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("InvalidQueryTest002"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
 /**
   * @tc.name: OptionValidCheck001
   * @tc.desc: test validation of option mode
@@ -2910,4 +3047,171 @@ HWTEST_F(DistributedDBInterfacesNBDelegateTest, OptionModeValidCheck001, TestSiz
 
     delete observer;
 }
+
+/**
+ * @tc.name: AbnormalKvStoreTest001
+ * @tc.desc: Test KvStoreNbDelegateImpl interface while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, AbnormalKvStoreTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. GetKvStore for initialize g_kvNbDelegatePtr.
+     * @tc.expected: step1. Success.
+     */
+    KvStoreNbDelegate::Option option = {true, false, false};
+    g_mgr.GetKvStore("AbnormalKvStoreTest001", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    InitResultSet();
+
+    /**
+     * @tc.steps: step2. test KvStoreNbDelegateImpl interface while conn is nullptr.
+     * @tc.expected: step2. return DB_ERROR.
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+
+    const Key key = {0};
+    EXPECT_EQ(kvStoreImpl->PublishLocal(key, true, true, nullptr), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->UnpublishToLocal(key, true, true), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->UnpublishToLocal({}, true, true), INVALID_ARGS);
+    EXPECT_EQ(kvStoreImpl->RemoveDeviceData(""), DB_ERROR);
+    bool autoSync = true;
+    PragmaData data = static_cast<PragmaData>(&autoSync);
+    EXPECT_EQ(kvStoreImpl->Pragma(AUTO_SYNC, data), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->SetConflictNotifier(0, nullptr), DB_ERROR);
+    CipherPassword password;
+    EXPECT_EQ(kvStoreImpl->Rekey(password), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->Export("", password, true), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->Import("", password), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->StartTransaction(), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->Commit(), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->Rollback(), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->CheckIntegrity(), DB_ERROR);
+    SecurityOption securityOption;
+    EXPECT_EQ(kvStoreImpl->GetSecurityOption(securityOption), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->SetRemotePushFinishedNotify(nullptr), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->SetEqualIdentifier("", {}), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->SetPushDataInterceptor(nullptr), DB_ERROR);
+
+    /**
+     * @tc.steps: step3. close kvStore.
+     * @tc.expected: step3. Success.
+     */
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("AbnormalKvStoreTest001"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
+/**
+ * @tc.name: AbnormalKvStoreTest002
+ * @tc.desc: Test KvStoreNbDelegateImpl interface while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, AbnormalKvStoreTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. GetKvStore for initialize g_kvNbDelegatePtr.
+     * @tc.expected: step1. Success.
+     */
+    KvStoreNbDelegate::Option option = {true, false, false};
+    g_mgr.GetKvStore("AbnormalKvStoreTest002", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    InitResultSet();
+
+    /**
+     * @tc.steps: step2. test KvStoreNbDelegateImpl interface while conn is nullptr.
+     * @tc.expected: step2. return DB_ERROR.
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvNbDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+
+    Query query;
+    EXPECT_EQ(kvStoreImpl->SubscribeRemoteQuery({}, nullptr, query, true), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->UnSubscribeRemoteQuery({}, nullptr, query, true), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->RemoveDeviceData(), DB_ERROR);
+    const Key key = {0};
+    std::vector<Key> keys;
+    EXPECT_EQ(kvStoreImpl->GetKeys(key, keys), DB_ERROR);
+    uint32_t expectedVal = 0;
+    EXPECT_EQ(kvStoreImpl->GetSyncDataSize(""), expectedVal);
+    EXPECT_EQ(kvStoreImpl->UpdateKey(nullptr), DB_ERROR);
+    const std::string device = "test";
+    std::pair<DBStatus, WatermarkInfo> info = kvStoreImpl->GetWatermarkInfo(device);
+    EXPECT_EQ(info.first, DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->GetTaskCount(), DB_ERROR);
+    EXPECT_EQ(kvStoreImpl->SetReceiveDataInterceptor(nullptr), DB_ERROR);
+    CloudSyncConfig config;
+    EXPECT_EQ(kvStoreImpl->SetCloudSyncConfig(config), DB_ERROR);
+    const IOption iOption;
+    std::vector<Entry> entries;
+    EXPECT_EQ(kvStoreImpl->GetEntries(key, entries), DB_ERROR);
+
+    /**
+     * @tc.steps: step3. close kvStore.
+     * @tc.expected: step3. Success.
+     */
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("AbnormalKvStoreTest002"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
+
+/**
+ * @tc.name: AbnormalKvStoreResultSetTest
+ * @tc.desc: Test KvStoreResultSetImpl interface when class para is nullptr.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBInterfacesNBDelegateTest, AbnormalKvStoreResultSetTest, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call interfaces when calss para is null.
+     * @tc.expected: step1. return failInfo.
+     */
+    KvStoreResultSetImpl kvStoreObj(nullptr);
+    EXPECT_EQ(kvStoreObj.GetCount(), 0);
+    EXPECT_EQ(kvStoreObj.GetPosition(), INIT_POSITION);
+    EXPECT_EQ(kvStoreObj.Move(0), false);
+    EXPECT_EQ(kvStoreObj.MoveToPosition(0), false);
+    EXPECT_EQ(kvStoreObj.MoveToFirst(), false);
+    EXPECT_EQ(kvStoreObj.MoveToLast(), false);
+    EXPECT_EQ(kvStoreObj.IsFirst(), false);
+    EXPECT_EQ(kvStoreObj.IsLast(), false);
+    EXPECT_EQ(kvStoreObj.IsBeforeFirst(), false);
+    EXPECT_EQ(kvStoreObj.IsAfterLast(), false);
+    std::vector<std::string> columnNames;
+    kvStoreObj.GetColumnNames(columnNames);
+    Entry entry;
+    EXPECT_EQ(kvStoreObj.GetEntry(entry), DB_ERROR);
+    EXPECT_EQ(kvStoreObj.IsClosed(), false);
+    kvStoreObj.Close();
+
+    /**
+     * @tc.steps: step2. Call unsupported interfaces.
+     * @tc.expected: step2. return NOT_SUPPORT.
+     */
+    std::string columnName;
+    int columnIndex = 0;
+    EXPECT_EQ(kvStoreObj.GetColumnIndex(columnName, columnIndex), NOT_SUPPORT);
+    EXPECT_EQ(kvStoreObj.GetColumnName(columnIndex, columnName), NOT_SUPPORT);
+    std::vector<uint8_t> vecVal;
+    EXPECT_EQ(kvStoreObj.Get(columnIndex, vecVal), NOT_SUPPORT);
+    std::string strVal;
+    EXPECT_EQ(kvStoreObj.Get(columnIndex, strVal), NOT_SUPPORT);
+    int64_t intVal;
+    EXPECT_EQ(kvStoreObj.Get(columnIndex, intVal), NOT_SUPPORT);
+    double doubleVal;
+    EXPECT_EQ(kvStoreObj.Get(columnIndex, doubleVal), NOT_SUPPORT);
+    bool isNull;
+    EXPECT_EQ(kvStoreObj.IsColumnNull(columnIndex, isNull), NOT_SUPPORT);
+    std::map<std::string, VariantData> data;
+    EXPECT_EQ(kvStoreObj.GetRow(data), NOT_SUPPORT);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_publish_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_publish_test.cpp
index fb6dd6a3a514af0edce8735f2905f8f83ff4cc5d..46fff6d32fa5715a9192cd5cf6e3ffd78c024677 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_publish_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_nb_publish_test.cpp
@@ -790,3 +790,42 @@ HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey011, TestSize.
     EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey011"), OK);
     g_kvNbDelegatePtr = nullptr;
 }
+
+/**
+  * @tc.name: SingleVerPublishKey012
+  * @tc.desc: Publish empty and illegal key
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+  */
+HWTEST_F(DistributedDBInterfacesNBPublishTest, SingleVerPublishKey012, TestSize.Level1)
+{
+    const KvStoreNbDelegate::Option option = {true, false};
+    g_mgr.GetKvStore("distributed_nb_publish_SingleVerPublishKey012", option, g_kvNbDelegateCallback);
+    ASSERT_TRUE(g_kvNbDelegatePtr != nullptr);
+    EXPECT_TRUE(g_kvDelegateStatus == OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->PutLocal(KEY_1, VALUE_1), OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_2, VALUE_2), OK);
+    /**
+     * @tc.steps:step1. PublishLocal empty and illegal key.
+     * @tc.expected: step1. return INVALID_ARGS.
+     */
+    Key key = {};
+    EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(key, true, true, nullptr), INVALID_ARGS);
+    Key illegalKey;
+    DistributedDBToolsUnitTest::GetRandomKeyValue(illegalKey, DBConstant::MAX_KEY_SIZE + 1); // 1K + 1
+    EXPECT_EQ(g_kvNbDelegatePtr->PublishLocal(illegalKey, true, true, nullptr), INVALID_ARGS);
+    /**
+     * @tc.steps:step2. Get value of key1 and key2 both from local and sync table
+     * @tc.expected: step2. value of key1 and key2 are correct
+     */
+    Value readValue;
+    EXPECT_EQ(g_kvNbDelegatePtr->Get(KEY_1, readValue), NOT_FOUND);
+    EXPECT_EQ(g_kvNbDelegatePtr->GetLocal(KEY_1, readValue), OK);
+    EXPECT_EQ(readValue, VALUE_1);
+
+    // finilize
+    EXPECT_EQ(g_mgr.CloseKvStore(g_kvNbDelegatePtr), OK);
+    EXPECT_EQ(g_mgr.DeleteKvStore("distributed_nb_publish_SingleVerPublishKey012"), OK);
+    g_kvNbDelegatePtr = nullptr;
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_query_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_query_test.cpp
index c59b1713e0f283109159a4678ba73446851b0121..d109fd5249021f7a7ee39255b383e7e75ddadf18 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_query_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_query_test.cpp
@@ -225,4 +225,60 @@ HWTEST_F(DistributedDBInterfacesQueryTest, Query003, TestSize.Level1)
     QueryExpression queryExpression1 = GetQueryInfo::GetQueryExpression(query1);
     EXPECT_TRUE(queryExpression1.GetErrFlag());
     EXPECT_EQ(queryExpression1.GetQueryExpression().size(), 2UL);
+}
+
+/**
+ * @tc.name: Query004
+ * @tc.desc: Check QueryExpression abnormal scene
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBInterfacesQueryTest, Query004, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. call comparison func when type is VALUE_TYPE_BOOL
+     * @tc.expected: step1. flag is false.
+     */
+    QueryExpression expression;
+    const FieldValue value = {};
+    expression.GreaterThanOrEqualTo("", QueryValueType::VALUE_TYPE_BOOL, value);
+    EXPECT_FALSE(expression.GetErrFlag());
+    expression.LessThanOrEqualTo("", QueryValueType::VALUE_TYPE_BOOL, value);
+    EXPECT_FALSE(expression.GetErrFlag());
+
+    /**
+     * @tc.steps: step2. call RangeParamCheck func with operFlag OPER_ILLEGAL
+     * @tc.expected: step2. flag is false.
+     */
+    expression.GetQueryExpression();
+    EXPECT_EQ(expression.RangeParamCheck(), -E_INVALID_ARGS);
+    EXPECT_FALSE(expression.GetErrFlag());
+    expression.Reset();
+    EXPECT_TRUE(expression.GetErrFlag());
+
+    /**
+     * @tc.steps: step3. call From func when tables_ is empty
+     * @tc.expected: step3. -E_INVALID_ARGS.
+     */
+    EXPECT_EQ(expression.GetExpressionStatus(), E_OK);
+    const std::string tableName1;
+    expression.From(tableName1);
+    const std::string tableName2 = "test2";
+    for (size_t i = 0; i < 2; i++) { // 传入相同tableName2次
+        expression.From(tableName2);
+    }
+    EXPECT_EQ(expression.GetExpressionStatus(), -E_INVALID_ARGS);
+
+    /**
+     * @tc.steps: step4. call From func when tables_ is not empty
+     * @tc.expected: step4. -E_NOT_SUPPORT.
+     */
+    QueryExpression expression1;
+    EXPECT_EQ(expression1.GetExpressionStatus(), E_OK);
+    const std::vector<std::string> tableNames = {tableName1, tableName2};
+    expression1.SetTables(tableNames);
+    const std::string tableName3 = "test3";
+    expression1.From(tableName3);
+    EXPECT_EQ(expression1.GetExpressionStatus(), -E_NOT_SUPPORT);
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
index 229b7dfc7bf0db3a21a07d76af27edbc77d737b8..10f0c9034c56c01b28c19b7cef6ee1f661ad4b3f 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_sync_test.cpp
@@ -19,6 +19,7 @@
 #include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_unit_test.h"
 #include "log_print.h"
+#include "relational_store_delegate_impl.h"
 #include "relational_store_manager.h"
 #include "relational_virtual_device.h"
 #include "runtime_config.h"
@@ -1090,3 +1091,63 @@ HWTEST_F(DistributedDBInterfacesRelationalSyncTest, RelationalSyncRangeTest001,
 
     EXPECT_EQ(errCode, NOT_SUPPORT);
 }
+
+/**
+  * @tc.name: RelationalSyncTest011
+  * @tc.desc: Test sync with invalid parm
+  * @tc.type: FUNC
+  * @tc.require:
+  * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBInterfacesRelationalSyncTest, RelationalSyncTest011, TestSize.Level1)
+{
+    sqlite3 *db = RelationalTestUtils::CreateDataBase(g_dbDir + STORE_ID + DB_SUFFIX);
+    ASSERT_NE(db, nullptr);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "PRAGMA journal_mode=WAL;"), SQLITE_OK);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, "CREATE TABLE IF NOT EXISTS t2(a INT, b TEXT)"), SQLITE_OK);
+    AddDeviceSchema(g_deviceB, db, "t2");
+    RelationalStoreDelegate *delegate = nullptr;
+    auto observer = new (std::nothrow) RelationalStoreObserverUnitTest();
+    DBStatus status = g_mgr.OpenStore(g_dbDir + STORE_ID + DB_SUFFIX, STORE_ID,
+        { .observer = observer }, delegate);
+    EXPECT_EQ(status, OK);
+    ASSERT_NE(delegate, nullptr);
+    EXPECT_EQ(delegate->CreateDistributedTable("t2"), OK);
+
+    std::vector<std::string> devices = {DEVICE_B};
+    Query query = Query::Select("t2");
+    EXPECT_EQ(delegate->Sync(devices, SyncMode::SYNC_MODE_CLOUD_MERGE, query, nullptr, true), NOT_SUPPORT);
+
+    auto relationalStoreImpl = static_cast<RelationalStoreDelegateImpl *>(delegate);
+    EXPECT_EQ(relationalStoreImpl->Close(), OK);
+    EXPECT_EQ(delegate->Sync(devices, SyncMode::SYNC_MODE_PULL_ONLY, query, nullptr, true), DB_ERROR);
+
+    std::mutex dataMutex;
+    std::condition_variable cv;
+    bool finish = false;
+    auto callback = [&cv, &dataMutex, &finish, &status](const std::map<std::string, SyncProcess> &process) {
+        for (const auto &item: process) {
+            if (item.second.process == DistributedDB::FINISHED) {
+                {
+                    EXPECT_EQ(item.second.errCode, status);
+                    std::lock_guard<std::mutex> autoLock(dataMutex);
+                    finish = true;
+                }
+                cv.notify_one();
+            }
+        }
+    };
+    int64_t syncWaitTime = 60;
+    EXPECT_EQ(delegate->Sync(devices, SyncMode::SYNC_MODE_PULL_ONLY, query, callback, syncWaitTime), DB_ERROR);
+
+    CloudSyncOption option;
+    option.devices = devices;
+    option.mode = SyncMode::SYNC_MODE_PULL_ONLY;
+    option.query = query;
+    option.waitTime = syncWaitTime;
+    EXPECT_EQ(delegate->Sync(option, callback), DB_ERROR);
+
+    EXPECT_EQ(g_mgr.CloseStore(delegate), OK);
+    EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
+    delete observer;
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_tracker_table_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_tracker_table_test.cpp
index 60aab138d2481e6902659ba74ca8c4506a8fb97c..17ad56bc41225387d590c04703c4d9b567c9aee8 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_tracker_table_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_relational_tracker_table_test.cpp
@@ -132,8 +132,9 @@ namespace {
 
     void BatchOperatorTableName2Data(uint64_t num, const std::set<std::string> &colNames)
     {
-        BatchInsertTableName2Data(num);
-        BatchInsertTableName2Data(num);
+        for (int i = 0; i < HALF; i++) {
+            BatchInsertTableName2Data(num);
+        }
         BatchUpdateTableName2Data(num, colNames);
         BatchDeleteTableName2Data(num);
     }
@@ -148,7 +149,7 @@ namespace {
         while (SQLiteUtils::StepWithRetry(stmt) == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
             std::string extendVal;
             EXPECT_EQ(SQLiteUtils::GetColumnTextValue(stmt, 0, extendVal), E_OK);
-            ASSERT_NE(num, 0u);
+            ASSERT_NE(num, 0ul);
             EXPECT_EQ(extendVal, "Local" + std::to_string(index % num));
             std::string cursorVal;
             EXPECT_EQ(SQLiteUtils::GetColumnTextValue(stmt, 1, cursorVal), E_OK);
@@ -513,6 +514,18 @@ HWTEST_F(DistributedDBInterfacesRelationalTrackerTableTest, TrackerTableTest007,
      * @tc.expected: step3. Return OK.
      */
     CheckExtendAndCursor(num, 0);
+
+    /**
+     * @tc.steps:step4. update extend field and check
+     * @tc.expected: step4. Return OK.
+     */
+    EXPECT_EQ(g_delegate->SetTrackerTable(g_normalSchema3), OK);
+    std::string sql = "UPDATE " + TABLE_NAME2 + " SET age='666'";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(g_db, sql), SQLITE_OK);
+    sql = "select count(*) from " + DBCommon::GetLogTableName(TABLE_NAME2) +
+        " where extend_field=666;";
+    EXPECT_EQ(sqlite3_exec(g_db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(num), nullptr), SQLITE_OK);
     CloseStore();
 }
 
@@ -1185,7 +1198,7 @@ HWTEST_F(DistributedDBInterfacesRelationalTrackerTableTest, TrackerTableTest023,
      */
     string querySql = "select cursor from " + DBConstant::RELATIONAL_PREFIX + TABLE_NAME2 + "_log";
     sqlite3_stmt *stmt = nullptr;
-    int index = 0;
+    int index = 20;
     EXPECT_EQ(SQLiteUtils::GetStatement(g_db, querySql, stmt), E_OK);
     while (SQLiteUtils::StepWithRetry(stmt) == SQLiteUtils::MapSQLiteErrno(SQLITE_ROW)) {
         std::string cursorVal;
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_single_version_result_set_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_single_version_result_set_test.cpp
index 0813b176293752b7a1556a4cffe963c93d9ba9ba..db872744705a0ca38595a1480398e708a090b8d3 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_single_version_result_set_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/interfaces/distributeddb_interfaces_single_version_result_set_test.cpp
@@ -123,9 +123,9 @@ void DistributedDBInterfacesSingleVersionResultSetTest::SetUp(void)
     IOption option;
     option.dataType = IOption::SYNC_DATA;
     g_connection->Clear(option);
-    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_1, VALUE_1), OK);
-    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_2, VALUE_2), OK);
-    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_3, VALUE_3), OK);
+    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_1, VALUE_1), E_OK);
+    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_2, VALUE_2), E_OK);
+    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_3, VALUE_3), E_OK);
 
     EXPECT_EQ(errCode, E_OK);
     g_rawCursor = new (std::nothrow) SQLiteSingleVerForwardCursor(g_store, KEY_PREFIX);
@@ -383,7 +383,7 @@ HWTEST_F(DistributedDBInterfacesSingleVersionResultSetTest, SingleVersionResultS
      */
     IOption option;
     option.dataType = IOption::SYNC_DATA;
-    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_4, VALUE_4), OK);
+    ASSERT_EQ(g_connection->Put(option, LOCAL_KEY_4, VALUE_4), E_OK);
 
     /**
      * @tc.steps:step4. Get the total count.
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp
index 80dc496b279a9895715eb0af063ac4e3f1795e31..80711fea688143d3babb9aeb5ea77b90a67c6d22 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_assets_operation_sync_test.cpp
@@ -46,6 +46,7 @@ const Asset g_localAsset = {
     .version = 2, .name = "Phone", .assetId = "0", .subpath = "/local/sync", .uri = "/cloud/sync",
     .modifyTime = "123456", .createTime = "0", .size = "1024", .hash = "DEC"
 };
+SyncProcess lastProcess_;
 
 void CreateUserDBAndTable(sqlite3 *&db)
 {
@@ -58,13 +59,15 @@ void BlockSync(const Query &query, RelationalStoreDelegate *delegate)
     std::mutex dataMutex;
     std::condition_variable cv;
     bool finish = false;
-    auto callback = [&cv, &dataMutex, &finish](const std::map<std::string, SyncProcess> &process) {
+    SyncProcess last;
+    auto callback = [&last, &cv, &dataMutex, &finish](const std::map<std::string, SyncProcess> &process) {
         for (const auto &item: process) {
             if (item.second.process == DistributedDB::FINISHED) {
                 {
                     std::lock_guard<std::mutex> autoLock(dataMutex);
                     finish = true;
                 }
+                last = item.second;
                 cv.notify_one();
             }
         }
@@ -75,6 +78,7 @@ void BlockSync(const Query &query, RelationalStoreDelegate *delegate)
     cv.wait(uniqueLock, [&finish]() {
         return finish;
     });
+    lastProcess_ = last;
     LOGW("end call sync");
 }
 
@@ -88,11 +92,12 @@ protected:
     void InitTestDir();
     DataBaseSchema GetSchema();
     void CloseDb();
-    void InsertUserTableRecord(const std::string &tableName, int64_t begin, int64_t count, int64_t photoSize,
-        bool assetIsNull);
+    void InsertUserTableRecord(const std::string &tableName, int64_t begin, int64_t count, size_t assetCount = 2u,
+        const Assets &templateAsset = {});
     void CheckAssetsCount(const std::vector<size_t> &expectCount);
     void UpdateCloudTableRecord(int64_t begin, int64_t count, bool assetIsNull);
     void ForkDownloadAndRemoveAsset(DBStatus removeStatus, int &downLoadCount, int &removeCount);
+    std::vector<Asset> GetAssets(const std::string &baseName, const Assets &templateAsset, size_t assetCount);
     std::string testDir_;
     std::string storePath_;
     sqlite3 *db_ = nullptr;
@@ -182,9 +187,9 @@ void DistributedDBCloudAssetsOperationSyncTest::CloseDb()
 }
 
 void DistributedDBCloudAssetsOperationSyncTest::InsertUserTableRecord(const std::string &tableName, int64_t begin,
-    int64_t count, int64_t photoSize, bool assetIsNull)
+    int64_t count, size_t assetCount, const Assets &templateAsset)
 {
-    std::string photo(photoSize, 'v');
+    std::string photo = "phone";
     int errCode;
     std::vector<uint8_t> assetBlob;
     std::vector<uint8_t> assetsBlob;
@@ -194,30 +199,38 @@ void DistributedDBCloudAssetsOperationSyncTest::InsertUserTableRecord(const std:
         Asset asset = g_localAsset;
         asset.name = name;
         RuntimeContext::GetInstance()->AssetToBlob(asset, assetBlob);
-        std::vector<Asset> assets;
-        asset.name = name + "_1";
-        asset.status = static_cast<uint32_t>(AssetStatus::INSERT);
-        assets.push_back(asset);
-        asset.name = name + "_2";
-        assets.push_back(asset);
+        std::vector<Asset> assets = GetAssets(name, templateAsset, assetCount);
         string sql = "INSERT OR REPLACE INTO " + tableName +
             " (id, name, height, photo, asset, assets, age) VALUES ('" + std::to_string(i) +
             "', 'local', '178.0', '" + photo + "', ?, ?, '18');";
         sqlite3_stmt *stmt = nullptr;
         ASSERT_EQ(SQLiteUtils::GetStatement(db_, sql, stmt), E_OK);
         RuntimeContext::GetInstance()->AssetsToBlob(assets, assetsBlob);
-        if (assetIsNull) {
-            ASSERT_EQ(sqlite3_bind_null(stmt, 1), SQLITE_OK);
-            ASSERT_EQ(sqlite3_bind_null(stmt, index2), SQLITE_OK);
-        } else {
-            ASSERT_EQ(SQLiteUtils::BindBlobToStatement(stmt, 1, assetBlob, false), E_OK);
-            ASSERT_EQ(SQLiteUtils::BindBlobToStatement(stmt, index2, assetsBlob, false), E_OK);
-        }
+        ASSERT_EQ(SQLiteUtils::BindBlobToStatement(stmt, 1, assetBlob, false), E_OK);
+        ASSERT_EQ(SQLiteUtils::BindBlobToStatement(stmt, index2, assetsBlob, false), E_OK);
         EXPECT_EQ(SQLiteUtils::StepWithRetry(stmt), SQLiteUtils::MapSQLiteErrno(SQLITE_DONE));
         SQLiteUtils::ResetStatement(stmt, true, errCode);
     }
 }
 
+std::vector<Asset> DistributedDBCloudAssetsOperationSyncTest::GetAssets(const std::string &baseName,
+    const Assets &templateAsset, size_t assetCount)
+{
+    std::vector<Asset> assets;
+    for (size_t i = 1; i <= assetCount; ++i) {
+        Asset asset;
+        if (i - 1 < templateAsset.size()) {
+            asset = templateAsset[i - 1];
+        } else {
+            asset = g_localAsset;
+            asset.name = baseName + "_" + std::to_string(i);
+            asset.status = static_cast<uint32_t>(AssetStatus::INSERT);
+        }
+        assets.push_back(asset);
+    }
+    return assets;
+}
+
 void DistributedDBCloudAssetsOperationSyncTest::UpdateCloudTableRecord(int64_t begin, int64_t count, bool assetIsNull)
 {
     std::vector<VBucket> record;
@@ -234,7 +247,9 @@ void DistributedDBCloudAssetsOperationSyncTest::UpdateCloudTableRecord(int64_t b
             asset.name = "Phone_" + std::to_string(j);
             asset.assetId = std::to_string(j);
             asset.status = AssetStatus::UPDATE;
+            assets.push_back(asset);
         }
+        data.insert_or_assign("assets", assets);
         record.push_back(data);
         VBucket log;
         log.insert_or_assign(CloudDbConstant::CREATE_FIELD, static_cast<int64_t>(
@@ -304,10 +319,9 @@ void DistributedDBCloudAssetsOperationSyncTest::ForkDownloadAndRemoveAsset(DBSta
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation001, TestSize.Level0)
 {
     const int actualCount = 10;
-    const int photoSize = 10;
     const int deleteDataCount = 5;
     const int deleteAssetsCount = 4;
-    InsertUserTableRecord(tableName_, 0, photoSize, actualCount, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     std::string tableName = tableName_;
     virtualCloudDb_->ForkUpload([this, deleteDataCount, deleteAssetsCount](const std::string &, VBucket &) {
         for (int64_t i = 0; i < deleteDataCount; i++) {
@@ -338,7 +352,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation001, T
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation002, TestSize.Level0)
 {
     const int actualCount = 1;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     BlockSync(query, delegate_);
     int downLoadCount = 0;
@@ -364,7 +378,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation002, T
  */
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation003, TestSize.Level0)
 {
-    InsertUserTableRecord(tableName_, 0, 1, 10, false); // 1 is size, 10 is count
+    InsertUserTableRecord(tableName_, 0, 1); // 1 is count
     int uploadCount = 0;
     virtualCloudDb_->ForkUpload([this, &uploadCount](const std::string &, VBucket &) {
         if (uploadCount > 0) {
@@ -410,7 +424,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation003, T
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation004, TestSize.Level0)
 {
     const int actualCount = 5; // 5 record
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     BlockSync(query, delegate_);
     int downLoadCount = 0;
@@ -423,7 +437,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation004, T
     virtualAssetLoader_->ForkDownload(nullptr);
     virtualAssetLoader_->ForkRemoveLocalAssets(nullptr);
 
-    std::vector<size_t> expectCount = { 0, 0, 0, 0, 0 };
+    std::vector<size_t> expectCount = { 0, 2, 2, 2, 2 };
     CheckAssetsCount(expectCount);
 }
 
@@ -437,7 +451,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetOperation004, T
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord001, TestSize.Level0)
 {
     const int actualCount = 1;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     BlockSync(query, delegate_);
     std::vector<size_t> expectCount = { 2 };
@@ -470,7 +484,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord001, TestSize.Le
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord002, TestSize.Level0)
 {
     const int actualCount = 1;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     RelationalTestUtils::CloudBlockSync(query, delegate_);
     UpdateCloudTableRecord(0, actualCount, false);
@@ -478,7 +492,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord002, TestSize.Le
     virtualAssetLoader_->SetDownloadStatus(DBStatus::CLOUD_RECORD_EXIST_CONFLICT);
     RelationalTestUtils::CloudBlockSync(query, delegate_);
     virtualAssetLoader_->SetDownloadStatus(DBStatus::OK);
-    std::vector<size_t> expectCount = { 2 };
+    std::vector<size_t> expectCount = { 4 };
     CheckAssetsCount(expectCount);
     RelationalTestUtils::CloudBlockSync(query, delegate_);
 }
@@ -493,7 +507,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord002, TestSize.Le
 HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, IgnoreRecord003, TestSize.Level0)
 {
     const int actualCount = 1;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     virtualCloudDb_->SetConflictInUpload(true);
     RelationalTestUtils::CloudBlockSync(query, delegate_);
@@ -514,7 +528,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UpsertData001, TestSize.Leve
 {
     // insert id 0 to local
     const int actualCount = 1;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false); // 10 is phone size
+    InsertUserTableRecord(tableName_, 0, actualCount); // 10 is phone size
     std::vector<std::map<std::string, std::string>> conditions;
     std::map<std::string, std::string> entries;
     entries["id"] = "0";
@@ -544,7 +558,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UpsertData002, TestSize.Leve
      * @tc.expected: step1. ok.
      */
     const int actualCount = 5;
-    InsertUserTableRecord(tableName_, 0, actualCount, 10, false); // 10 is photo size
+    InsertUserTableRecord(tableName_, 0, actualCount);
     Query query = Query::Select().FromTable({ tableName_ });
     BlockSync(query, delegate_);
 
@@ -588,7 +602,7 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, SyncWithAssetConflict001, Te
     const int actualCount = 1;
     RelationalTestUtils::InsertCloudRecord(0, actualCount, tableName_, virtualCloudDb_);
     std::this_thread::sleep_for(std::chrono::seconds(1)); // sleep 1s for data conflict
-    InsertUserTableRecord(tableName_, 0, actualCount, 1, false);
+    InsertUserTableRecord(tableName_, 0, actualCount);
     // sync and local asset's status are normal
     Query query = Query::Select().FromTable({ tableName_ });
     RelationalTestUtils::CloudBlockSync(query, delegate_);
@@ -703,5 +717,153 @@ HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UpsertDataInvalid002, TestSi
     delegate1 = nullptr;
     mgr1 = nullptr;
 }
+
+/**
+ * @tc.name: UploadAssetsTest001
+ * @tc.desc: Test upload asset with error.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UploadAssetsTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps:step1. Insert 10 records.
+     * @tc.expected: step1. ok.
+     */
+    const int actualCount = 10;
+    InsertUserTableRecord(tableName_, 0, actualCount);
+    /**
+     * @tc.steps:step2. Set callback function to cause some upstream data to fail.
+     * @tc.expected: step2. ok.
+     */
+    int recordIndex = 0;
+    Asset tempAsset = {
+            .version = 2, .name = "Phone", .assetId = "0", .subpath = "/local/sync", .uri = "/cloud/sync",
+            .modifyTime = "123456", .createTime = "0", .size = "1024", .hash = "DEC"
+    };
+    virtualCloudDb_->ForkUpload([&tempAsset, &recordIndex](const std::string &tableName, VBucket &extend) {
+        Asset asset;
+        Assets assets;
+        switch (recordIndex) {
+            case 0: // record[0] is successful because ERROR_FIELD is not verified when BatchInsert returns OK status.
+                extend[std::string(CloudDbConstant::ERROR_FIELD)] = static_cast<int64_t>(DBStatus::CLOUD_ERROR);
+                break;
+            case 1: // record[1] is considered successful because it is a conflict.
+                extend[std::string(CloudDbConstant::ERROR_FIELD)] =
+                    static_cast<int64_t>(DBStatus::CLOUD_RECORD_EXIST_CONFLICT);
+                break;
+            case 2: // record[2] fail because of empty gid.
+                extend[std::string(CloudDbConstant::GID_FIELD)] = std::string("");
+                break;
+            case 3: // record[3] fail because of empty assetId.
+                asset = tempAsset;
+                asset.assetId = "";
+                extend[std::string(CloudDbConstant::ASSET)] = asset;
+                break;
+            case 4: // record[4] fail because of empty assetId.
+                assets.push_back(tempAsset);
+                assets[0].assetId = "";
+                extend[std::string(CloudDbConstant::ASSETS)] = assets;
+                break;
+            case 5: // record[5] is successful because ERROR_FIELD is not verified when BatchInsert returns OK status.
+                extend[std::string(CloudDbConstant::ERROR_FIELD)] = std::string("");
+                break;
+            default:
+                break;
+        }
+        recordIndex++;
+    });
+    /**
+     * @tc.steps:step3. Sync and check upLoadInfo.
+     * @tc.expected: step3. failCount is 5 and successCount is 5.
+     */
+    Query query = Query::Select().FromTable({ tableName_ });
+    BlockSync(query, delegate_);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 10u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 3u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 7u);
+    }
+    virtualCloudDb_->ForkUpload(nullptr);
+}
+
+/**
+ * @tc.name: UploadAssetsTest002
+ * @tc.desc: Test upload asset with error.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UploadAssetsTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps:step1. Insert 10 records.
+     * @tc.expected: step1. ok.
+     */
+    const int actualCount = 10;
+    InsertUserTableRecord(tableName_, 0, actualCount);
+    Query query = Query::Select().FromTable({ tableName_ });
+    BlockSync(query, delegate_);
+    /**
+     * @tc.steps:step2. Delete local data.
+     * @tc.expected: step2. OK.
+     */
+    std::string sql = "delete from " + tableName_ + " where id >= " + std::to_string(actualCount / 2);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db_, sql), SQLITE_OK);
+    /**
+     * @tc.steps:step3. Set callback function to cause some upstream data to fail.
+     * @tc.expected: step3. ok.
+     */
+    virtualCloudDb_->ForkUpload([](const std::string &tableName, VBucket &extend) {
+        extend[std::string(CloudDbConstant::GID_FIELD)] = "";
+    });
+    BlockSync(query, delegate_);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 5u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 0u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 5u);
+    }
+    virtualCloudDb_->ForkUpload(nullptr);
+}
+
+/**
+ * @tc.name: UploadAssetsTest003
+ * @tc.desc: Test upload asset with error CLOUD_RECORD_ALREADY_EXISTED.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudAssetsOperationSyncTest, UploadAssetsTest003, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. Insert 100 records.
+     * @tc.expected: step1. ok.
+     */
+    const int actualCount = 100;
+    InsertUserTableRecord(tableName_, 0, actualCount);
+    /**
+     * @tc.steps:step2. Set callback function to return CLOUD_RECORD_ALREADY_EXISTED in 1st batch.
+     * @tc.expected: step2. ok.
+     */
+    int uploadCount = 0;
+    virtualCloudDb_->ForkUpload([&uploadCount](const std::string &tableName, VBucket &extend) {
+        if (uploadCount < 30) { // There are a total of 30 pieces of data in one batch of upstream data
+            extend[std::string(CloudDbConstant::ERROR_FIELD)] =
+                static_cast<int64_t>(DBStatus::CLOUD_RECORD_ALREADY_EXISTED);
+        }
+        uploadCount++;
+    });
+    Query query = Query::Select().FromTable({ tableName_ });
+    BlockSync(query, delegate_);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.batchIndex, 4u);
+        EXPECT_EQ(table.second.upLoadInfo.total, 70u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 0u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 70u);
+        EXPECT_EQ(table.second.process, ProcessStatus::FINISHED);
+    }
+    virtualCloudDb_->ForkUpload(nullptr);
+}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_check_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_check_sync_test.cpp
index b79dba4244a0cdd3c5506f13c6c6568e6788e535..308e8f105269c2200b8764a172bab0721c4ee7c5 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_check_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_check_sync_test.cpp
@@ -57,6 +57,7 @@ const Asset g_cloudAsset = {
 };
 
 std::vector<DBStatus> g_actualDBStatus;
+std::map<std::string, SyncProcess> lastProcess_;
 
 void CreateUserDBAndTable(sqlite3 *&db)
 {
@@ -75,7 +76,8 @@ void PrepareOption(CloudSyncOption &option, const Query &query, bool isPriorityT
     option.compensatedSyncOnly = isCompensatedSyncOnly;
 }
 
-void BlockSync(const Query &query, RelationalStoreDelegate *delegate, std::vector<DBStatus> &actualDBStatus)
+void BlockSync(const Query &query, RelationalStoreDelegate *delegate, std::vector<DBStatus> &actualDBStatus,
+    bool prioritySync = false)
 {
     std::mutex dataMutex;
     std::condition_variable cv;
@@ -92,7 +94,13 @@ void BlockSync(const Query &query, RelationalStoreDelegate *delegate, std::vecto
             }
         }
     };
-    ASSERT_EQ(delegate->Sync({ "CLOUD" }, SYNC_MODE_CLOUD_MERGE, query, callback, g_syncWaitTime), OK);
+    CloudSyncOption option;
+    option.devices = { "CLOUD" };
+    option.mode = SYNC_MODE_CLOUD_MERGE;
+    option.query = query;
+    option.waitTime = g_syncWaitTime;
+    option.priorityTask = prioritySync;
+    ASSERT_EQ(delegate->Sync(option, callback), OK);
     std::unique_lock<std::mutex> uniqueLock(dataMutex);
     cv.wait(uniqueLock, [&finish]() {
         return finish;
@@ -105,7 +113,8 @@ void BlockPrioritySync(const Query &query, RelationalStoreDelegate *delegate, bo
     std::mutex dataMutex;
     std::condition_variable cv;
     bool finish = false;
-    auto callback = [&cv, &dataMutex, &finish](const std::map<std::string, SyncProcess> &process) {
+    std::map<std::string, SyncProcess> last;
+    auto callback = [&last, &cv, &dataMutex, &finish](const std::map<std::string, SyncProcess> &process) {
         for (const auto &item: process) {
             if (item.second.process == DistributedDB::FINISHED) {
                 {
@@ -115,6 +124,7 @@ void BlockPrioritySync(const Query &query, RelationalStoreDelegate *delegate, bo
                 cv.notify_one();
             }
         }
+        last = process;
     };
     CloudSyncOption option;
     PrepareOption(option, query, isPriority, isCompensatedSyncOnly);
@@ -125,6 +135,7 @@ void BlockPrioritySync(const Query &query, RelationalStoreDelegate *delegate, bo
             return finish;
         });
     }
+    lastProcess_ = last;
 }
 
 int QueryCountCallback(void *data, int count, char **colValue, char **colName)
@@ -166,7 +177,7 @@ protected:
     void DeleteCloudDBData(int64_t begin, int64_t count);
     void SetForkQueryForCloudPrioritySyncTest007(std::atomic<int> &count);
     void SetForkQueryForCloudPrioritySyncTest008(std::atomic<int> &count);
-    void InitLogicDeleteDataEnv(int64_t dataCount);
+    void InitLogicDeleteDataEnv(int64_t dataCount, bool prioritySync = false);
     void CheckLocalCount(int64_t expectCount);
     void CheckLogCleaned(int64_t expectCount);
     void SyncDataStatusTest(bool isCompensatedSyncOnly);
@@ -376,19 +387,17 @@ void DistributedDBCloudCheckSyncTest::PriorityAndNormalSync(const Query &normalQ
         const std::map<std::string, SyncProcess> &process) {
         for (const auto &item: process) {
             if (item.second.process == DistributedDB::FINISHED) {
-                {
-                    std::lock_guard<std::mutex> autoLock(dataMutex);
-                    normalFinish = true;
-                }
+                normalFinish = true;
                 ASSERT_EQ(priorityFinish, true);
                 cv.notify_one();
             }
         }
     };
-    auto priorityCallback = [&priorityFinish](const std::map<std::string, SyncProcess> &process) {
+    auto priorityCallback = [&cv, &priorityFinish](const std::map<std::string, SyncProcess> &process) {
         for (const auto &item: process) {
             if (item.second.process == DistributedDB::FINISHED) {
                 priorityFinish = true;
+                cv.notify_one();
             }
         }
     };
@@ -397,6 +406,7 @@ void DistributedDBCloudCheckSyncTest::PriorityAndNormalSync(const Query &normalQ
     virtualCloudDb_->SetBlockTime(500); // 500 ms
     ASSERT_EQ(delegate->Sync(option, normalCallback), OK);
     PrepareOption(option, priorityQuery, true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 50 ms
     ASSERT_EQ(delegate->Sync(option, priorityCallback), OK);
     std::unique_lock<std::mutex> uniqueLock(dataMutex);
     cv.wait(uniqueLock, [&normalFinish]() {
@@ -451,7 +461,7 @@ void DistributedDBCloudCheckSyncTest::SetForkQueryForCloudPrioritySyncTest008(st
     });
 }
 
-void DistributedDBCloudCheckSyncTest::InitLogicDeleteDataEnv(int64_t dataCount)
+void DistributedDBCloudCheckSyncTest::InitLogicDeleteDataEnv(int64_t dataCount, bool prioritySync)
 {
     // prepare data
     InsertUserTableRecord(tableName_, dataCount);
@@ -519,7 +529,7 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, CloudSyncTest001, TestSize.Level0)
         dataCnt = sqlite3_column_int(stmt, 0);
         return E_OK;
     });
-    EXPECT_EQ(dataCnt, actualCount);
+    EXPECT_EQ(dataCnt, 0);
 }
 
 /**
@@ -847,10 +857,10 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, CloudPrioritySyncTest003, TestSize.Lev
     std::vector<std::string> idValue = {"0", "1", "2"};
     Query priorityQuery = Query::Select().From(tableName_).In("id", idValue);
     PriorityAndNormalSync(normalQuery, priorityQuery, delegate_);
-    CheckCloudTableCount(tableName_, 10); // 10 is count of cloud records
     EXPECT_EQ(virtualCloudDb_->GetLockCount(), 2);
     virtualCloudDb_->Reset();
     EXPECT_EQ(virtualCloudDb_->GetLockCount(), 0);
+    CheckCloudTableCount(tableName_, 10); // 10 is count of cloud records
 }
 
 /**
@@ -1401,11 +1411,11 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, LogicDeleteSyncTest001, TestSize.Level
     auto data = static_cast<PragmaData>(&logicDelete);
     delegate_->Pragma(LOGIC_DELETE_SYNC_DATA, data);
     int actualCount = 10;
-    InitLogicDeleteDataEnv(actualCount);
+    InitLogicDeleteDataEnv(actualCount, true);
     CheckLocalCount(actualCount);
     std::string device = "";
     ASSERT_EQ(delegate_->RemoveDeviceData(device, DistributedDB::FLAG_AND_DATA), DBStatus::OK);
-    CheckLocalCount(0);
+    CheckLocalCount(actualCount);
 }
 
 /**
@@ -1592,6 +1602,43 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, LogicDeleteSyncTest006, TestSize.Level
     }
 }
 
+/**
+ * @tc.name: LogicDeleteSyncTest008
+ * @tc.desc: Test sync when data with flag 0x800 locally but there is updated data on the cloud.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudCheckSyncTest, LogicDeleteSyncTest008, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. Insert user table record with flag 0x800. Insert cloud table record.
+     * @tc.expected: step1. ok.
+     */
+    int dataCount = 10;
+    uint32_t logicDeleteCount = 4;
+    InsertUserTableRecord(tableName_, dataCount);
+    std::string sql = "update " + DBCommon::GetLogTableName(tableName_) +
+        " set flag = flag | 0x800 where data_key <= " + std::to_string(logicDeleteCount);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db_, sql), E_OK);
+    InsertCloudTableRecord(0, dataCount, 0, false);
+    sql = "select count(*) from " + DBCommon::GetLogTableName(tableName_) + " where flag & 0x800=0x800";
+    EXPECT_EQ(sqlite3_exec(db_, sql.c_str(), QueryCountCallback,
+        reinterpret_cast<void *>(logicDeleteCount), nullptr), SQLITE_OK);
+    /**
+     * @tc.steps:step2. Do sync.
+     * @tc.expected: step2. ok.
+     */
+    Query query = Query::Select().FromTable({ tableName_ });
+    BlockSync(query, delegate_, g_actualDBStatus);
+    /**
+     * @tc.steps:step3. Check data flag in local DB.
+     * @tc.expected: step3. No data flag is 0x800.
+     */
+    EXPECT_EQ(sqlite3_exec(db_, sql.c_str(), QueryCountCallback,
+        reinterpret_cast<void *>(0), nullptr), SQLITE_OK);
+}
+
 /**
  * @tc.name: LogicCreateRepeatedTableNameTest001
  * @tc.desc: test create repeated table name with different cases
@@ -1818,8 +1865,8 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, SameDataSync002, TestSize.Level1)
     Timestamp now = TimeHelper::GetSysCurrentTime();
     VBucket data;
     std::vector<uint8_t> photo(0, 'v');
-    data.insert_or_assign("id", "0");
-    data.insert_or_assign("name", "Cloud");
+    data.insert_or_assign("id", std::string("0"));
+    data.insert_or_assign("name", std::string("Cloud"));
     data.insert_or_assign("height", 166.0); // 166.0 is random double value
     data.insert_or_assign("married", false);
     data.insert_or_assign("photo", photo);
@@ -1833,9 +1880,9 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, SameDataSync002, TestSize.Level1)
     log.insert_or_assign(CloudDbConstant::MODIFY_FIELD, static_cast<int64_t>(
         now / CloudDbConstant::TEN_THOUSAND));
     log.insert_or_assign(CloudDbConstant::DELETE_FIELD, false);
-    log.insert_or_assign(CloudDbConstant::VERSION_FIELD, "1");
+    log.insert_or_assign(CloudDbConstant::VERSION_FIELD, std::string("1"));
     extend.push_back(log);
-    log.insert_or_assign(CloudDbConstant::VERSION_FIELD, "2");
+    log.insert_or_assign(CloudDbConstant::VERSION_FIELD, std::string("2"));
     extend.push_back(log);
     ASSERT_EQ(virtualCloudDb_->BatchInsert(tableName_, std::move(record), extend), DBStatus::OK);
 
@@ -2060,4 +2107,4 @@ HWTEST_F(DistributedDBCloudCheckSyncTest, SyncDataStatusTest002, TestSize.Level1
     SyncDataStatusTest(false);
 }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp
index 8d9c6ed95ee29bde37df6299ddef3597b1077a04..c3ba47dca109e34e5a1be053c4a7d083965197eb 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_interfaces_relational_sync_test.cpp
@@ -423,7 +423,9 @@ namespace {
             ASSERT_EQ(RuntimeContext::GetInstance()->BlobToAssets(assetsBlob, assets), E_OK);
             for (const Asset &asset: assets) {
                 ASSERT_EQ(asset.status, static_cast<uint32_t>(AssetStatus::NORMAL));
-                ASSERT_EQ(asset.name, names[index++]);
+                ASSERT_EQ(asset.name, names[index]);
+                LOGE("lyh_test: name: %s", names[index].c_str());
+                index++;
             }
         }
         int errCode;
@@ -442,7 +444,7 @@ namespace {
             Assets &assets = std::get<Assets>(data[j]["asserts"]);
             ASSERT_TRUE(assets.size() > 0);
             Asset &asset = assets[0];
-            EXPECT_EQ(asset.status, static_cast<uint32_t>(AssetStatus::NORMAL));
+            EXPECT_EQ(asset.status, static_cast<uint32_t>(AssetStatus::DELETE));
             EXPECT_EQ(asset.flag, static_cast<uint32_t>(AssetOpType::DELETE));
         }
     }
@@ -1066,10 +1068,11 @@ namespace {
                 LOGD("Download GID:%s", gid.c_str());
                 for (auto &item: assets) {
                     for (auto &asset: item.second) {
-                        EXPECT_EQ(AssetOperationUtils::EraseBitMask(asset.status),
-                            static_cast<uint32_t>(AssetStatus::DOWNLOADING));
+                        uint32_t lowBitStatus = AssetOperationUtils::EraseBitMask(asset.status);
+                        EXPECT_TRUE(lowBitStatus == static_cast<uint32_t>(AssetStatus::INSERT) ||
+                            lowBitStatus == static_cast<uint32_t>(AssetStatus::UPDATE));
                         LOGD("asset [name]:%s, [status]:%u, [flag]:%u", asset.name.c_str(), asset.status, asset.flag);
-                        asset.status = (index++) % 5u + 1; // 5 is AssetStatus type num, include invalid type
+                        asset.status = (index++) % 5u + 1; // 6 is AssetStatus type num, include invalid type
                     }
                 }
                 return status;
@@ -1902,7 +1905,7 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalSyncTest, CloudSyncAssetTest003,
         g_processCondition.wait(lock, []() {
             return g_syncProcess.process == FINISHED;
         });
-        ASSERT_EQ(g_syncProcess.errCode, DBStatus::CLOUD_ERROR);
+        ASSERT_EQ(g_syncProcess.errCode, DBStatus::OK);
     }
     CloseDb();
 }
@@ -2324,7 +2327,7 @@ HWTEST_F(DistributedDBCloudInterfacesRelationalSyncTest, DownloadAssetTest004, T
      */
     g_syncProcess = {};
     InsertCloudTableRecord(0, count, paddingSize, false);
-    EXPECT_EQ(RelationalTestUtils::ExecSql(db, DROP_INTEGER_PRIMARY_KEY_TABLE_SQL), DBStatus::OK);
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, DROP_INTEGER_PRIMARY_KEY_TABLE_SQL), E_OK);
     EXPECT_EQ(g_delegate->Sync({ DEVICE_CLOUD }, SYNC_MODE_CLOUD_MERGE, query, callback, g_syncWaitTime),
         DBStatus::NOT_FOUND);
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_meta_data_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_meta_data_test.cpp
index 15a927bae40e9834d4f67af4b9e1711b4a433ecb..adf0ce80e14e654d5389085cc946716b127baa88 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_meta_data_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_meta_data_test.cpp
@@ -200,4 +200,192 @@ namespace {
         EXPECT_EQ(g_storageProxy->GetLocalWaterMark(TABLE_NAME_2, retLocalMark), E_OK);
         EXPECT_EQ(retLocalMark, 0u);
     }
+
+    /**
+    * @tc.name: AbnormalStorageProxyTest001
+    * @tc.desc: Check StorageProxy interfaces when para is invalid.
+    * @tc.type: FUNC
+    * @tc.require: DTS2024073106613
+    * @tc.author: suyue
+    */
+    HWTEST_F(DistributedDBCloudMetaDataTest, AbnormalStorageProxyTest001, TestSize.Level0)
+    {
+        /**
+         * @tc.steps: step1. Call interfaces when class para and db is null.
+         * @tc.expected: step1. return -E_INVALID_DB.
+         */
+        StorageProxy proxyObj(nullptr);
+        Timestamp retLocalMark;
+        EXPECT_EQ(proxyObj.GetLocalWaterMark(TABLE_NAME_1, retLocalMark), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.GetLocalWaterMarkByMode(TABLE_NAME_1, CloudWaterType::INSERT, retLocalMark), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.PutLocalWaterMark(TABLE_NAME_1, retLocalMark), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.PutWaterMarkByMode(TABLE_NAME_1, CloudWaterType::INSERT, retLocalMark), -E_INVALID_DB);
+        proxyObj.ReleaseUploadRecord(TABLE_NAME_1, CloudWaterType::INSERT, retLocalMark);
+        int64_t count = 0;
+        EXPECT_EQ(proxyObj.GetUploadCount(TABLE_NAME_1, retLocalMark, true, count), -E_INVALID_DB);
+        const QuerySyncObject query;
+        EXPECT_EQ(proxyObj.GetUploadCount(query, retLocalMark, true, true, count), -E_INVALID_DB);
+        ContinueToken continueStmtToken;
+        CloudSyncData cloudDataResult;
+        EXPECT_EQ(proxyObj.GetCloudData(query, retLocalMark, continueStmtToken, cloudDataResult), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.GetCloudDataNext(continueStmtToken, cloudDataResult), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.GetUploadCount(query, true, true, true, count), -E_INVALID_DB);
+        std::vector<std::string> strVec = {};
+        EXPECT_EQ(proxyObj.GetCloudGid(query, true, true, strVec), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.CheckSchema(strVec), -E_INVALID_DB);
+        std::vector<Field> assetFields;
+        EXPECT_EQ(proxyObj.GetPrimaryColNamesWithAssetsFields(TABLE_NAME_1, strVec, assetFields), -E_INVALID_DB);
+        std::vector<std::string> colNames = {"testColName"};
+        EXPECT_EQ(proxyObj.GetPrimaryColNamesWithAssetsFields(TABLE_NAME_1, colNames, assetFields), -E_INVALID_ARGS);
+        VBucket assetInfo;
+        DataInfoWithLog log;
+        EXPECT_EQ(proxyObj.GetInfoByPrimaryKeyOrGid(TABLE_NAME_1, assetInfo, log, assetInfo),
+            -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.FillCloudAssetForDownload(TABLE_NAME_1, assetInfo, true), -E_INVALID_DB);
+        const Bytes hashKey;
+        std::pair<int, uint32_t> res = proxyObj.GetAssetsByGidOrHashKey(TABLE_NAME_1, "", hashKey, assetInfo);
+        EXPECT_EQ(res.first, -E_INVALID_DB);
+        std::string str = proxyObj.GetIdentify();
+        const std::string emptyStr = "";
+        EXPECT_TRUE(str.compare(0, str.length(), emptyStr) == 0);
+        std::pair<int, CloudSyncData> ver = proxyObj.GetLocalCloudVersion();
+        EXPECT_EQ(ver.first, -E_INTERNAL_ERROR);
+        CloudSyncConfig cfg = proxyObj.GetCloudSyncConfig();
+        EXPECT_EQ(cfg.maxRetryConflictTimes, -1);
+        std::string cloudMark = "test";
+        EXPECT_EQ(proxyObj.GetCloudWaterMark(TABLE_NAME_1, cloudMark), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.SetCloudWaterMark(TABLE_NAME_1, cloudMark), -E_INVALID_DB);
+        const RelationalSchemaObject localSchema;
+        std::vector<Asset> assets = {};
+        EXPECT_EQ(proxyObj.CleanCloudData(ClearMode::DEFAULT, strVec, localSchema, assets), -E_INVALID_DB);
+    }
+
+    /**
+    * @tc.name: AbnormalStorageProxyTest002
+    * @tc.desc: Check StorageProxy interfaces when para is invalid.
+    * @tc.type: FUNC
+    * @tc.require: DTS2024073106613
+    * @tc.author: suyue
+    */
+    HWTEST_F(DistributedDBCloudMetaDataTest, AbnormalStorageProxyTest002, TestSize.Level0)
+    {
+        /**
+         * @tc.steps: step1. Call interfaces when class para and db is null.
+         * @tc.expected: step1. return -E_INVALID_DB.
+         */
+        StorageProxy proxyObj(nullptr);
+        DownloadData downloadData;
+        EXPECT_EQ(proxyObj.PutCloudSyncData(TABLE_NAME_1, downloadData), -E_INVALID_DB);
+        const std::set<std::string> gidFilters = {};
+        EXPECT_EQ(proxyObj.MarkFlagAsConsistent(TABLE_NAME_1, downloadData, gidFilters), -E_INVALID_DB);
+        bool isSharedTable = true;
+        EXPECT_EQ(proxyObj.IsSharedTable(TABLE_NAME_1, isSharedTable), -E_INVALID_DB);
+        CloudSyncData data;
+        proxyObj.FillCloudGidIfSuccess(OpType::INSERT, data);
+        const CloudTaskConfig config;
+        proxyObj.SetCloudTaskConfig(config);
+        std::vector<QuerySyncObject> syncQuery;
+        EXPECT_EQ(proxyObj.GetCompensatedSyncQuery(syncQuery), -E_INVALID_DB);
+        proxyObj.OnSyncFinish();
+        proxyObj.OnUploadStart();
+        std::shared_ptr<DataBaseSchema> cloudSchema;
+        EXPECT_EQ(proxyObj.GetCloudDbSchema(cloudSchema), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.CheckSchema(TABLE_NAME_1), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.NotifyChangedData(TABLE_NAME_1, {}), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.SetLogTriggerStatus(true), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.CleanWaterMark(TABLE_NAME_1), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.CleanWaterMarkInMemory(TABLE_NAME_1), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.CreateTempSyncTrigger(TABLE_NAME_1), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.IsTableExistReference(TABLE_NAME_1), false);
+        EXPECT_EQ(proxyObj.ClearAllTempSyncTrigger(), -E_INVALID_DB);
+        EXPECT_EQ(proxyObj.SetIAssetLoader(nullptr), -E_INVALID_DB);
+    }
+
+    /**
+     * @tc.name: AbnormalSyncAbleStorageTest001
+     * @tc.desc: Check RelationalSyncAbleStorage interfaces.
+     * @tc.type: FUNC
+     * @tc.require: DTS2024073106613
+     * @tc.author: suyue
+     */
+    HWTEST_F(DistributedDBCloudMetaDataTest, AbnormalSyncAbleStorageTest001, TestSize.Level0)
+    {
+        /**
+         * @tc.steps: step1. Call interfaces when RelationalSyncAbleStorage class para is null.
+         * @tc.expected: step1. return -E_INVALID_DB.
+         */
+        RelationalSyncAbleStorage obj(nullptr);
+        std::vector<Key> keys;
+        EXPECT_EQ(obj.DeleteMetaData(keys), -E_INVALID_DB);
+        EXPECT_EQ(obj.GetAllMetaKeys(keys), -E_INVALID_DB);
+        Key key;
+        Value value;
+        EXPECT_EQ(obj.GetMetaData(key, value), -E_INVALID_DB);
+        EXPECT_EQ(obj.PutMetaData(key, value), -E_INVALID_DB);
+        EXPECT_EQ(obj.PutMetaData(key, value, true), -E_INVALID_DB);
+        EXPECT_EQ(obj.DeleteMetaDataByPrefixKey(key), -E_INVALID_DB);
+        Timestamp timestamp;
+        obj.GetMaxTimestamp(timestamp);
+        EXPECT_EQ(obj.GetMaxTimestamp(TABLE_NAME_1, timestamp), -E_INVALID_DB);
+        QuerySyncObject querySync;
+        int64_t count;
+        EXPECT_EQ(obj.GetUploadCount(querySync, timestamp, true, true, count), -E_INVALID_DB);
+        TableSchema tableSchema;
+        ContinueToken token;
+        CloudSyncData data;
+        EXPECT_EQ(obj.GetCloudData(tableSchema, querySync, timestamp, token, data), -E_INVALID_DB);
+        std::vector<Timestamp> timestampVec;
+        EXPECT_EQ(obj.GetAllUploadCount(querySync, timestampVec, true, true, count), -E_INVALID_DB);
+        std::vector<std::string> cloudGid;
+        EXPECT_EQ(obj.GetCloudGid(tableSchema, querySync, true, true, cloudGid), -E_INVALID_DB);
+        EXPECT_EQ(obj.CheckQueryValid(querySync), -E_INVALID_DB);
+        std::vector<QuerySyncObject> resVec;
+        EXPECT_EQ(obj.LocalDataChanged(0, resVec), -E_NOT_SUPPORT);
+        VBucket assetInfo;
+        DataInfoWithLog log;
+        EXPECT_EQ(obj.GetInfoByPrimaryKeyOrGid(TABLE_NAME_1, assetInfo, log, assetInfo), -E_INVALID_DB);
+        EXPECT_EQ(obj.FillCloudAssetForDownload(TABLE_NAME_1, assetInfo, true), -E_INVALID_DB);
+        DownloadData downloadData;
+        EXPECT_EQ(obj.PutCloudSyncData(TABLE_NAME_1, downloadData), -E_INVALID_DB);
+        std::vector<std::string> strVec = {};
+        std::vector<Asset> assets = {};
+        const RelationalSchemaObject localSchema;
+        EXPECT_EQ(obj.CleanCloudData(ClearMode::DEFAULT, strVec, localSchema, assets), -E_INVALID_DB);
+        EXPECT_EQ(obj.SetLogTriggerStatus(true), -E_INVALID_DB);
+    }
+
+    /**
+     * @tc.name: AbnormalSyncAbleStorageTest002
+     * @tc.desc: Check RelationalSyncAbleStorage interfaces.
+     * @tc.type: FUNC
+     * @tc.require: DTS2024073106613
+     * @tc.author: suyue
+     */
+    HWTEST_F(DistributedDBCloudMetaDataTest, AbnormalSyncAbleStorageTest002, TestSize.Level0)
+    {
+        /**
+         * @tc.steps: step1. Call interfaces when RelationalSyncAbleStorage class para is null.
+         * @tc.expected: step1. return -E_INVALID_DB.
+         */
+        RelationalSyncAbleStorage obj(nullptr);
+        CloudSyncData cloudDataResult;
+        EXPECT_EQ(obj.FillCloudLogAndAsset(OpType::INSERT, cloudDataResult, true, true), -E_INVALID_DB);
+        std::string str = obj.GetIdentify();
+        const std::string emptyStr = "";
+        EXPECT_TRUE(str.compare(0, str.length(), emptyStr) == 0);
+        EXPECT_EQ(obj.CreateTempSyncTrigger(""), -E_INVALID_DB);
+        ChangeProperties properties;
+        EXPECT_EQ(obj.GetAndResetServerObserverData(TABLE_NAME_1, properties), -E_INVALID_DB);
+        std::vector<VBucket> records;
+        EXPECT_EQ(obj.UpsertData(RecordStatus::WAIT_COMPENSATED_SYNC, TABLE_NAME_1, records), -E_INVALID_DB);
+        LogInfo logInfo;
+        EXPECT_EQ(obj.UpdateRecordFlag(TABLE_NAME_1, true, logInfo), -E_INVALID_DB);
+        CloudSyncConfig config;
+        obj.SetCloudSyncConfig(config);
+        EXPECT_EQ(obj.SaveRemoteDeviceSchema(TABLE_NAME_1, "", 0), -E_INVALID_ARGS);
+        EXPECT_EQ(obj.RemoveDeviceData(TABLE_NAME_1, true), -E_NOT_SUPPORT);
+        EXPECT_EQ(obj.StartTransaction(TransactType::DEFERRED), -E_INVALID_DB);
+        EXPECT_EQ(obj.ClearAllTempSyncTrigger(), -E_INVALID_DB);
+        EXPECT_EQ(obj.SetIAssetLoader(nullptr), -E_INVALID_DB);
+    }
 }
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_reference_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_reference_sync_test.cpp
index 0eacdfa5c3aaf05c359e6f92efbb4c22015b490e..d3dccb19c893d9772bb21df539289b8319c5422d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_reference_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_reference_sync_test.cpp
@@ -637,6 +637,51 @@ HWTEST_F(DistributedDBCloudReferenceSyncTest, CloudSyncTest007, TestSize.Level0)
     CheckSharedDataAfterUpdated({166.0, 166.0}); // 166.0 is the height col val on the cloud
 }
 
+/**
+ * @tc.name: CloudSyncTest008
+ * @tc.desc: sync with dot storeId
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBCloudReferenceSyncTest, CloudSyncTest008, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. open store with dot store id
+     * @tc.expected: open ok.
+     */
+    RelationalStoreDelegate::Option option;
+    RelationalStoreDelegate *delegate = nullptr;
+    ASSERT_EQ(mgr_->OpenStore(storePath_, STORE_ID_1 + ".test", option, delegate), DBStatus::OK);
+    ASSERT_NE(delegate, nullptr);
+    EXPECT_EQ(delegate->SetCloudDB(virtualCloudDb_), DBStatus::OK);
+    EXPECT_EQ(delegate->SetIAssetLoader(std::make_shared<VirtualAssetLoader>()), DBStatus::OK);
+    EXPECT_EQ(delegate->CreateDistributedTable(parentTableName_, CLOUD_COOPERATION), DBStatus::OK);
+    EXPECT_EQ(delegate->CreateDistributedTable(childTableName_, CLOUD_COOPERATION), DBStatus::OK);
+    SetReference();
+    DataBaseSchema dataBaseSchema = GetSchema();
+    EXPECT_EQ(delegate->SetCloudDbSchema(dataBaseSchema), DBStatus::OK);
+    /**
+     * @tc.steps: step2. call cloud sync
+     * @tc.expected: sync ok.
+     */
+    std::vector<std::string> tableNames = { parentTableName_, childTableName_ };
+    Query query = Query::Select().FromTable(tableNames);
+    RelationalTestUtils::CloudBlockSync(query, delegate_);
+    /**
+     * @tc.steps: step3. insert data and cloud sync again
+     * @tc.expected: sync ok.
+     */
+    InsertUserTableRecord(parentTableName_, 1);
+    InsertUserTableRecord(childTableName_, 1);
+    RelationalTestUtils::CloudBlockSync(query, delegate_);
+    /**
+     * @tc.steps: step4. close store
+     * @tc.expected: close ok.
+     */
+    EXPECT_EQ(mgr_->CloseStore(delegate), DBStatus::OK);
+}
+
 void ComplexReferenceCheck001SetReference(RelationalStoreDelegate *delegate)
 {
     // the reference like this
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_save_cloud_data_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_save_cloud_data_test.cpp
index 56ae2d09e8e2b182fddbc92d08199fe5e702c9b0..80ac40adfd2dec3cdd5266ac4c04a9a15a46d6cb 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_save_cloud_data_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/cloud/distributeddb_cloud_save_cloud_data_test.cpp
@@ -872,7 +872,7 @@ namespace {
         EXPECT_NE(db, nullptr);
         int errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int64(stmt, 0), 1); // will get only 1 log record
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, SQLITE_OK);
         EXPECT_EQ(sqlite3_close_v2(db), E_OK);
@@ -1120,7 +1120,7 @@ namespace {
             EXPECT_EQ(sqlite3_column_int64(stmt, 1), BASE_MODIFY_TIME + 1);
             EXPECT_EQ(sqlite3_column_int(stmt, 2), 0x20|0x01); // 2 is flag
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 1);
@@ -1221,7 +1221,7 @@ namespace {
                 EXPECT_EQ(static_cast<uint16_t>(flag) & 0x04, 0);
             }
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 2); // 2 is result count
@@ -1276,7 +1276,7 @@ namespace {
         int errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [&count] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int(stmt, 0), 0);
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 1);
@@ -1346,7 +1346,7 @@ namespace {
         int errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [&count] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int(stmt, 0), 3); // 3 mean local delete
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 1);
@@ -1361,7 +1361,7 @@ namespace {
         count = 0;
         errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [&count] (sqlite3_stmt *stmt) {
             count++;
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(count, 1);
@@ -1503,7 +1503,7 @@ namespace {
             " where data_key in('10', '1')";
         int errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int(stmt, 0), 0x20|0x02);
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
 
@@ -1515,7 +1515,7 @@ namespace {
             " where data_key=-1 and cloud_gid !='';";
         errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int(stmt, 0), 0x20|0x03);
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
 
@@ -1527,7 +1527,7 @@ namespace {
               " where data_key=-1 and cloud_gid ='';";
         errCode = RelationalTestUtils::ExecSql(db, sql, nullptr, [] (sqlite3_stmt *stmt) {
             EXPECT_EQ(sqlite3_column_int(stmt, 0), 0x03);
-            return OK;
+            return E_OK;
         });
         EXPECT_EQ(errCode, E_OK);
         EXPECT_EQ(sqlite3_close_v2(db), SQLITE_OK);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp
index 69a7e8f9d292eeee1386dad881292390385cee4d..4394ca21f22b7ab3e45f163ef69e6ce961609a72 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_cloud_syncable_storage_test.cpp
@@ -87,10 +87,10 @@ void CreateDB()
     sqlite3_close(db);
 }
 
-void CreateLogTable()
+void CreateLogTable(const std::string &tableName)
 {
     TableInfo table;
-    table.SetTableName(g_tableName);
+    table.SetTableName(tableName);
     table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
     sqlite3 *db = nullptr;
     ASSERT_EQ(sqlite3_open(g_storePath.c_str(), &db), SQLITE_OK);
@@ -138,7 +138,8 @@ void CreateAndInitUserTable(int64_t count, int64_t photoSize, const Asset &expec
     sqlite3_close(db);
 }
 
-void InitLogData(int64_t insCount, int64_t updCount, int64_t delCount, int64_t excludeCount)
+void InitLogData(int64_t insCount, int64_t updCount, int64_t delCount, int64_t excludeCount,
+    const std::string &tableName)
 {
     sqlite3 *db = nullptr;
     ASSERT_EQ(sqlite3_open(g_storePath.c_str(), &db), SQLITE_OK);
@@ -160,7 +161,7 @@ void InitLogData(int64_t insCount, int64_t updCount, int64_t delCount, int64_t e
             cloudGid = "''";
         }
         Bytes hashKey(index.begin(), index.end());
-        string sql = "INSERT OR REPLACE INTO " + g_logTblName +
+        string sql = "INSERT OR REPLACE INTO " + tableName +
             " (data_key, device, ori_device, timestamp, wtimestamp, flag, hash_key, cloud_gid)" +
             " VALUES ('" + std::to_string(i) + "', '', '', '" +  std::to_string(g_startTime + i) + "', '" +
             std::to_string(g_startTime + i) + "','" + flag + "', ? , " + cloudGid + ");";
@@ -281,7 +282,7 @@ void SetDbSchema(const TableSchema &tableSchema)
 {
     DataBaseSchema dataBaseSchema;
     dataBaseSchema.tables.push_back(tableSchema);
-    EXPECT_EQ(g_delegate->SetCloudDbSchema(dataBaseSchema), E_OK);
+    EXPECT_EQ(g_delegate->SetCloudDbSchema(dataBaseSchema), DBStatus::OK);
 }
 
 void InitUserDataForAssetTest(int64_t insCount, int64_t photoSize, const Asset &expect)
@@ -624,20 +625,20 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount001, Tes
     query.SetTableName(g_tableName);
     EXPECT_EQ(g_cloudStore->GetUploadCount(query, g_startTime, false, false, resCount), -E_INVALID_QUERY_FORMAT);
 
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 100;
     CreateAndInitUserTable(insCount, insCount, g_localAsset);
-    InitLogData(insCount, insCount, insCount, insCount);
+    InitLogData(insCount, insCount, insCount, insCount, g_logTblName);
     EXPECT_EQ(g_cloudStore->GetUploadCount(query, g_startTime, false, false, resCount), E_OK);
     EXPECT_EQ(resCount, insCount + insCount + insCount);
 
     /**
-     * @tc.steps: There are no matching data anymore
-     * @tc.expected: count is 0 and return E_OK.
+     * @tc.steps: Timestamp filtering will not work.
+     * @tc.expected: count is 300 and return E_OK.
      */
     Timestamp invalidTime = g_startTime + g_startTime;
     EXPECT_EQ(g_cloudStore->GetUploadCount(query, invalidTime, false, false, resCount), E_OK);
-    EXPECT_EQ(resCount, 0);
+    EXPECT_EQ(resCount, insCount + insCount + insCount);
 }
 
 /**
@@ -649,9 +650,9 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount001, Tes
   */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount002, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 100;
-    InitLogData(insCount, insCount, 0, insCount);
+    InitLogData(insCount, insCount, 0, insCount, g_logTblName);
     CreateAndInitUserTable(insCount, insCount, g_localAsset);
     int64_t resCount = 0;
 
@@ -664,7 +665,8 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount002, Tes
     int timeOffset = 30;
     EXPECT_EQ(g_storageProxy->StartTransaction(), E_OK);
     EXPECT_EQ(g_storageProxy->GetUploadCount(g_tableName, g_startTime + timeOffset, false, resCount), E_OK);
-    EXPECT_EQ(resCount, insCount + insCount - timeOffset);
+    // Timestamp filtering will not work.
+    EXPECT_EQ(resCount, insCount + insCount);
     EXPECT_EQ(g_storageProxy->Rollback(), E_OK);
 
     /**
@@ -673,7 +675,8 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount002, Tes
      */
     EXPECT_EQ(g_storageProxy->StartTransaction(TransactType::IMMEDIATE), E_OK);
     EXPECT_EQ(g_storageProxy->GetUploadCount(g_tableName, g_startTime + timeOffset, false, resCount), E_OK);
-    EXPECT_EQ(resCount, insCount + insCount - timeOffset);
+    // Timestamp filtering will not work.
+    EXPECT_EQ(resCount, insCount + insCount);
     EXPECT_EQ(g_storageProxy->Commit(), E_OK);
 }
 
@@ -686,10 +689,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount002, Tes
  */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount003, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 100;
     CreateAndInitUserTable(insCount, insCount, g_localAsset);
-    InitLogData(0, 0, insCount, insCount);
+    InitLogData(0, 0, insCount, insCount, g_logTblName);
     int64_t resCount = 0;
 
     /**
@@ -713,9 +716,9 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetUploadCount003, Tes
  */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, FillCloudGid001, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 100;
-    InitLogData(insCount, 0, insCount, insCount);
+    InitLogData(insCount, 0, insCount, insCount, g_logTblName);
     CloudSyncData syncData(g_tableName);
     SetDbSchema(g_tableSchema);
 
@@ -798,10 +801,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, FillCloudGid001, TestS
  */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData003, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 1024;
     int64_t photoSize = 1024 * 8;
-    InitLogData(insCount, insCount, insCount, insCount);
+    InitLogData(insCount, insCount, insCount, insCount, g_logTblName);
     CreateAndInitUserTable(2 * insCount, photoSize, g_localAsset); // 2 is insert,update type data
 
     SetDbSchema(g_tableSchema);
@@ -830,10 +833,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData003, TestS
  */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData004, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 10;
     int64_t photoSize = 10;
-    InitLogData(insCount, insCount, insCount, insCount);
+    InitLogData(insCount, insCount, insCount, insCount, g_logTblName);
     CreateAndInitUserTable(3 * insCount, photoSize, g_localAsset); // 3 is insert,update and delete type data
 
     SetDbSchema(g_tableSchema);
@@ -866,10 +869,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData004, TestS
  */
 HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData005, TestSize.Level0)
 {
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 1024;
     int64_t photoSize = 1024 * 8;
-    InitLogData(insCount, insCount, insCount, insCount);
+    InitLogData(insCount, insCount, insCount, insCount, g_logTblName);
     CreateAndInitUserTable(2 * insCount, photoSize, g_localAsset); // 2 is insert,update type data
 
     SetDbSchema(g_tableSchema);
@@ -900,10 +903,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData006, TestS
      * @tc.steps:step1. Init data and set asset status to invalid num
      * @tc.expected: step1. return ok.
      */
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 1024;
     int64_t photoSize = 1024;
-    InitLogData(insCount, insCount, insCount, insCount);
+    InitLogData(insCount, insCount, insCount, insCount, g_logTblName);
     CreateAndInitUserTable(2 * insCount, photoSize, g_localAsset); // 2 is insert,update type data
     Asset asset = g_localAsset;
     asset.status = static_cast<uint32_t>(AssetStatus::UPDATE) + 1;
@@ -1552,10 +1555,10 @@ HWTEST_F(DistributedDBRelationalCloudSyncableStorageTest, GetCloudData007, TestS
      * @tc.steps:step1. Init data and set asset status to abnormal
      * @tc.expected: step1. return ok.
      */
-    CreateLogTable();
+    CreateLogTable(g_tableName);
     int64_t insCount = 10;
     int64_t photoSize = 1024 * 100;
-    InitLogData(insCount * 3, insCount * 3, 1, insCount); // 3 is multiple
+    InitLogData(insCount * 3, insCount * 3, 1, insCount, g_logTblName); // 3 is multiple
     CreateAndInitUserTable(insCount, photoSize, g_localAsset); // 2 is insert,update type data
     Asset asset = g_localAsset;
     asset.status = static_cast<uint32_t>(AssetStatus::ABNORMAL);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
index 6d1f8bfd731552f56dc2c3ebd1fc5e0b670601f2..355e40b38de318507caa954e28c4b1e01634ebb9 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_get_data_test.cpp
@@ -396,6 +396,11 @@ HWTEST_F(DistributedDBRelationalGetDataTest, GetSyncData1, TestSize.Level1)
         EXPECT_TRUE(errCode == E_OK || errCode == -E_UNFINISHED);
     }
     EXPECT_EQ(count, RECORD_COUNT);
+
+    RelationalDBProperties properties;
+    InitStoreProp(g_storePath, APP_ID, USER_ID, properties);
+    auto db = RelationalStoreInstance::GetDataBase(properties, errCode, false);
+    EXPECT_EQ(db, nullptr);
     RefObject::DecObjRef(g_store);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_result_set_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_result_set_test.cpp
index 2309574b6401b5ae6e200922cb84e70f5874be40..e3b17420e4525c5f735587933ebe8edd1ac5f21c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_result_set_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_relational_result_set_test.cpp
@@ -165,23 +165,23 @@ HWTEST_F(DistributedDBRelationalResultSetTest, SerializeAndDeserialize, TestSize
 
     // test the second row. if the second row ok, the first row is likely ok
     StorageType type = StorageType::STORAGE_TYPE_NONE;
-    EXPECT_EQ(rowDataSet2.Get(1)->GetType(0, type), DBStatus::OK);
+    EXPECT_EQ(rowDataSet2.Get(1)->GetType(0, type), E_OK);
     EXPECT_EQ(type, StorageType::STORAGE_TYPE_NULL);
 
     vector<uint8_t> desBlob;
-    EXPECT_EQ(rowDataSet2.Get(1)->Get(1, desBlob), DBStatus::OK);
+    EXPECT_EQ(rowDataSet2.Get(1)->Get(1, desBlob), E_OK);
     EXPECT_EQ(desBlob, BLOB_VALUE);
 
     double desDoub;
-    EXPECT_EQ(rowDataSet2.Get(1)->Get(2, desDoub), DBStatus::OK);
+    EXPECT_EQ(rowDataSet2.Get(1)->Get(2, desDoub), E_OK);
     EXPECT_EQ(desDoub, DOUBLE_VALUE);
 
     int64_t desInt64;
-    EXPECT_EQ(rowDataSet2.Get(1)->Get(3, desInt64), DBStatus::OK);
+    EXPECT_EQ(rowDataSet2.Get(1)->Get(3, desInt64), E_OK);
     EXPECT_EQ(desInt64, INT64_VALUE);
 
     std::string desStr;
-    EXPECT_EQ(rowDataSet2.Get(1)->Get(4, desStr), DBStatus::OK);
+    EXPECT_EQ(rowDataSet2.Get(1)->Get(4, desStr), E_OK);
     EXPECT_EQ(desStr, STR_VALUE);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_sqlite_utils_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_sqlite_utils_test.cpp
index eec9414c1a2c5e6e0764e5e36babe13bd365119f..3692e1502c9b7bd8502a11efea36efdd78adc758 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_sqlite_utils_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_sqlite_utils_test.cpp
@@ -19,6 +19,7 @@
 #include "native_sqlite.h"
 #include "platform_specific.h"
 #include "sqlite_import.h"
+#include "sqlite_log_table_manager.h"
 
 using namespace testing::ext;
 using namespace DistributedDB;
@@ -239,4 +240,26 @@ HWTEST_F(DistributedDBSqliteUtilsTest, GetTextTest003, TestSize.Level1)
         EXPECT_EQ(val, text);
         return E_OK;
     });
+}
+
+/**
+ * @tc.name: KVLogUpgrade001
+ * @tc.desc: Get blob size over limit
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBSqliteUtilsTest, KVLogUpgrade001, TestSize.Level0)
+{
+    const std::string tableName = "naturalbase_kv_aux_sync_data_log";
+    const std::string primaryKey = "PRIMARY KEY(userid, hash_key)";
+    std::string createTableSql = "CREATE TABLE IF NOT EXISTS " + tableName + "(" \
+        "userid    TEXT NOT NULL," + \
+        "hash_key  BLOB NOT NULL," + \
+        "cloud_gid TEXT," + \
+        "version   TEXT," + \
+        primaryKey + ");";
+    int errCode = SQLiteUtils::ExecuteRawSQL(g_db, createTableSql);
+    ASSERT_EQ(errCode, E_OK);
+    EXPECT_EQ(SqliteLogTableManager::CreateKvSyncLogTable(g_db), E_OK);
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_memory_rd_single_ver_naturall_store_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_memory_rd_single_ver_naturall_store_test.cpp
deleted file mode 100644
index 9163a9efebfb6364e7f294d2ed06a94c6e7a1fe0..0000000000000000000000000000000000000000
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_memory_rd_single_ver_naturall_store_test.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifdef USE_RD_KERNEL
-
-#include <gtest/gtest.h>
-
-#include "db_constant.h"
-#include "distributeddb_storage_rd_single_ver_natural_store_testcase.h"
-
-using namespace testing::ext;
-using namespace DistributedDB;
-using namespace DistributedDBUnitTest;
-using namespace std;
-
-namespace {
-    DistributedDB::KvStoreConfig g_config;
-    std::string g_testDir;
-    const std::string MEM_URL = "file:31?mode=memory&cache=shared";
-    DistributedDB::RdSingleVerNaturalStore *g_store = nullptr;
-    DistributedDB::RdSingleVerNaturalStoreConnection *g_connection = nullptr;
-}
-
-class DistributedDBStorageMemoryRdSingleVerNaturalStoreTest : public testing::Test {
-public:
-    static void SetUpTestCase(void);
-    static void TearDownTestCase(void);
-    void SetUp();
-    void TearDown();
-};
-
-void DistributedDBStorageMemoryRdSingleVerNaturalStoreTest::SetUpTestCase(void)
-{
-    DistributedDBToolsUnitTest::TestDirInit(g_testDir);
-    LOGD("Test dir is %s", g_testDir.c_str());
-    // IDENTIFIER_DIR is 31
-    DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/31/" + DBConstant::SINGLE_SUB_DIR);
-}
-
-void DistributedDBStorageMemoryRdSingleVerNaturalStoreTest::TearDownTestCase(void) {}
-
-void DistributedDBStorageMemoryRdSingleVerNaturalStoreTest::SetUp(void)
-{
-    DistributedDBToolsUnitTest::PrintTestCaseInfo();
-    KvDBProperties property;
-    property.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
-    property.SetStringProp(KvDBProperties::STORE_ID, "TestGeneralNB");
-    property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, "31");
-    property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_RD_KERNAL);
-    g_store = new (std::nothrow) RdSingleVerNaturalStore;
-    ASSERT_NE(g_store, nullptr);
-    ASSERT_EQ(g_store->Open(property), E_OK);
-
-    int erroCode = E_OK;
-    g_connection = static_cast<RdSingleVerNaturalStoreConnection *>(g_store->GetDBConnection(erroCode));
-    ASSERT_NE(g_connection, nullptr);
-    g_store->DecObjRef(g_store);
-    EXPECT_EQ(erroCode, E_OK);
-}
-
-void DistributedDBStorageMemoryRdSingleVerNaturalStoreTest::TearDown(void)
-{
-    if (g_connection != nullptr) {
-        g_connection->Close();
-    }
-
-    g_store = nullptr;
-    DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir + "/31/" + DBConstant::SINGLE_SUB_DIR);
-}
-
-/**
-  * @tc.name: SyncDatabaseOperate001
-  * @tc.desc: To test the function of inserting data of the local device in the synchronization database.
-  * @tc.type: FUNC
-  * @tc.require: AR000CCPOM
-  * @tc.author: wangbingquan
-  */
-HWTEST_F(DistributedDBStorageMemoryRdSingleVerNaturalStoreTest, SyncDatabaseOperate001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1/2. Set Ioption to the local data and insert a record of key1 and value1.
-     * @tc.expected: step1/2. Return OK.
-     */
-    /**
-     * @tc.steps: step3. Set Ioption to the local data and obtain the value of key1.
-     *  Check whether the value is the same as the value of value1.
-     * @tc.expected: step3. The obtained value and value2 are the same.
-     */
-    /**
-     * @tc.steps: step4. Ioption Set this parameter to the local data. Insert key1.
-     *  The value cannot be empty. value2(!=value1)
-     * @tc.expected: step4. Return OK.
-     */
-    /**
-     * @tc.steps: step5. Set Ioption to the local data, GetMetaData to obtain the value of key1,
-     *  and check whether the value is the same as the value of value2.
-     * @tc.expected: step5. The obtained value and value2 are the same.
-     */
-    /**
-     * @tc.steps: step6. The Ioption parameter is set to the local data.
-     *  The data record whose key is empty and value is not empty is inserted.
-     * @tc.expected: step6. Return E_INVALID_DATA.
-     */
-    /**
-     * @tc.steps: step7. Set Ioption to the local data, insert data
-     *  whose key2(!=key1) is not empty, and value is empty.
-     * @tc.expected: step7. Return OK.
-     */
-    /**
-     * @tc.steps: step8. Set option to local data, obtain the value of key2,
-     *  and check whether the value is empty.
-     * @tc.expected: step8. Return OK, value is empty.
-     */
-    /**
-     * @tc.steps: step9. Ioption Set the local data.
-     *  Insert the data whose key size is 1024 and value size is 4Mb.
-     * @tc.expected: step9. Return OK.
-     */
-    /**
-     * @tc.steps: step10/11. Set Ioption to the local data and insert data items
-     *  whose value is greater than 4Mb or key is bigger than 1Kb
-     * @tc.expected: step10/11. Return E_INVALID_ARGS.
-     */
-    DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate001(g_store, g_connection);
-}
-
-/**
-  * @tc.name: SyncDatabaseOperate003
-  * @tc.desc: test the delete operation in sync database.
-  * @tc.type: FUNC
-  * @tc.require: AR000CCPOM
-  * @tc.author: wangbingquan
-  */
-HWTEST_F(DistributedDBStorageMemoryRdSingleVerNaturalStoreTest, SyncDatabaseOperate003, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
-     * @tc.expected: step2. Return E_INVALID_ARGS.
-     */
-    /**
-     * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
-     * @tc.expected: step3. Return E_OK.
-     */
-    /**
-     * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
-     *  and check whether the value is the same as that of value1.
-     * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
-     */
-    /**
-     * @tc.steps: step5. Set Ioption to the local data and delete the data whose key is key1.
-     * @tc.expected: step5. Return E_OK.
-     */
-    /**
-     * @tc.steps: step5. Set Ioption to the local data and obtain the value of Key1.
-     * @tc.expected: step5. Return E_NOT_FOUND.
-     */
-    DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate003(g_store, g_connection);
-}
-
-/**
-  * @tc.name: SyncDatabaseOperate005
-  * @tc.desc: test the reading for sync database.
-  * @tc.type: FUNC
-  * @tc.require: AR000CCPOM
-  * @tc.author: wangbingquan
-  */
-HWTEST_F(DistributedDBStorageMemoryRdSingleVerNaturalStoreTest, SyncDatabaseOperate005, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step2. Set Ioption to the local data and delete the data whose key is key1 (empty).
-     * @tc.expected: step2. Return E_INVALID_ARGS.
-     */
-    /**
-     * @tc.steps: step3. Set Ioption to the local data, insert non-null key1, and non-null value1 data.
-     * @tc.expected: step3. Return E_OK.
-     */
-    /**
-     * @tc.steps: step4. Set Ioption to the local data, obtain the value of key1,
-     *  and check whether the value is the same as that of value1.
-     * @tc.expected: step4. Return E_OK. The obtained value is the same as the value of value1.
-     */
-    /**
-     * @tc.steps: step5. Set Ioption to the local data and obtain the value data of Key1.
-     *  Check whether the value is the same as the value of value2.
-     * @tc.expected: step4. Return E_OK, and the value is the same as the value of value2.
-     */
-    /**
-     * @tc.steps: step5. The Ioption is set to the local.
-     *  The data of the key1 and value2(!=value1) is inserted.
-     * @tc.expected: step4. Return E_OK.
-     */
-    DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate005(g_store, g_connection);
-}
-
-/**
-  * @tc.name: SyncDatabaseOperate006
-  * @tc.desc: test the get entries for sync database
-  * @tc.type: FUNC
-  * @tc.require: AR000CCPOM
-  * @tc.author: wangbingquan
-  */
-HWTEST_F(DistributedDBStorageMemoryRdSingleVerNaturalStoreTest, SyncDatabaseOperate006, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step2/3/4. Set Ioption to synchronous data.
-     * Insert the data of key=keyPrefix + 'a', value1.
-     * Insert the data of key=keyPrefix + 'c', value2.
-     * Insert the data of key length=keyPrefix length - 1, value3.
-     * @tc.expected: step2/3/4. Return E_NOT_FOUND.
-     */
-    /**
-     * @tc.steps: step5. Obtain all data whose prefixKey is keyPrefix.
-     * @tc.expected: step5. Return OK. The number of obtained data records is 2.
-     */
-    /**
-     * @tc.steps: step6. Obtain all data whose prefixKey is empty.
-     * @tc.expected: step6. Return OK. The number of obtained data records is 3.
-     */
-    /**
-     * @tc.steps: step7. Obtain all data whose prefixKey is keyPrefix.
-     * @tc.expected: step7. Return E_NOT_SUPPORT.
-     */
-    DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate006(g_store, g_connection);
-}
-#endif // USE_RD_KERNEL
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_resultset_and_json_optimize.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_resultset_and_json_optimize.cpp
deleted file mode 100644
index 1c43617087e851456df067a4800b984df6749f63..0000000000000000000000000000000000000000
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_resultset_and_json_optimize.cpp
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifdef USE_RD_KERNEL
-#ifndef OMIT_JSON
-#include <gtest/gtest.h>
-
-#include "db_common.h"
-#include "db_constant.h"
-#include "distributeddb_data_generate_unit_test.h"
-#include "distributeddb_tools_unit_test.h"
-#include "kvdb_manager.h"
-#include "log_print.h"
-#include "platform_specific.h"
-#include "res_finalizer.h"
-#include "rd_single_ver_natural_store_connection.h"
-#include "rd_single_ver_result_set.h"
-#include "store_types.h"
-
-using namespace testing::ext;
-using namespace DistributedDB;
-using namespace DistributedDBUnitTest;
-
-namespace {
-    const int INSERT_NUMBER = 10;
-    const Key EMPTY_KEY;
-
-    string g_testDir;
-    string g_identifier;
-    RdSingleVerNaturalStore *g_store = nullptr;
-    RdSingleVerNaturalStoreConnection *g_connection = nullptr;
-    KvDBProperties g_Property;
-    const string STORE_ID = STORE_ID_SYNC;
-}
-class DistributedDBStorageRdResultAndJsonOptimizeTest : public testing::Test {
-public:
-    static void SetUpTestCase(void);
-    static void TearDownTestCase(void);
-    void SetUp();
-    void TearDown();
-};
-
-void DistributedDBStorageRdResultAndJsonOptimizeTest::SetUpTestCase(void)
-{
-    DistributedDBToolsUnitTest::TestDirInit(g_testDir);
-    std::string origIdentifier = USER_ID + "-" + APP_ID + "-" + STORE_ID;
-    std::string identifier = DBCommon::TransferHashString(origIdentifier);
-    g_identifier = DBCommon::TransferStringToHex(identifier);
-    std::string dir = g_testDir + g_identifier + "/" + DBConstant::SINGLE_SUB_DIR;
-    DIR *dirTmp = opendir(dir.c_str());
-    if (dirTmp == nullptr) {
-        OS::MakeDBDirectory(dir);
-    } else {
-        closedir(dirTmp);
-    }
-    g_Property.SetStringProp(KvDBProperties::DATA_DIR, g_testDir);
-    g_Property.SetStringProp(KvDBProperties::STORE_ID, STORE_ID);
-    g_Property.SetStringProp(KvDBProperties::IDENTIFIER_DIR, g_identifier);
-    g_Property.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_RD_KERNAL);
-}
-
-void DistributedDBStorageRdResultAndJsonOptimizeTest::TearDownTestCase(void)
-{
-    if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
-        LOGE("rm test db files error!");
-    }
-}
-
-void DistributedDBStorageRdResultAndJsonOptimizeTest::SetUp(void)
-{
-    DistributedDBToolsUnitTest::PrintTestCaseInfo();
-    /**
-     * @tc.setup: 1. Create a RdSingleVerNaturalStore.
-     *            2. Set the ResultSet cache mode to CACHE_ENTRY_ID_ONLY.
-     *            3. Put 10 records.
-     */
-    g_store = new (std::nothrow) RdSingleVerNaturalStore;
-    ASSERT_NE(g_store, nullptr);
-    ASSERT_EQ(g_store->Open(g_Property), E_OK);
-
-    int errCode = E_OK;
-    g_connection = static_cast<RdSingleVerNaturalStoreConnection *>(g_store->GetDBConnection(errCode));
-    ASSERT_NE(g_connection, nullptr);
-    g_store->DecObjRef(g_store);
-    EXPECT_EQ(errCode, E_OK);
-
-    IOption option;
-    option.dataType = IOption::SYNC_DATA;
-    g_connection->Clear(option);
-    Key insertKey;
-    ASSERT_EQ(g_connection->StartTransaction(), -E_NOT_SUPPORT);
-    for (int i = 1; i < INSERT_NUMBER + 1; i++) {
-        insertKey.clear();
-        insertKey.push_back(i);
-        ASSERT_EQ(g_connection->Put(option, insertKey, VALUE_1), OK);
-    }
-    ASSERT_EQ(g_connection->Commit(), -E_NOT_SUPPORT);
-}
-
-void DistributedDBStorageRdResultAndJsonOptimizeTest::TearDown(void)
-{
-    /**
-     * @tc.teardown: Release the RdSingleVerNaturalStore.
-     */
-    if (g_connection != nullptr) {
-        g_connection->Close();
-        g_connection = nullptr;
-    }
-
-    g_store = nullptr;
-    KvDBManager::RemoveDatabase(g_Property);
-}
-
-/**
-  * @tc.name: ResultSetOpen001
-  * @tc.desc: Test the RdSingleVerResultSet Open function
-  * @tc.type: FUNC
-  * @tc.require: AR000F3OP0
-  * @tc.author: xushaohua
-  */
-HWTEST_F(DistributedDBStorageRdResultAndJsonOptimizeTest, ResultSetOpen001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Create a RdSingleVerResultSet.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet1 =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet.Open with parameter true.
-     * @tc.expected: step2. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet1->Open(false), E_OK);
-
-    /**
-     * @tc.steps: step3. Create a RdSingleVerResultSet.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet2 =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-
-    /**
-     * @tc.steps: step4. Call RdSingleVerResultSet.Open with parameter false.
-     * @tc.expected: step4. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet2->Open(false), E_OK);
-
-    /**
-     * @tc.steps: step5. Close all ResultSet.
-     */
-    resultSet1->Close();
-    resultSet2->Close();
-}
-
-/**
-  * @tc.name: ResultSetGetCount001
-  * @tc.desc: Test the RdSingleVerResultSet GetCount function.
-  * @tc.type: FUNC
-  * @tc.require: AR000F3OP0
-  * @tc.author: xushaohua
-  */
-HWTEST_F(DistributedDBStorageRdResultAndJsonOptimizeTest, ResultSetGetCount001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Create a RdSingleVerResultSet.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet.Open
-     * @tc.expected: step2. Expect return E_OK.Gits
-     */
-    EXPECT_EQ(resultSet->Open(false), E_OK);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet.GetCount
-     * @tc.expected: step2. Expect return INSERT_NUMBER.
-     */
-    EXPECT_EQ(resultSet->GetCount(), INSERT_NUMBER);
-
-    /**
-     * @tc.steps: step3. Close the ResultSet.
-     */
-    resultSet->Close();
-}
-
-/**
-  * @tc.name: ResultSetMoveTo001
-  * @tc.desc: Test the RdSingleVerResultSet MoveTo And GetPosition function.
-  * @tc.type: FUNC
-  * @tc.require: AR000F3OP0
-  * @tc.author: xushaohua
-  */
-HWTEST_F(DistributedDBStorageRdResultAndJsonOptimizeTest, ResultSetMoveTo001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Create a RdSingleVerResultSet.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet.Open.
-     * @tc.expected: step2. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet->Open(false), E_OK);
-
-    /**
-     * @tc.steps: step3. Call RdSingleVerResultSet MoveTo INSERT_NUMBER - 1
-     * @tc.expected: step3. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet->MoveTo(INSERT_NUMBER - 1), E_OK);
-
-    /**
-     * @tc.steps: step4. Call RdSingleVerResultSet GetPosition
-     * @tc.expected: step5. Expect return INSERT_NUMBER - 1.
-     */
-    EXPECT_EQ(resultSet->GetPosition(), INSERT_NUMBER - 1);
-
-    /**
-     * @tc.steps: step5. Call RdSingleVerResultSet MoveTo INSERT_NUMBER
-     * @tc.expected: step5. Expect return -E_INVALID_ARGS.
-     */
-    EXPECT_EQ(resultSet->MoveTo(INSERT_NUMBER), -E_INVALID_ARGS);
-
-    /**
-     * @tc.steps: step6. Call RdSingleVerResultSet GetPosition
-     * @tc.expected: step6. Expect return INSERT_NUMBER.
-     */
-    EXPECT_EQ(resultSet->GetPosition(), INSERT_NUMBER);
-
-    /**
-     * @tc.steps: step7. Call RdSingleVerResultSet MoveTo -1
-     * @tc.expected: step7. Expect return E_INVALID_ARGS.
-     */
-    EXPECT_EQ(resultSet->MoveTo(-1), -E_INVALID_ARGS);
-
-    /**
-     * @tc.steps: step8. Call RdSingleVerResultSet GetPosition
-     * @tc.expected: step8. Expect return 0.
-     */
-    EXPECT_EQ(resultSet->GetPosition(), -1);
-
-    /**
-     * @tc.steps: step9. Call RdSingleVerResultSet MoveTo 0
-     * @tc.expected: step9. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet->MoveTo(0), E_OK);
-
-    /**
-     * @tc.steps: step10. Call RdSingleVerResultSet GetPosition
-     * @tc.expected: step10. Expect return 0.
-     */
-    EXPECT_EQ(resultSet->GetPosition(), 0);
-
-    /**
-     * @tc.steps: step11. Close the ResultSet.
-     */
-    resultSet->Close();
-}
-
-/**
-  * @tc.name: ResultSetGetEntry001
-  * @tc.desc: Test the RdSingleVerResultSet GetEntry function.
-  * @tc.type: FUNC
-  * @tc.require: AR000F3OP0
-  * @tc.author: xushaohua
-  */
-HWTEST_F(DistributedDBStorageRdResultAndJsonOptimizeTest, ResultSetGetEntry001, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Create a RdSingleVerResultSet.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet.Open
-     * @tc.expected: step2. Expect return E_OK.
-     */
-    EXPECT_EQ(resultSet->Open(false), E_OK);
-
-    /**
-     * @tc.steps: step2. Call RdSingleVerResultSet MoveTo 0 And GetEntry
-     * @tc.expected: step2. Expect return E_OK.
-     */
-    Entry entry;
-    ASSERT_EQ(resultSet->MoveTo(0), E_OK);
-    EXPECT_EQ(resultSet->GetEntry(entry), E_OK);
-
-    /**
-     * @tc.expected: step2. Expect return Key == { 1 }, value == VALUE_1.
-     */
-    const Key key = { 1 };
-    EXPECT_EQ(entry.key, key);
-    EXPECT_EQ(entry.value, VALUE_1);
-
-    /**
-     * @tc.steps: step3. Close the ResultSet.
-     */
-    resultSet->Close();
-}
-
-/**
-  * @tc.name: ResultSetTest002
-  * @tc.desc: Check the resultSet move,then get
-  * @tc.type: FUNC
-  * @tc.require:
-  * @tc.author: bty
-  */
-HWTEST_F(DistributedDBStorageRdResultAndJsonOptimizeTest, ResultSetTest002, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. Check resultSet MoveTo when resultSet is not opened
-     * @tc.expected: step1. Expect return -E_RESULT_SET_STATUS_INVALID.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet1 =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-    ASSERT_NE(resultSet1, nullptr);
-    EXPECT_EQ(resultSet1->MoveTo(INSERT_NUMBER - 1), -E_RESULT_SET_STATUS_INVALID);
-
-    /**
-     * @tc.steps: step2. Then get the Entry
-     * @tc.expected: step2. Expect return -E_NO_SUCH_ENTRY.
-     */
-    EXPECT_EQ(resultSet1->Open(false), E_OK);
-    Entry entry;
-    EXPECT_EQ(resultSet1->GetEntry(entry), -E_NO_SUCH_ENTRY);
-    resultSet1->Close();
-
-    /**
-     * @tc.steps: step3. Check resultSet MoveTo when db is empty
-     * @tc.expected: step3. Expect return -E_RESULT_SET_EMPTY.
-     */
-    std::unique_ptr<RdSingleVerResultSet> resultSet2 =
-        std::make_unique<RdSingleVerResultSet>(g_store, EMPTY_KEY);
-    ASSERT_NE(resultSet2, nullptr);
-    IOption option;
-    option.dataType = IOption::SYNC_DATA;
-    Key insertKey;
-    ASSERT_EQ(g_connection->StartTransaction(), -E_NOT_SUPPORT);
-    for (int i = 1; i < INSERT_NUMBER + 1; i++) {
-        insertKey.clear();
-        insertKey.push_back(i);
-        ASSERT_EQ(g_connection->Delete(option, insertKey), OK);
-    }
-    ASSERT_EQ(g_connection->Commit(), -E_NOT_SUPPORT);
-    resultSet2->Open(false);
-    EXPECT_EQ(resultSet2->MoveTo(INSERT_NUMBER - 1), -E_RESULT_SET_EMPTY);
-
-    /**
-     * @tc.steps: step4. Get resultSet Entry when db is empty
-     * @tc.expected: step4. Expect return -E_NO_SUCH_ENTRY.
-     */
-    EXPECT_EQ(resultSet2->GetEntry(entry), -E_NO_SUCH_ENTRY);
-    resultSet2->Close();
-}
-#endif
-#endif // USE_RD_KERNEL
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_executor_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_executor_test.cpp
index 343b500d926a432401f454186e05e06b350f5060..1655a3fba89fe69b149fcc3d3338695298c1760d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_executor_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_executor_test.cpp
@@ -446,8 +446,8 @@ HWTEST_F(DistributedDBStorageRdSingleVerNaturalExecutorTest, PragmaTest003, Test
     EXPECT_EQ(emptyConn->Pragma(PRAGMA_SET_MAX_LOG_LIMIT, &limit), -E_NOT_SUPPORT);
     EXPECT_EQ(emptyConn->Pragma(PRAGMA_RM_DEVICE_DATA, nullptr), -E_NOT_SUPPORT);
     CipherPassword pw;
-    EXPECT_EQ(emptyConn->Import("/a.b", pw), -E_NOT_SUPPORT);
-    EXPECT_EQ(emptyConn->Export("/a.b", pw), -E_NOT_SUPPORT);
+    EXPECT_EQ(emptyConn->Import("/a.b", pw), -E_INVALID_DB);
+    EXPECT_EQ(emptyConn->Export("/a.b", pw), -E_INVALID_DB);
     DatabaseLifeCycleNotifier notifier;
     EXPECT_EQ(emptyConn->RegisterLifeCycleCallback(notifier), -E_NOT_SUPPORT);
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_test.cpp
index 351a7b2633c6a943860ec6e7661f8860f26dc57f..9277cd0f9042e1e6903c1e75a8768e764795b6a3 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_test.cpp
@@ -255,7 +255,7 @@ HWTEST_F(DistributedDBStorageRdSingleVerNaturalStoreTest, ExportBusy001, TestSiz
     ASSERT_NE(g_store, nullptr);
     ASSERT_EQ(g_store->TryToDisableConnection(OperatePerm::NORMAL_WRITE), E_OK);
     CipherPassword password;
-    EXPECT_EQ(g_store->Export(g_testDir, password), -E_NOT_SUPPORT);
+    EXPECT_EQ(g_store->Export(g_testDir, password), -E_READ_ONLY);
     g_store->ReEnableConnection(OperatePerm::NORMAL_WRITE);
 }
 }
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_testcase.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_testcase.cpp
index fd2adadd80d7486e9c51ea83bb3a7b82e7372b91..9fbd39582aa68281a010b274d5190da41ee6f435 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_testcase.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_rd_single_ver_natural_store_testcase.cpp
@@ -84,8 +84,6 @@ void DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate006
 {
     IOption option;
     option.dataType = IOption::SYNC_DATA;
-    Key key1, key2, key3;
-    Value value1, value2, value3;
 
     /**
      * @tc.steps: step2/3/4. Set Ioption to synchronous data.
@@ -94,12 +92,17 @@ void DistributedDBStorageRdSingleVerNaturalStoreTestCase::SyncDatabaseOperate006
      * Insert the data of key length=keyPrefix length - 1, value3.
      * @tc.expected: step2/3/4. Return E_NOT_FOUND.
      */
+    Key key1;
     DistributedDBToolsUnitTest::GetRandomKeyValue(key1, 30); // 30 as random size
-    key3 = key2 = key1;
+    Key key2 = key1;
     key2.push_back('C');
+    Key key3 = key1;
     key3.pop_back();
+    Value value1;
     DistributedDBToolsUnitTest::GetRandomKeyValue(value1, 84); // 84 as random size
+    Value value2;
     DistributedDBToolsUnitTest::GetRandomKeyValue(value2, 101); // 101 as random size
+    Value value3;
     DistributedDBToolsUnitTest::GetRandomKeyValue(value3, 37); // 37 as random size
     EXPECT_EQ(connection->Put(option, key1, value1), E_OK);
     EXPECT_EQ(connection->Put(option, key2, value2), E_OK);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_register_conflict_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_register_conflict_test.cpp
index aa1474581188aa92f89cf71e131ff5016acf5811..29e4cb74e688d2582805646246b8ff7f44f4c8c0 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_register_conflict_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_register_conflict_test.cpp
@@ -417,7 +417,7 @@ HWTEST_F(DistributedDBStorageRegisterConflictTest, ConflictNotificationTest002,
      * @tc.expected: step3. Expect to trigger a conflict. Return a SingleVerConflictData with {
      * CONFLICT_NATIVE_ALL, KEY_1, VALUE_1, VALUE_2, false, false, true, true}
      */
-    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), E_OK);
+    EXPECT_EQ(g_kvNbDelegatePtr->Put(KEY_1, VALUE_2), OK);
     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_LAG));
     ASSERT_FALSE(g_conflictData.empty());
     SingleVerConflictData expectNotifyData = {KvStoreNbConflictType::CONFLICT_NATIVE_ALL,
@@ -833,4 +833,4 @@ HWTEST_F(DistributedDBStorageRegisterConflictTest, ConflictNotificationTest017,
     Value readValue;
     EXPECT_EQ(g_connection->Get(option, KEY_1, readValue), E_OK);
     EXPECT_EQ(VALUE_1, readValue);
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_resultset_and_json_optimize.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_resultset_and_json_optimize.cpp
index 475930ecbf2c66a5d2aef536da402f16b06ffa6e..1151efae1daffffe3901639858456242d9a26023 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_resultset_and_json_optimize.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_resultset_and_json_optimize.cpp
@@ -104,7 +104,7 @@ void DistributedDBStorageResultAndJsonOptimizeTest::SetUp(void)
     for (int i = 1; i < INSERT_NUMBER + 1; i++) {
         insertKey.clear();
         insertKey.push_back(i);
-        ASSERT_EQ(g_connection->Put(option, insertKey, VALUE_1), OK);
+        ASSERT_EQ(g_connection->Put(option, insertKey, VALUE_1), E_OK);
     }
     ASSERT_EQ(g_connection->Commit(), E_OK);
 }
@@ -409,7 +409,7 @@ HWTEST_F(DistributedDBStorageResultAndJsonOptimizeTest, ResultSetTest002, TestSi
     for (int i = 1; i < INSERT_NUMBER + 1; i++) {
         insertKey.clear();
         insertKey.push_back(i);
-        ASSERT_EQ(g_connection->Delete(option, insertKey), OK);
+        ASSERT_EQ(g_connection->Delete(option, insertKey), E_OK);
     }
     ASSERT_EQ(g_connection->Commit(), E_OK);
     resultSet2->Open(true);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_upgrade_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_upgrade_test.cpp
index 6b18a3b80cdab20d9521dc4ecd5ebbdab840e9f0..9603da7effb0208deca25ac63220ce5e763d8fbf 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_upgrade_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_single_ver_upgrade_test.cpp
@@ -330,7 +330,7 @@ void DistributedDBStorageSingleVerUpgradeTest::TearDown(void)
   * @tc.require: AR000DPTQ7
   * @tc.author: wangbingquan
   */
-HWTEST_F(DistributedDBStorageSingleVerUpgradeTest, UpgradeTest001, TestSize.Level2)
+HWTEST_F(DistributedDBStorageSingleVerUpgradeTest, UpgradeTest001, TestSize.Level0)
 {
     /**
      * @tc.steps:step1. create old version V1 db.
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_sqlite_single_ver_natural_executor_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_sqlite_single_ver_natural_executor_test.cpp
index 19b01a356c691bcf729c8bb01b5a412cfbd2112c..42a4ba96a73ca1e644da053eb7fdeffd93cf33ae 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_sqlite_single_ver_natural_executor_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/storage/distributeddb_storage_sqlite_single_ver_natural_executor_test.cpp
@@ -20,6 +20,7 @@
 #include "distributeddb_storage_single_ver_natural_store_testcase.h"
 #include "kvdb_pragma.h"
 #include "storage_engine_manager.h"
+#include "sqlite_meta_executor.h"
 #include "sqlite_single_ver_storage_executor_sql.h"
 
 using namespace testing::ext;
@@ -1089,4 +1090,113 @@ HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, ExecutorCache00
     dataItem.flag = DataItem::DELETE_FLAG;
     EXPECT_EQ(executor->SaveSyncDataItemInCacheMode(dataItem, info, maxTime, 0, object), E_OK);
     sqlite3_close_v2(db);
-}
\ No newline at end of file
+}
+
+/**
+ * @tc.name: AbnormalSqlExecutorTest001
+ * @tc.desc: Check SQLiteStorageExecutor interfaces abnormal scene.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest001, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call interfaces when db and para is invalid.
+     * @tc.expected: step1. return errorCode.
+     */
+    SQLiteStorageExecutor storageObj(nullptr, true, true);
+    EXPECT_EQ(storageObj.Reset(), -E_INVALID_DB);
+    sqlite3 *dbHandle = nullptr;
+    EXPECT_EQ(storageObj.GetDbHandle(dbHandle), -E_NOT_FOUND);
+    SqliteMetaExecutor metaObj;
+    std::vector<Key> keys;
+    int ret = metaObj.GetAllKeys(nullptr, true, keys);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+
+    /**
+     * @tc.steps: step2. Call GetMetaKeysByKeyPrefix interface when para metaMode is not in enum class MetaMode.
+     * @tc.expected: step2. return -E_INVALID_ARGS.
+     */
+    std::set<std::string> outKeys;
+    int metaMode = 10; // set metaMode to 10 not in enum class MetaMode
+    ret = metaObj.GetMetaKeysByKeyPrefix("", nullptr,
+        static_cast<SqliteMetaExecutor::MetaMode>(metaMode), true, outKeys);
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+}
+
+/**
+ * @tc.name: AbnormalSqlExecutorTest002
+ * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call interfaces when db is null.
+     * @tc.expected: step1. return -E_INVALID_DB.
+     */
+    const std::vector<std::string> vec = {"test"};
+    int ret = g_nullHandle->RemoveTrigger(vec);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->RemoveSubscribeTriggerWaterMark(vec);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    std::vector<std::string> triggerNames;
+    ret = g_nullHandle->GetTriggers("", triggerNames);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    std::vector<Entry> entries;
+    ret = g_nullHandle->GetEntries("", entries);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->RemoveDeviceData("", ClearMode::DEFAULT);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->RemoveDeviceData("", "", ClearMode::FLAG_AND_DATA);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    const Key keyPrefix;
+    SingleVerRecord result;
+    ret = g_nullHandle->GetKvDataByHashKey(keyPrefix, result);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->EraseSyncData(keyPrefix);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->UpdateKey(nullptr);
+    EXPECT_EQ(ret, -E_INVALID_DB);
+    ret = g_nullHandle->CreateCloudLogTable();
+    EXPECT_EQ(ret, -E_INVALID_DB);
+}
+
+/**
+ * @tc.name: AbnormalSqlExecutorTest003
+ * @tc.desc: Check SQLiteSingleVerStorageExecutor interfaces abnormal scene.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBStorageSQLiteSingleVerNaturalExecutorTest, AbnormalSqlExecutorTest003, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. Call interfaces with invalid para.
+     * @tc.expected: step1. return errCode.
+     */
+    QueryObjNode node;
+    const std::list<QueryObjNode> queryObjNodes = {node};
+    const std::vector<uint8_t> prefixKey;
+    const std::set<Key> keys;
+    QueryObject queryObj(queryObjNodes, prefixKey, keys);
+    int ret = g_handle->AddSubscribeTrigger(queryObj, "");
+    EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
+    ret = g_handle->ReloadResultSet(queryObj);
+    EXPECT_EQ(ret, -E_INVALID_QUERY_FORMAT);
+    Entry entry;
+    ret = g_nullHandle->GetEntryByRowId(0, entry);
+    EXPECT_EQ(ret, -E_RESULT_SET_STATUS_INVALID);
+
+    /**
+     * @tc.steps: step2. Call AddSubscribeTrigger interface when executorState is CACHEDB.
+     * @tc.expected: step2. return -E_EKEYREVOKED.
+     */
+    SQLiteSingleVerStorageExecutor obj(nullptr, true, true, ExecutorState::CACHEDB);
+    QueryObject query;
+    ret = obj.AddSubscribeTrigger(query, "");
+    EXPECT_EQ(ret, -E_EKEYREVOKED);
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h
index fb442737b54a552c786f72b4210b0f936d9e4904..e35d0311b39d676ee6c84fde6d7e6ca55c167c5a 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/cloud_syncer_test.h
@@ -58,6 +58,7 @@ public:
         cloudTaskInfos_[taskId].table.push_back(currentContext_.tableName);
         currentContext_.currentTaskId = taskId;
         currentContext_.notifier = std::make_shared<ProcessNotifier>(this);
+        currentContext_.processRecorder = std::make_shared<ProcessRecorder>();
         currentContext_.notifier->Init({currentContext_.tableName}, { "cloud" }, cloudTaskInfos_[taskId].users);
         currentContext_.strategy = std::make_shared<CloudMergeStrategy>();
         closed_ = false;
@@ -119,9 +120,9 @@ public:
         };
     }
 
-    int CallDoSyncInner(const CloudTaskInfo &taskInfo, const bool &needUpload)
+    int CallDoSyncInner(const CloudTaskInfo &taskInfo)
     {
-        return DoSyncInner(taskInfo, needUpload, true);
+        return DoSyncInner(taskInfo);
     }
 
     SyncProcessCallback getCallback(TaskId taskId)
@@ -197,6 +198,7 @@ public:
     {
         VBucket tmp = { std::pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
                         std::pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1),
+                        std::pair<std::string, std::string>(CloudDbConstant::GID_FIELD, "0"),
                         std::pair<std::string, Asset>(CloudDbConstant::ASSET, ASSET_COPY) };
         VBucket asset = { std::pair<std::string, Asset>(CloudDbConstant::ASSET, ASSET_COPY) };
         uploadData.insData.record = std::vector<VBucket>(size, tmp);
@@ -339,10 +341,10 @@ public:
         return CloudSyncer::HandleTagAssets(hashKey, dataInfo, idx, param, localAssetInfo);
     }
 
-    std::map<int, std::map<std::string, bool>> GetDownloadFinishedStatus()
+    std::shared_ptr<ProcessRecorder> GetProcessRecorder()
     {
         std::lock_guard<std::mutex> autoLock(dataLock_);
-        return currentContext_.isDownloadFinished;
+        return currentContext_.processRecorder;
     }
 
     int CallDoDownloadInNeed(bool needUpload, bool isFirstDownload)
@@ -354,6 +356,16 @@ public:
         }
         return DoDownloadInNeed(taskInfo, needUpload, isFirstDownload);
     }
+
+    int CallDoUploadInNeed()
+    {
+        CloudTaskInfo taskInfo;
+        {
+            std::lock_guard<std::mutex> autoLock(dataLock_);
+            taskInfo = cloudTaskInfos_[currentContext_.currentTaskId];
+        }
+        return DoUploadInNeed(taskInfo, true);
+    }
     CloudTaskInfo taskInfo_;
 private:
     std::map<TaskId, SyncProcess> process_;
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_db_proxy_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_db_proxy_test.cpp
index 3a2c893a604c7d1b448a3c23992575e6fb46ebad..cae789758e9b9f36282623ac6d3e53f775ebbe46 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_db_proxy_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_db_proxy_test.cpp
@@ -193,7 +193,7 @@ HWTEST_F(DistributedDBCloudDBProxyTest, CloudDBProxyTest002, TestSize.Level0)
     std::vector<VBucket> expectExtends = CloudDBDataUtils::GenerateExtends(10); // generate 10 extends
     Info uploadInfo;
     std::vector<VBucket> insert = expectRecords;
-    EXPECT_EQ(proxy.BatchInsert(TABLE_NAME, insert, expectExtends, uploadInfo), OK);
+    EXPECT_EQ(proxy.BatchInsert(TABLE_NAME, insert, expectExtends, uploadInfo), E_OK);
 
     VBucket extend;
     extend[CloudDbConstant::CURSOR_FIELD] = std::string("");
@@ -246,14 +246,14 @@ HWTEST_F(DistributedDBCloudDBProxyTest, CloudDBProxyTest003, TestSize.Level0)
     std::vector<VBucket> expectExtends = CloudDBDataUtils::GenerateExtends(10); // generate 10 extends
     Info uploadInfo;
     std::vector<VBucket> insert = expectRecords;
-    EXPECT_EQ(proxy.BatchInsert(TABLE_NAME, insert, expectExtends, uploadInfo), OK);
+    EXPECT_EQ(proxy.BatchInsert(TABLE_NAME, insert, expectExtends, uploadInfo), E_OK);
     /**
      * @tc.steps: step3. update data to cloud db
      * @tc.expected: step3. E_OK
      */
     ModifyRecords(expectRecords);
     std::vector<VBucket> update = expectRecords;
-    EXPECT_EQ(proxy.BatchUpdate(TABLE_NAME, update, expectExtends, uploadInfo), OK);
+    EXPECT_EQ(proxy.BatchUpdate(TABLE_NAME, update, expectExtends, uploadInfo), E_OK);
     /**
      * @tc.steps: step3. proxy close cloud db
      * @tc.expected: step3. E_OK
@@ -499,6 +499,77 @@ HWTEST_F(DistributedDBCloudDBProxyTest, CloudDBProxyTest011, TestSize.Level2)
     EXPECT_EQ(currentCount, scheduleCount);
 }
 
+/**
+ * @tc.name: CloudDBProxyTest012
+ * @tc.desc: Asset data deduplication.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: tankaisheng
+ */
+HWTEST_F(DistributedDBCloudDBProxyTest, CloudDBProxyTest012, TestSize.Level2)
+{
+    /**
+     * @tc.steps: step1. set cloud db to proxy
+     * @tc.expected: step1. E_OK
+     */
+    Assets assets;
+    Asset asset1;
+    asset1.name = "assetName1";
+    asset1.assetId = "";
+    asset1.modifyTime = "20240730";
+    assets.push_back(asset1);
+    
+    Asset asset2;
+    asset2.name = "assetName1";
+    asset2.assetId = "123";
+    asset2.modifyTime = "20240730";
+    assets.push_back(asset2);
+
+    Asset asset3;
+    asset3.name = "assetName2";
+    asset3.assetId = "456";
+    asset3.modifyTime = "20240730";
+    assets.push_back(asset3);
+
+    Asset asset4;
+    asset4.name = "assetName2";
+    asset4.assetId = "789";
+    asset4.modifyTime = "20240731";
+    assets.push_back(asset4);
+
+    Asset asset5;
+    asset5.name = "assetName3";
+    asset5.assetId = "123";
+    asset5.modifyTime = "20240730";
+    assets.push_back(asset5);
+
+    Asset asset6;
+    asset6.name = "assetName3";
+    asset6.assetId = "789";
+    asset6.modifyTime = "20240730";
+    assets.push_back(asset6);
+
+    Asset asset7;
+    asset7.name = "assetName1";
+    asset7.assetId = "456";
+    asset7.modifyTime = "20240731";
+    assets.push_back(asset7);
+
+    DBCommon::RemoveDuplicateAssetsData(assets);
+
+    /**
+     * @tc.steps: step2. check data
+     * @tc.expected: step2. E_OK
+     */
+    std::string assetNameArr[] = {"assetName2", "assetName3", "assetName1"};
+    std::string assetIdArr[] = {"789", "123", "456"};
+    EXPECT_EQ(assets.size(), 3u);
+    for (std::vector<DistributedDB::Asset>::size_type i = 0; i < assets.size(); ++i) {
+        EXPECT_EQ(assets.at(i).name, assetNameArr[i]);
+        EXPECT_EQ(assets.at(i).assetId, assetIdArr[i]);
+    }
+}
+
 /**
  * @tc.name: CloudSyncQueue001
  * @tc.desc: Verify sync task count decrease after sync finished.
@@ -685,4 +756,115 @@ HWTEST_F(DistributedDBCloudDBProxyTest, SameBatchTest002, TestSize.Level0)
     // index start with zero
     EXPECT_EQ(CloudSyncUtils::CalOpType(param, param.downloadData.data.size() - 1), OpType::UPDATE);
 }
+
+/**
+ * @tc.name: CloudDBProxyTest013
+ * @tc.desc: Verify CloudDBProxy interfaces.
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCloudDBProxyTest, CloudDBProxyTest013, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. call CloudDBProxy interfaces when ICloudDb is nullptr.
+     * @tc.expected: step1. return -E_CLOUD_ERROR.
+     */
+    CloudDBProxy proxy;
+    int ret = proxy.UnLock();
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    ret = proxy.HeartBeat();
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    VBucket extend;
+    const std::string tableName = "test";
+    std::vector<VBucket> record;
+    ret = proxy.Query(tableName, extend, record);
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    Info info;
+    ret = proxy.BatchInsert(tableName, record, record, info);
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    ret = proxy.BatchUpdate(tableName, record, record, info);
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    ret = proxy.BatchDelete(tableName, record, record, info);
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+    std::pair<int, uint64_t> res = proxy.Lock();
+    EXPECT_EQ(res.first, -E_CLOUD_ERROR);
+    std::pair<int, std::string> cursor = proxy.GetEmptyCursor(tableName);
+    EXPECT_EQ(cursor.first, -E_CLOUD_ERROR);
+
+    /**
+     * @tc.steps: step2. call CloudDBProxy interfaces when para is err.
+     * @tc.expected: step2. return fail.
+     */
+    std::pair<int, std::string> ver = proxy.GetCloudVersion("test");
+    EXPECT_EQ(ver.first, -E_NOT_SUPPORT);
+    std::vector<Asset> assets;
+    ret = proxy.RemoveLocalAssets(assets);
+    EXPECT_EQ(ret, -E_OK);
+    assets = {{}};
+    ret = proxy.RemoveLocalAssets(assets);
+    EXPECT_EQ(ret, -E_OK);
+}
+
+/**
+ * @tc.name: CloudSyncUtilsTest
+ * @tc.desc: Verify CloudSyncUtils interfaces
+ * @tc.type: FUNC
+ * @tc.require: DTS2024073106613
+ * @tc.author: suyue
+ */
+HWTEST_F(DistributedDBCloudDBProxyTest, CloudSyncUtilsTest, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. Test type translation interfaces.
+     * @tc.expected: step1. success.
+     */
+    CloudSyncUtils utilsObj;
+    EXPECT_EQ(utilsObj.StatusToFlag(AssetStatus::INSERT), AssetOpType::INSERT);
+    EXPECT_EQ(utilsObj.StatusToFlag(AssetStatus::DELETE), AssetOpType::DELETE);
+    EXPECT_EQ(utilsObj.StatusToFlag(AssetStatus::UPDATE), AssetOpType::UPDATE);
+    EXPECT_EQ(utilsObj.StatusToFlag(AssetStatus::NORMAL), AssetOpType::NO_CHANGE);
+    EXPECT_EQ(utilsObj.StatusToFlag(AssetStatus::DOWNLOADING), AssetOpType::NO_CHANGE);
+    EXPECT_EQ(utilsObj.OpTypeToChangeType(OpType::ONLY_UPDATE_GID), ChangeType::OP_BUTT);
+
+    /**
+     * @tc.steps: step2. call CloudSyncUtils interfaces when para is err.
+     * @tc.expected: step2. return false.
+     */
+    const std::vector<DeviceID> devices = {"test"};
+    int mode = 10; // set metaMode to 10 not in enum class MetaMode
+    int ret = utilsObj.CheckParamValid(devices, static_cast<SyncMode>(mode));
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+    VBucket record;
+    const std::vector<std::string> pkColNames;
+    std::vector<Type> cloudPkVals = {{}};
+    ret = utilsObj.GetCloudPkVals(record, pkColNames, 0, cloudPkVals);
+    EXPECT_EQ(ret, -E_INVALID_ARGS);
+    Assets assets = {{}};
+    utilsObj.StatusToFlagForAssets(assets);
+    std::vector<Field> fields = {{"test", TYPE_INDEX<Assets>, true, true}};
+    utilsObj.StatusToFlagForAssetsInRecord(fields, record);
+    Timestamp timestamp;
+    CloudSyncData uploadData;
+    const int64_t count = 0;
+    ret = utilsObj.UpdateExtendTime(uploadData, count, 0, timestamp);
+    EXPECT_EQ(ret, -E_INTERNAL_ERROR);
+    CloudSyncBatch data;
+    data.assets = {{}};
+    ret = utilsObj.FillAssetIdToAssets(data, 0, CloudWaterType::UPDATE);
+    EXPECT_EQ(ret, -E_CLOUD_ERROR);
+
+    /**
+     * @tc.steps: step3. call IsChangeDataEmpty interface when para is different.
+     * @tc.expected: step3. success.
+     */
+    ChangedData changedData;
+    EXPECT_EQ(utilsObj.IsChangeDataEmpty(changedData), true);
+    changedData.primaryData[OP_INSERT] = {{}};
+    EXPECT_EQ(utilsObj.IsChangeDataEmpty(changedData), true);
+    changedData.primaryData[OP_UPDATE] = {{}};
+    EXPECT_EQ(utilsObj.IsChangeDataEmpty(changedData), true);
+    changedData.primaryData[OP_DELETE] = {{}};
+    EXPECT_EQ(utilsObj.IsChangeDataEmpty(changedData), false);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_syncer_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_syncer_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c6edf18261f78562fadc0a29b9e16e31c9bf62f
--- /dev/null
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_syncer_test.cpp
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "cloud/cloud_db_constant.h"
+#include "cloud_db_sync_utils_test.h"
+#include "db_base64_utils.h"
+#include "distributeddb_data_generate_unit_test.h"
+#include "distributeddb_tools_unit_test.h"
+#include "kv_virtual_device.h"
+#include "kv_store_nb_delegate.h"
+#include "kvdb_manager.h"
+#include "platform_specific.h"
+#include "process_system_api_adapter_impl.h"
+#include "sqlite_cloud_kv_executor_utils.h"
+#include "virtual_communicator_aggregator.h"
+#include "virtual_cloud_db.h"
+
+using namespace testing::ext;
+using namespace DistributedDB;
+using namespace DistributedDBUnitTest;
+using namespace std;
+
+namespace {
+static std::string HWM_HEAD = "naturalbase_cloud_meta_sync_data_";
+string g_testDir;
+KvStoreDelegateManager g_mgr(APP_ID, USER_ID);
+CloudSyncOption g_CloudSyncoption;
+const std::string USER_ID_2 = "user2";
+const std::string USER_ID_3 = "user3";
+const int64_t WAIT_TIME = 5;
+class DistributedDBCloudKvSyncerTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+protected:
+    DBStatus GetKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId, KvStoreNbDelegate::Option option,
+        bool invalidSchema = false);
+    void CloseKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId);
+    void BlockSync(KvStoreNbDelegate *delegate, DBStatus expectDBStatus, CloudSyncOption option,
+        DBStatus expectSyncResult = OK);
+    static DataBaseSchema GetDataBaseSchema(bool invalidSchema);
+    void GetSingleStore();
+    void ReleaseSingleStore();
+    void BlockCompensatedSync(int &actSyncCnt, int expSyncCnt);
+    void CheckUploadAbnormal(OpType opType, int64_t expCnt, bool isCompensated = false);
+    std::shared_ptr<VirtualCloudDb> virtualCloudDb_ = nullptr;
+    std::shared_ptr<VirtualCloudDb> virtualCloudDb2_ = nullptr;
+    KvStoreConfig config_;
+    KvStoreNbDelegate* kvDelegatePtrS1_ = nullptr;
+    KvStoreNbDelegate* kvDelegatePtrS2_ = nullptr;
+    SyncProcess lastProcess_;
+    VirtualCommunicatorAggregator *communicatorAggregator_ = nullptr;
+    KvVirtualDevice *deviceB_ = nullptr;
+    SQLiteSingleVerNaturalStore *singleStore_ = nullptr;
+    std::mutex comSyncMutex;
+    std::condition_variable comSyncCv;
+};
+
+void DistributedDBCloudKvSyncerTest::SetUpTestCase()
+{
+    DistributedDBToolsUnitTest::TestDirInit(g_testDir);
+    if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
+        LOGE("rm test db files error!");
+    }
+    g_CloudSyncoption.mode = SyncMode::SYNC_MODE_CLOUD_MERGE;
+    g_CloudSyncoption.users.push_back(USER_ID);
+    g_CloudSyncoption.devices.push_back("cloud");
+
+    string dir = g_testDir + "/single_ver";
+    DIR* dirTmp = opendir(dir.c_str());
+    if (dirTmp == nullptr) {
+        OS::MakeDBDirectory(dir);
+    } else {
+        closedir(dirTmp);
+    }
+}
+
+void DistributedDBCloudKvSyncerTest::TearDownTestCase()
+{
+    if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
+        LOGE("rm test db files error!");
+    }
+}
+
+void DistributedDBCloudKvSyncerTest::SetUp()
+{
+    DistributedDBToolsUnitTest::PrintTestCaseInfo();
+    config_.dataDir = g_testDir;
+    /**
+     * @tc.setup: create virtual device B and C, and get a KvStoreNbDelegate as deviceA
+     */
+    virtualCloudDb_ = std::make_shared<VirtualCloudDb>();
+    virtualCloudDb2_ = std::make_shared<VirtualCloudDb>();
+    g_mgr.SetKvStoreConfig(config_);
+    KvStoreNbDelegate::Option option1;
+    ASSERT_EQ(GetKvStore(kvDelegatePtrS1_, STORE_ID_1, option1), OK);
+    // set aggregator after get store1, only store2 can sync with p2p
+    communicatorAggregator_ = new (std::nothrow) VirtualCommunicatorAggregator();
+    ASSERT_TRUE(communicatorAggregator_ != nullptr);
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(communicatorAggregator_);
+    KvStoreNbDelegate::Option option2;
+    ASSERT_EQ(GetKvStore(kvDelegatePtrS2_, STORE_ID_2, option2), OK);
+
+    deviceB_ = new (std::nothrow) KvVirtualDevice("DEVICE_B");
+    ASSERT_TRUE(deviceB_ != nullptr);
+    auto syncInterfaceB = new (std::nothrow) VirtualSingleVerSyncDBInterface();
+    ASSERT_TRUE(syncInterfaceB != nullptr);
+    ASSERT_EQ(deviceB_->Initialize(communicatorAggregator_, syncInterfaceB), E_OK);
+    GetSingleStore();
+}
+
+void DistributedDBCloudKvSyncerTest::TearDown()
+{
+    ReleaseSingleStore();
+    CloseKvStore(kvDelegatePtrS1_, STORE_ID_1);
+    CloseKvStore(kvDelegatePtrS2_, STORE_ID_2);
+    virtualCloudDb_ = nullptr;
+    virtualCloudDb2_ = nullptr;
+    if (DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir) != 0) {
+        LOGE("rm test db files error!");
+    }
+
+    if (deviceB_ != nullptr) {
+        delete deviceB_;
+        deviceB_ = nullptr;
+    }
+
+    RuntimeContext::GetInstance()->SetCommunicatorAggregator(nullptr);
+    communicatorAggregator_ = nullptr;
+    RuntimeContext::GetInstance()->SetProcessSystemApiAdapter(nullptr);
+}
+
+void DistributedDBCloudKvSyncerTest::BlockSync(KvStoreNbDelegate *delegate, DBStatus expectDBStatus,
+    CloudSyncOption option, DBStatus expectSyncResult)
+{
+    if (delegate == nullptr) {
+        return;
+    }
+    std::mutex dataMutex;
+    std::condition_variable cv;
+    bool finish = false;
+    SyncProcess last;
+    auto callback = [expectDBStatus, &last, &cv, &dataMutex, &finish, &option](const std::map<std::string,
+        SyncProcess> &process) {
+        size_t notifyCnt = 0;
+        for (const auto &item: process) {
+            LOGD("user = %s, status = %d, errCode = %d", item.first.c_str(), item.second.process, item.second.errCode);
+            if (item.second.process != DistributedDB::FINISHED) {
+                continue;
+            }
+            EXPECT_EQ(item.second.errCode, expectDBStatus);
+            {
+                std::lock_guard<std::mutex> autoLock(dataMutex);
+                notifyCnt++;
+                std::set<std::string> userSet(option.users.begin(), option.users.end());
+                if (notifyCnt == userSet.size()) {
+                    finish = true;
+                    last = item.second;
+                    cv.notify_one();
+                }
+            }
+        }
+    };
+    auto actualRet = delegate->Sync(option, callback);
+    EXPECT_EQ(actualRet, expectSyncResult);
+    if (actualRet == OK) {
+        std::unique_lock<std::mutex> uniqueLock(dataMutex);
+        cv.wait(uniqueLock, [&finish]() {
+            return finish;
+        });
+    }
+    lastProcess_ = last;
+}
+
+DataBaseSchema DistributedDBCloudKvSyncerTest::GetDataBaseSchema(bool invalidSchema)
+{
+    DataBaseSchema schema;
+    TableSchema tableSchema;
+    tableSchema.name = invalidSchema ? "invalid_schema_name" : CloudDbConstant::CLOUD_KV_TABLE_NAME;
+    Field field;
+    field.colName = CloudDbConstant::CLOUD_KV_FIELD_KEY;
+    field.type = TYPE_INDEX<std::string>;
+    field.primary = true;
+    tableSchema.fields.push_back(field);
+    field.colName = CloudDbConstant::CLOUD_KV_FIELD_DEVICE;
+    field.primary = false;
+    tableSchema.fields.push_back(field);
+    field.colName = CloudDbConstant::CLOUD_KV_FIELD_ORI_DEVICE;
+    tableSchema.fields.push_back(field);
+    field.colName = CloudDbConstant::CLOUD_KV_FIELD_VALUE;
+    tableSchema.fields.push_back(field);
+    field.colName = CloudDbConstant::CLOUD_KV_FIELD_DEVICE_CREATE_TIME;
+    field.type = TYPE_INDEX<int64_t>;
+    tableSchema.fields.push_back(field);
+    schema.tables.push_back(tableSchema);
+    return schema;
+}
+
+void DistributedDBCloudKvSyncerTest::GetSingleStore()
+{
+    KvDBProperties prop;
+    prop.SetStringProp(KvDBProperties::USER_ID, USER_ID);
+    prop.SetStringProp(KvDBProperties::APP_ID, APP_ID);
+    prop.SetStringProp(KvDBProperties::STORE_ID, STORE_ID_1);
+
+    std::string hashIdentifier = DBCommon::TransferHashString(
+        DBCommon::GenerateIdentifierId(STORE_ID_1, APP_ID, USER_ID, "", 0));
+    prop.SetStringProp(DBProperties::IDENTIFIER_DATA, hashIdentifier);
+    prop.SetIntProp(KvDBProperties::DATABASE_TYPE, KvDBProperties::SINGLE_VER_TYPE_SQLITE);
+    int errCode = E_OK;
+    singleStore_ = static_cast<SQLiteSingleVerNaturalStore *>(KvDBManager::OpenDatabase(prop, errCode));
+    ASSERT_NE(singleStore_, nullptr);
+}
+
+void DistributedDBCloudKvSyncerTest::ReleaseSingleStore()
+{
+    RefObject::DecObjRef(singleStore_);
+    singleStore_ = nullptr;
+}
+
+void DistributedDBCloudKvSyncerTest::BlockCompensatedSync(int &actSyncCnt, int expSyncCnt)
+{
+    {
+        std::unique_lock<std::mutex> lock(comSyncMutex);
+        bool result = comSyncCv.wait_for(lock, std::chrono::seconds(WAIT_TIME),
+            [&actSyncCnt, expSyncCnt]() { return actSyncCnt == expSyncCnt; });
+        ASSERT_EQ(result, true);
+    }
+}
+
+
+DBStatus DistributedDBCloudKvSyncerTest::GetKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId,
+    KvStoreNbDelegate::Option option, bool invalidSchema)
+{
+    DBStatus openRet = OK;
+    g_mgr.GetKvStore(storeId, option, [&openRet, &delegate](DBStatus status, KvStoreNbDelegate *openDelegate) {
+        openRet = status;
+        delegate = openDelegate;
+    });
+    EXPECT_EQ(openRet, OK);
+    EXPECT_NE(delegate, nullptr);
+
+    std::map<std::string, std::shared_ptr<ICloudDb>> cloudDbs;
+    cloudDbs[USER_ID] = virtualCloudDb_;
+    cloudDbs[USER_ID_2] = virtualCloudDb2_;
+    delegate->SetCloudDB(cloudDbs);
+    std::map<std::string, DataBaseSchema> schemas;
+    schemas[USER_ID] = GetDataBaseSchema(invalidSchema);
+    schemas[USER_ID_2] = GetDataBaseSchema(invalidSchema);
+    return delegate->SetCloudDbSchema(schemas);
+}
+
+void DistributedDBCloudKvSyncerTest::CloseKvStore(KvStoreNbDelegate *&delegate, const std::string &storeId)
+{
+    if (delegate != nullptr) {
+        ASSERT_EQ(g_mgr.CloseKvStore(delegate), OK);
+        delegate = nullptr;
+        DBStatus status = g_mgr.DeleteKvStore(storeId);
+        LOGD("delete kv store status %d store %s", status, storeId.c_str());
+        ASSERT_EQ(status, OK);
+    }
+}
+
+void DistributedDBCloudKvSyncerTest::CheckUploadAbnormal(OpType opType, int64_t expCnt, bool isCompensated)
+{
+    sqlite3 *db_;
+    uint64_t flag = SQLITE_OPEN_URI | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+    std::string fileUrl = g_testDir + "/" \
+        "2d23c8a0ffadafcaa03507a4ec2290c83babddcab07c0e2945fbba93efc7eec0/single_ver/main/gen_natural_store.db";
+    EXPECT_EQ(sqlite3_open_v2(fileUrl.c_str(), &db_, flag, nullptr), SQLITE_OK);
+
+    std::string sql = "SELECT count(*) FROM naturalbase_kv_aux_sync_data_log WHERE ";
+    switch (opType) {
+        case OpType::INSERT:
+            sql += isCompensated ? " cloud_gid != '' AND version !='' AND cloud_flag&0x10=0" :
+                " cloud_gid != '' AND version !='' AND cloud_flag=cloud_flag|0x10";
+            break;
+        case OpType::UPDATE:
+            sql += isCompensated ? " cloud_gid != '' AND version !='' AND cloud_flag&0x10=0" :
+                " cloud_gid == '' AND version =='' AND cloud_flag=cloud_flag|0x10";
+            break;
+        case OpType::DELETE:
+            sql += " cloud_gid == '' AND version ==''";
+            break;
+        default:
+            break;
+    }
+    EXPECT_EQ(sqlite3_exec(db_, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(expCnt), nullptr), SQLITE_OK);
+    sqlite3_close_v2(db_);
+}
+
+/**
+ * @tc.name: UploadAbnormalSync001
+ * @tc.desc: Test upload update record, cloud returned record not found.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: bty
+ */
+HWTEST_F(DistributedDBCloudKvSyncerTest, UploadAbnormalSync001, TestSize.Level0)
+{
+    auto cloudHook = (ICloudSyncStorageHook *) singleStore_->GetCloudKvStore();
+    ASSERT_NE(cloudHook, nullptr);
+
+    /**
+     * @tc.steps:step1. Device A inserts data and synchronizes
+     * @tc.expected: step1 OK.
+     */
+    Key key = {'k'};
+    Value value = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+
+    /**
+     * @tc.steps:step2. Device A update data and synchronizes, cloud returned record not found
+     * @tc.expected: step2 OK.
+     */
+    Value value2 = {'x'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value2), OK);
+    int upIdx = 0;
+    virtualCloudDb_->ForkUpload([&upIdx](const std::string &tableName, VBucket &extend) {
+        LOGD("cloud db upload index:%d", ++upIdx);
+        if (upIdx == 1) { // 1 is index
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_NOT_FOUND);
+        }
+    });
+    int syncCnt = 0;
+    cloudHook->SetSyncFinishHook([&syncCnt, this] {
+        LOGD("sync finish times:%d", ++syncCnt);
+        if (syncCnt == 1) { // 1 is the first sync
+            CheckUploadAbnormal(OpType::UPDATE, 1L); // 1 is expected count
+        } else {
+            CheckUploadAbnormal(OpType::UPDATE, 1L, true); // 1 is expected count
+        }
+        comSyncCv.notify_all();
+    });
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    BlockCompensatedSync(syncCnt, 2); // 2 is sync times
+    virtualCloudDb_->ForkUpload(nullptr);
+    cloudHook->SetSyncFinishHook(nullptr);
+}
+
+/**
+ * @tc.name: UploadAbnormalSync002
+ * @tc.desc: Test upload insert record, cloud returned record already existed.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: bty
+ */
+HWTEST_F(DistributedDBCloudKvSyncerTest, UploadAbnormalSync002, TestSize.Level0)
+{
+    auto cloudHook = (ICloudSyncStorageHook *) singleStore_->GetCloudKvStore();
+    ASSERT_NE(cloudHook, nullptr);
+
+    /**
+     * @tc.steps:step1. Device A inserts k-v and synchronizes
+     * @tc.expected: step1 OK.
+     */
+    Key key = {'k'};
+    Value value = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+
+    /**
+     * @tc.steps:step2. Device A insert k2-v2 and synchronizes, Device B insert k2-v2 and sync before A upload
+     * @tc.expected: step2 OK.
+     */
+    Key key2 = {'x'};
+    Value value2 = {'y'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key2, value2), OK);
+    int upIdx = 0;
+    virtualCloudDb_->ForkUpload([&upIdx](const std::string &tableName, VBucket &extend) {
+        LOGD("cloud db upload index:%d", ++upIdx);
+        if (upIdx == 2) { // 2 is index
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_ALREADY_EXISTED);
+        }
+    });
+    int doUpIdx = 0;
+    cloudHook->SetDoUploadHook([&doUpIdx, key2, value2, this] {
+        LOGD("begin upload index:%d", ++doUpIdx);
+        ASSERT_EQ(kvDelegatePtrS2_->Put(key2, value2), OK);
+        BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+    });
+    int syncCnt = 0;
+    cloudHook->SetSyncFinishHook([&syncCnt, this] {
+        LOGD("sync finish times:%d", ++syncCnt);
+        if (syncCnt == 1) { // 1 is the normal sync
+            CheckUploadAbnormal(OpType::INSERT, 1L); // 1 is expected count
+        } else {
+            CheckUploadAbnormal(OpType::INSERT, 2L, true); // 2 is expected count
+        }
+        comSyncCv.notify_all();
+    });
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    BlockCompensatedSync(syncCnt, 2); // 2 is sync times
+    virtualCloudDb_->ForkUpload(nullptr);
+    cloudHook->SetSyncFinishHook(nullptr);
+    cloudHook->SetDoUploadHook(nullptr);
+}
+
+/**
+ * @tc.name: UploadAbnormalSync003
+ * @tc.desc: Test upload delete record, cloud returned record not found.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: bty
+ */
+HWTEST_F(DistributedDBCloudKvSyncerTest, UploadAbnormalSync003, TestSize.Level0)
+{
+    auto cloudHook = (ICloudSyncStorageHook *) singleStore_->GetCloudKvStore();
+    ASSERT_NE(cloudHook, nullptr);
+
+    /**
+     * @tc.steps:step1. Device A inserts data and synchronizes
+     * @tc.expected: step1 OK.
+     */
+    Key key = {'k'};
+    Value value = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+
+    /**
+     * @tc.steps:step2. Device A delete data and synchronizes, Device B delete data and sync before A upload
+     * @tc.expected: step2 OK.
+     */
+    ASSERT_EQ(kvDelegatePtrS1_->Delete(key), OK);
+    int upIdx = 0;
+    virtualCloudDb_->ForkUpload([&upIdx](const std::string &tableName, VBucket &extend) {
+        LOGD("cloud db upload index:%d", ++upIdx);
+        if (upIdx == 2) { // 2 is index
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_RECORD_NOT_FOUND);
+        }
+    });
+    int doUpIdx = 0;
+    cloudHook->SetDoUploadHook([&doUpIdx, key, this] {
+        LOGD("begin upload index:%d", ++doUpIdx);
+        ASSERT_EQ(kvDelegatePtrS2_->Delete(key), OK);
+        BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+    });
+    int syncCnt = 0;
+    cloudHook->SetSyncFinishHook([&syncCnt, this] {
+        LOGD("sync finish times:%d", ++syncCnt);
+        if (syncCnt == 1) { // 1 is the normal sync
+            CheckUploadAbnormal(OpType::DELETE, 1L); // 1 is expected count
+        } else {
+            CheckUploadAbnormal(OpType::DELETE, 1L, true); // 1 is expected count
+        }
+        comSyncCv.notify_all();
+    });
+    BlockSync(kvDelegatePtrS1_, CLOUD_ERROR, g_CloudSyncoption);
+    BlockCompensatedSync(syncCnt, 1); // 1 is sync times
+    virtualCloudDb_->ForkUpload(nullptr);
+    cloudHook->SetSyncFinishHook(nullptr);
+    cloudHook->SetDoUploadHook(nullptr);
+}
+
+/**
+ * @tc.name: QueryParsingProcessTest001
+ * @tc.desc: Test Query parsing process.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: luoguo
+ */
+HWTEST_F(DistributedDBCloudKvSyncerTest, QueryParsingProcessTest001, TestSize.Level0)
+{
+    auto cloudHook = (ICloudSyncStorageHook *) singleStore_->GetCloudKvStore();
+    ASSERT_NE(cloudHook, nullptr);
+
+    /**
+     * @tc.steps:step1. Device A inserts data and synchronizes
+     * @tc.expected: step1 OK.
+     */
+    Key key = {'k'};
+    Value value = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+
+    /**
+     * @tc.steps:step2. Test Query parsing Process
+     * @tc.expected: step2 OK.
+     */
+    QuerySyncObject syncObject;
+    std::vector<VBucket> syncDataPk;
+    VBucket bucket;
+    bucket.insert_or_assign(std::string("k"), std::string("k"));
+    syncDataPk.push_back(bucket);
+    std::string tableName = "sync_data";
+    ASSERT_EQ(CloudStorageUtils::GetSyncQueryByPk(tableName, syncDataPk, true, syncObject), E_OK);
+
+    Bytes bytes;
+    bytes.resize(syncObject.CalculateParcelLen(SOFTWARE_VERSION_CURRENT));
+    Parcel parcel(bytes.data(), bytes.size());
+    ASSERT_EQ(syncObject.SerializeData(parcel, SOFTWARE_VERSION_CURRENT), E_OK);
+
+    /**
+     * @tc.steps:step3. Check Node's type is QueryNodeType::IN.
+     * @tc.expected: step3 OK.
+     */
+    std::vector<QueryNode> queryNodes;
+    syncObject.ParserQueryNodes(bytes, queryNodes);
+    ASSERT_EQ(queryNodes[0].type, QueryNodeType::IN);
+}
+}
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_test.cpp
index d7d264a5199f0ebad487c6e9eccf72c816220c7a..ad26f0716a2d160bcc6d5baa397f89bfd0f14780 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_kv_test.cpp
@@ -21,6 +21,7 @@
 #include "kv_virtual_device.h"
 #include "kv_store_nb_delegate.h"
 #include "platform_specific.h"
+#include "kv_store_nb_delegate_impl.h"
 #include "process_system_api_adapter_impl.h"
 #include "virtual_communicator_aggregator.h"
 #include "virtual_cloud_db.h"
@@ -256,15 +257,20 @@ HWTEST_F(DistributedDBCloudKvTest, NormalSync001, TestSize.Level0)
     BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
     for (const auto &table : lastProcess_.tableProcess) {
         EXPECT_EQ(table.second.upLoadInfo.total, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 1u);
     }
     BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.downLoadInfo.total, 2u); // download 2 records
+        EXPECT_EQ(table.second.downLoadInfo.insertCount, 2u); // download 2 records
+    }
     Value actualValue;
     EXPECT_EQ(kvDelegatePtrS2_->Get(key, actualValue), OK);
     EXPECT_EQ(actualValue, expectValue);
     kvDelegatePtrS1_->SetGenCloudVersionCallback(nullptr);
     auto result = kvDelegatePtrS2_->GetCloudVersion("");
     EXPECT_EQ(result.first, OK);
-    for (auto item : result.second) {
+    for (const auto &item : result.second) {
         EXPECT_EQ(item.second, "1");
     }
 }
@@ -403,7 +409,13 @@ HWTEST_F(DistributedDBCloudKvTest, NormalSync005, TestSize.Level1)
         ASSERT_EQ(kvDelegatePtrS1_->Put(key, expectValue), OK);
     }
     BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    for (const auto &process : lastProcess_.tableProcess) {
+        EXPECT_EQ(process.second.upLoadInfo.insertCount, 60u); // sync 60 records
+    }
     BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+    for (const auto &process : lastProcess_.tableProcess) {
+        EXPECT_EQ(process.second.downLoadInfo.insertCount, 60u); // sync 60 records
+    }
 }
 
 /**
@@ -635,19 +647,26 @@ HWTEST_F(DistributedDBCloudKvTest, NormalSync013, TestSize.Level0)
  */
 HWTEST_F(DistributedDBCloudKvTest, NormalSync014, TestSize.Level1)
 {
+    /**
+     * @tc.steps: step1. kvDelegatePtrS1_ put and sync data (k1, v1)
+     * @tc.expected: step1.ok
+     */
     g_mgr.SetSyncActivationCheckCallback([] (const std::string &userId, const std::string &appId,
         const std::string &storeId)-> bool {
         return true;
     });
-
     KvStoreNbDelegate* kvDelegatePtrS3_ = nullptr;
     KvStoreNbDelegate::Option option;
     option.syncDualTupleMode = true;
     GetKvStore(kvDelegatePtrS3_, STORE_ID_3, option);
     Key key = {'k', '1'};
     Value value = {'v', '1'};
-    ASSERT_EQ(kvDelegatePtrS3_->Put(key, value), OK);
-
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    /**
+     * @tc.steps: step2. Set sync block time 2s, and change user in sync block time
+     * @tc.expected: step2. Sync return  USER_CHANGED.
+     */
     virtualCloudDb_->SetBlockTime(2000); // 2000ms
     std::thread thread([&]() {
         std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // sleep for 1000ms
@@ -933,7 +952,7 @@ HWTEST_F(DistributedDBCloudKvTest, NormalSync022, TestSize.Level0)
     cloudDbs[USER_ID] = virtualCloudDb_;
     cloudDbs[USER_ID_2] = virtualCloudDb2_;
     memoryDB1->SetCloudDB(cloudDbs);
-    BlockSync(memoryDB1, OK, g_CloudSyncoption, CLOUD_ERROR);
+    BlockSync(memoryDB1, OK, g_CloudSyncoption, SCHEMA_MISMATCH);
     EXPECT_EQ(g_mgr.CloseKvStore(memoryDB1), OK);
 }
 
@@ -1041,6 +1060,227 @@ HWTEST_F(DistributedDBCloudKvTest, NormalSync026, TestSize.Level0)
     CloseKvStore(kvDelegatePtrS3_, STORE_ID_3);
 }
 
+/**
+ * @tc.name: NormalSync028
+ * @tc.desc: Test multi user sync.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync028, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. put 1 record and sync.
+     * @tc.expected: step1 OK.
+     */
+    Key key = {'k'};
+    Value value = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, value), OK);
+    auto option = g_CloudSyncoption;
+    option.users = {USER_ID, USER_ID_2};
+    BlockSync(kvDelegatePtrS1_, OK, option);
+    option.users = {USER_ID_2};
+    BlockSync(kvDelegatePtrS2_, OK, option);
+    option.users = {USER_ID, USER_ID_2};
+    BlockSync(kvDelegatePtrS2_, OK, option);
+    EXPECT_EQ(lastProcess_.tableProcess[USER_ID_2].downLoadInfo.total, 0u);
+}
+
+/**
+ * @tc.name: NormalSync032
+ * @tc.desc: Test some record upload fail in 1 batch.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync032, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. put 10 records.
+     * @tc.expected: step1 ok.
+     */
+    vector<Entry> entries;
+    int count = 10; // put 10 records.
+    for (int i = 0; i < count; i++) {
+        std::string keyStr = "k_" + std::to_string(i);
+        std::string valueStr = "v_" + std::to_string(i);
+        Key key(keyStr.begin(), keyStr.end());
+        Value value(valueStr.begin(), valueStr.end());
+        entries.push_back({key, value});
+    }
+    EXPECT_EQ(kvDelegatePtrS1_->PutBatch(entries), OK);
+    /**
+     * @tc.steps:step2. sync and set the last record upload fail.
+     * @tc.expected: step2 sync fail and upLoadInfo.failCount is 1.
+     */
+    int uploadFailId = 0;
+    virtualCloudDb_->ForkInsertConflict([&uploadFailId](const std::string &tableName, VBucket &extend, VBucket &record,
+        std::vector<VirtualCloudDb::CloudData> &cloudDataVec) {
+        uploadFailId++;
+        if (uploadFailId == 10) { // 10 is the last record
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_ERROR);
+            return CLOUD_ERROR;
+        }
+        return OK;
+    });
+    BlockSync(kvDelegatePtrS1_, CLOUD_ERROR, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 10u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 9u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 9u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 1u);
+    }
+    virtualCloudDb_->ForkUpload(nullptr);
+}
+
+/**
+ * @tc.name: NormalSync033
+ * @tc.desc: test sync with different operation type and check upLoadInfo
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync033, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. put local records {k1, v1} {k2, v2} and sync to cloud.
+     * @tc.expected: step1 ok.
+     */
+    Key key1 = {'k', '1'};
+    Value value1 = {'v', '1'};
+    kvDelegatePtrS1_->Put(key1, value1);
+    Key key2 = {'k', '2'};
+    Value value2 = {'v', '2'};
+    kvDelegatePtrS1_->Put(key2, value2);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    /**
+     * @tc.steps:step2. put {k3, v3}, delete {k1, v1}, and put {k2, v3}
+     * @tc.expected: step2 ok.
+     */
+    Key key3 = {'k', '3'};
+    Value value3 = {'v', '3'};
+    kvDelegatePtrS1_->Put(key3, value3);
+    kvDelegatePtrS1_->Delete(key1);
+    kvDelegatePtrS1_->Put(key2, value3);
+    /**
+     * @tc.steps:step3. sync and check upLoadInfo
+     * @tc.expected: step3 ok.
+     */
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 3u);
+        EXPECT_EQ(table.second.upLoadInfo.batchIndex, 3u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 3u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.deleteCount, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.updateCount, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 0u);
+    }
+}
+
+/**
+ * @tc.name: NormalSync036
+ * @tc.desc: test sync data with SetCloudSyncConfig.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync036, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. put data and SetCloudSyncConfig.
+     * @tc.expected: step1 ok.
+     */
+    CloudSyncConfig config;
+    int maxUploadCount = 40;
+    config.maxUploadCount = maxUploadCount;
+    kvDelegatePtrS1_->SetCloudSyncConfig(config);
+    Key key = {'k', '1'};
+    Value value = {'v', '1'};
+    kvDelegatePtrS1_->Put(key, value);
+    /**
+     * @tc.steps:step2. sync.
+     * @tc.expected: step2 ok.
+     */
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+}
+
+/**
+ * @tc.name: NormalSync041
+ * @tc.desc: Test concurrent sync and close DB.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync041, TestSize.Level1)
+{
+    /**
+     * @tc.steps:step1. put data to cloud.
+     * @tc.expected: step1 ok.
+     */
+    Key key = {'k', '1'};
+    Value value = {'v', '1'};
+    kvDelegatePtrS1_->Put(key, value);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+
+    /**
+     * @tc.steps:step2. sync and close DB concurrently.
+     * @tc.expected: step2 ok.
+     */
+    KvStoreNbDelegate* kvDelegatePtrS3_ = nullptr;
+    KvStoreNbDelegate::Option option;
+    EXPECT_EQ(GetKvStore(kvDelegatePtrS3_, STORE_ID_3, option), OK);
+    virtualCloudDb_->ForkQuery([](const std::string &tableName, VBucket &extend) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(200)); // sleep for 200ms
+    });
+    KvStoreDelegateManager &mgr = g_mgr;
+    std::thread syncThread([&mgr, &kvDelegatePtrS3_]() {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // sleep for 100ms
+        EXPECT_EQ(mgr.CloseKvStore(kvDelegatePtrS3_), OK);
+    });
+    EXPECT_EQ(kvDelegatePtrS3_->Sync(g_CloudSyncoption, nullptr), OK);
+    syncThread.join();
+}
+
+/**
+ * @tc.name: NormalSync045
+ * @tc.desc: Test some record upload fail in 1 batch and extend size greater than record size
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangtao
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSync045, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. put 10 records.
+     * @tc.expected: step1 ok.
+     */
+    vector<Entry> entries;
+    int count = 10; // put 10 records.
+    for (int i = 0; i < count; i++) {
+        std::string keyStr = "k_" + std::to_string(i);
+        std::string valueStr = "v_" + std::to_string(i);
+        Key key(keyStr.begin(), keyStr.end());
+        Value value(valueStr.begin(), valueStr.end());
+        entries.push_back({key, value});
+    }
+    EXPECT_EQ(kvDelegatePtrS1_->PutBatch(entries), OK);
+    /**
+     * @tc.steps:step2. sync and add one empty extend as result
+     * @tc.expected: step2 sync fail and upLoadInfo.failCount is 10. 1 batch failed.
+     */
+    std::atomic<int> missCount = -1;
+    virtualCloudDb_->SetClearExtend(missCount);
+    BlockSync(kvDelegatePtrS1_, CLOUD_ERROR, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 10u);
+        EXPECT_EQ(table.second.upLoadInfo.successCount, 0u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 0u);
+        EXPECT_EQ(table.second.upLoadInfo.failCount, 10u);
+    }
+    virtualCloudDb_->ForkUpload(nullptr);
+}
+
 /**
  * @tc.name: SyncOptionCheck001
  * @tc.desc: Test sync without user.
@@ -2024,4 +2264,339 @@ HWTEST_F(DistributedDBCloudKvTest, RemoveDeviceTest010, TestSize.Level0)
     EXPECT_EQ(kvDelegatePtrS1_->RemoveDeviceData("", "", ClearMode::DEFAULT), OK);
     EXPECT_EQ(kvDelegatePtrS1_->RemoveDeviceData("", ClearMode::DEFAULT), OK);
 }
-}
\ No newline at end of file
+
+/**
+ * @tc.name: RemoveDeviceTest011
+ * @tc.desc: remove record while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, RemoveDeviceTest011, TestSize.Level0)
+{
+    const KvStoreNbDelegate::Option option = {true, true};
+    KvStoreNbDelegate *kvDelegateInvalidPtrS1_ = nullptr;
+    ASSERT_EQ(GetKvStore(kvDelegateInvalidPtrS1_, "RemoveDeviceTest011", option), OK);
+    ASSERT_NE(kvDelegateInvalidPtrS1_, nullptr);
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegateInvalidPtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(kvDelegateInvalidPtrS1_->RemoveDeviceData("", ClearMode::FLAG_ONLY), DB_ERROR);
+    EXPECT_EQ(kvDelegateInvalidPtrS1_->RemoveDeviceData("", "", ClearMode::FLAG_ONLY), DB_ERROR);
+    EXPECT_EQ(g_mgr.CloseKvStore(kvDelegateInvalidPtrS1_), OK);
+}
+
+/**
+ * @tc.name: RemoveDeviceTest012
+ * @tc.desc: Test remove all data from other device.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudKvTest, RemoveDeviceTest012, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. Insert three record, k0 from device sync, k1 from local write, k2 from cloud sync.
+     * * @tc.expected: step1. insert successfully
+    */
+    int recordNum = 3;
+    InsertRecord(recordNum);
+    SetFlag({'k', '0'}, LogInfoFlag::FLAG_CLOUD);
+    SetFlag({'k', '1'}, LogInfoFlag::FLAG_LOCAL);
+    /**
+     * @tc.steps: step2. Remove data from device sync and cloud sync, and remove log.
+     * * @tc.expected: step2. All data and log are removed except data from local write.
+    */
+    EXPECT_EQ(kvDelegatePtrS1_->RemoveDeviceData(), OK);
+    Value actualValue;
+    Value expectValue = {'k', '1'};
+    EXPECT_EQ(kvDelegatePtrS1_->Get({'k', '1'}, actualValue), OK);
+    EXPECT_EQ(actualValue, expectValue);
+    EXPECT_EQ(kvDelegatePtrS1_->Get({'k', '0'}, actualValue), NOT_FOUND);
+    EXPECT_EQ(kvDelegatePtrS1_->Get({'k', '2'}, actualValue), NOT_FOUND);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid001
+ * @tc.desc: Test normal push not sync and get cloud version.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid001, TestSize.Level0)
+{
+    Key key = {'k'};
+    Value expectValue = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, expectValue), OK);
+    kvDelegatePtrS1_->SetGenCloudVersionCallback([](const std::string &origin) {
+        LOGW("origin is %s", origin.c_str());
+        return origin + "1";
+    });
+    Value actualValue;
+    EXPECT_EQ(kvDelegatePtrS1_->Get(key, actualValue), OK);
+    EXPECT_EQ(actualValue, expectValue);
+    kvDelegatePtrS1_->SetGenCloudVersionCallback(nullptr);
+    auto result = kvDelegatePtrS1_->GetCloudVersion("");
+    EXPECT_EQ(result.first, NOT_FOUND);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid002
+ * @tc.desc: Test normal push sync and use invalidDevice to get cloud version.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid002, TestSize.Level0)
+{
+    Key key = {'k'};
+    Value expectValue = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, expectValue), OK);
+    kvDelegatePtrS1_->SetGenCloudVersionCallback([](const std::string &origin) {
+        LOGW("origin is %s", origin.c_str());
+        return origin + "1";
+    });
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 1u);
+    }
+    BlockSync(kvDelegatePtrS2_, OK, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.downLoadInfo.total, 2u); // download 2 records
+        EXPECT_EQ(table.second.downLoadInfo.insertCount, 2u); // download 2 records
+    }
+    Value actualValue;
+    EXPECT_EQ(kvDelegatePtrS2_->Get(key, actualValue), OK);
+    EXPECT_EQ(actualValue, expectValue);
+    kvDelegatePtrS1_->SetGenCloudVersionCallback(nullptr);
+    std::string invalidDevice = std::string(DBConstant::MAX_DEV_LENGTH + 1, '0');
+    auto result = kvDelegatePtrS2_->GetCloudVersion(invalidDevice);
+    EXPECT_EQ(result.first, INVALID_ARGS);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid003
+ * @tc.desc: Test normal push sync for add data while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid003, TestSize.Level0)
+{
+    const KvStoreNbDelegate::Option option = {true, true};
+    KvStoreNbDelegate *kvDelegateInvalidPtrS1_ = nullptr;
+    ASSERT_EQ(GetKvStore(kvDelegateInvalidPtrS1_, "NormalSyncInvalid003", option), OK);
+    ASSERT_NE(kvDelegateInvalidPtrS1_, nullptr);
+    Key key = {'k'};
+    Value expectValue = {'v'};
+    ASSERT_EQ(kvDelegateInvalidPtrS1_->Put(key, expectValue), OK);
+    kvDelegateInvalidPtrS1_->SetGenCloudVersionCallback([](const std::string &origin) {
+        LOGW("origin is %s", origin.c_str());
+        return origin + "1";
+    });
+    BlockSync(kvDelegateInvalidPtrS1_, OK, g_CloudSyncoption);
+    for (const auto &table : lastProcess_.tableProcess) {
+        EXPECT_EQ(table.second.upLoadInfo.total, 1u);
+        EXPECT_EQ(table.second.upLoadInfo.insertCount, 1u);
+    }
+    Value actualValue;
+    EXPECT_EQ(kvDelegateInvalidPtrS1_->Get(key, actualValue), OK);
+    EXPECT_EQ(actualValue, expectValue);
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegateInvalidPtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    kvDelegateInvalidPtrS1_->SetGenCloudVersionCallback(nullptr);
+    auto result = kvDelegateInvalidPtrS1_->GetCloudVersion("");
+    EXPECT_EQ(result.first, DB_ERROR);
+    EXPECT_EQ(g_mgr.CloseKvStore(kvDelegateInvalidPtrS1_), OK);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid004
+ * @tc.desc: Test normal push sync use GetDeviceEntries while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid004, TestSize.Level0)
+{
+    const KvStoreNbDelegate::Option option = {true, true};
+    KvStoreNbDelegate *kvDelegateInvalidPtrS2_ = nullptr;
+    ASSERT_EQ(GetKvStore(kvDelegateInvalidPtrS2_, "NormalSyncInvalid004", option), OK);
+    ASSERT_NE(kvDelegateInvalidPtrS2_, nullptr);
+    /**
+     * @tc.steps: step1. store1 put (k1,v1) store2 put (k2,v2)
+     * @tc.expected: step1. both put ok
+     */
+    communicatorAggregator_->SetLocalDeviceId("DEVICES_A");
+    kvDelegatePtrS1_->SetGenCloudVersionCallback([](const std::string &origin) {
+        LOGW("origin is %s", origin.c_str());
+        return origin + "1";
+    });
+    kvDelegateInvalidPtrS2_->SetGenCloudVersionCallback([](const std::string &origin) {
+        LOGW("origin is %s", origin.c_str());
+        return origin + "1";
+    });
+    Key key1 = {'k', '1'};
+    Value expectValue1 = {'v', '1'};
+    Key key2 = {'k', '2'};
+    Value expectValue2 = {'v', '2'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key1, expectValue1), OK);
+    ASSERT_EQ(kvDelegateInvalidPtrS2_->Put(key2, expectValue2), OK);
+    /**
+     * @tc.steps: step2. both store1 and store2 sync while conn is nullptr
+     * @tc.expected: step2. both sync ok, and store2 got (k1,v1) store1 not exist (k2,v2)
+     */
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption);
+    LOGW("Store1 sync end");
+    communicatorAggregator_->SetLocalDeviceId("DEVICES_B");
+    BlockSync(kvDelegateInvalidPtrS2_, OK, g_CloudSyncoption);
+    LOGW("Store2 sync end");
+    Value actualValue;
+    EXPECT_EQ(kvDelegateInvalidPtrS2_->Get(key1, actualValue), OK);
+
+    /**
+     * @tc.steps: step3. use GetDeviceEntries while conn is nullptr
+     * @tc.expected: step3. DB_ERROR
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegateInvalidPtrS2_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    std::vector<Entry> entries;
+    EXPECT_EQ(kvDelegateInvalidPtrS2_->GetDeviceEntries(std::string("DEVICES_A"), entries), DB_ERROR);
+    EXPECT_EQ(entries.size(), 0u); // 1 record
+    communicatorAggregator_->SetLocalDeviceId("DEVICES_A");
+    EXPECT_EQ(actualValue, expectValue1);
+    EXPECT_EQ(kvDelegatePtrS1_->Get(key2, actualValue), NOT_FOUND);
+
+    kvDelegatePtrS1_->SetGenCloudVersionCallback(nullptr);
+    kvDelegateInvalidPtrS2_->SetGenCloudVersionCallback(nullptr);
+    EXPECT_EQ(g_mgr.CloseKvStore(kvDelegateInvalidPtrS2_), OK);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid005
+ * @tc.desc: Test normal sync with invalid parm.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid005, TestSize.Level0)
+{
+    Key key = {'k'};
+    Value expectValue = {'v'};
+    ASSERT_EQ(kvDelegatePtrS1_->Put(key, expectValue), OK);
+    auto devices = g_CloudSyncoption.devices;
+    EXPECT_EQ(kvDelegatePtrS1_->Sync(devices, SyncMode::SYNC_MODE_CLOUD_MERGE, nullptr), NOT_SUPPORT);
+    Query query = Query::Select().Range({}, {});
+    EXPECT_EQ(kvDelegatePtrS1_->Sync(devices, SyncMode::SYNC_MODE_CLOUD_MERGE, nullptr, query, true), NOT_SUPPORT);
+    auto mode = g_CloudSyncoption.mode;
+    EXPECT_EQ(kvDelegatePtrS1_->Sync(devices, mode, nullptr, query, true), NOT_SUPPORT);
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegatePtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    BlockSync(kvDelegatePtrS1_, OK, g_CloudSyncoption, DB_ERROR);
+    EXPECT_EQ(kvDelegatePtrS1_->Sync(devices, mode, nullptr), DB_ERROR);
+    EXPECT_EQ(kvDelegatePtrS1_->Sync(devices, mode, nullptr, query, true), DB_ERROR);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid006
+ * @tc.desc: Test normal sync set cloudDB while cloudDB is empty and conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid006, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. set cloudDB while cloudDB is empty
+     * @tc.expected: step1. INVALID_ARGS
+     */
+    std::map<std::string, std::shared_ptr<ICloudDb>> cloudDbs;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudDB(cloudDbs), INVALID_ARGS);
+    /**
+     * @tc.steps: step2. set cloudDB while conn is nullptr
+     * @tc.expected: step2. DB_ERROR
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegatePtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    cloudDbs[USER_ID] = virtualCloudDb_;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudDB(cloudDbs), DB_ERROR);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid007
+ * @tc.desc: Test normal sync set cloudDb schema while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid007, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. set cloudDB schema while conn is nullptr
+     * @tc.expected: step1. DB_ERROR
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegatePtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    std::map<std::string, DataBaseSchema> schemas;
+    schemas[USER_ID] = GetDataBaseSchema(true);
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudDbSchema(schemas), DB_ERROR);
+}
+
+/**
+ * @tc.name: NormalSyncInvalid008
+ * @tc.desc: Test SetCloudSyncConfig with invalid parm.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBCloudKvTest, NormalSyncInvalid008, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. SetCloudSyncConfig with invalid maxUploadCount.
+     * @tc.expected: step1. INVALID_ARGS
+     */
+    CloudSyncConfig config;
+    int maxUploadCount = 0;
+    config.maxUploadCount = maxUploadCount;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), INVALID_ARGS);
+    maxUploadCount = 2001;
+    config.maxUploadCount = maxUploadCount;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), INVALID_ARGS);
+    maxUploadCount = 50;
+    config.maxUploadCount = maxUploadCount;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), OK);
+
+    /**
+     * @tc.steps: step2. SetCloudSyncConfig with invalid maxUploadSize.
+     * @tc.expected: step2. INVALID_ARGS
+     */
+    int maxUploadSize = 1023;
+    config.maxUploadSize = maxUploadSize;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), INVALID_ARGS);
+    maxUploadSize = 128 * 1024 * 1024 + 1;
+    config.maxUploadSize = maxUploadSize;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), INVALID_ARGS);
+    maxUploadSize = 10240;
+    config.maxUploadSize = maxUploadSize;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), OK);
+
+    /**
+     * @tc.steps: step3. SetCloudSyncConfig with invalid maxRetryConflictTimes.
+     * @tc.expected: step3. INVALID_ARGS
+     */
+    int maxRetryConflictTimes = -2;
+    config.maxRetryConflictTimes = maxRetryConflictTimes;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), INVALID_ARGS);
+    maxRetryConflictTimes = 2;
+    config.maxRetryConflictTimes = maxRetryConflictTimes;
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), OK);
+
+    /**
+     * @tc.steps: step4. SetCloudSyncConfig while conn is nullptr
+     * @tc.expected: step4. DB_ERROR
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(kvDelegatePtrS1_);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    EXPECT_EQ(kvDelegatePtrS1_->SetCloudSyncConfig(config), DB_ERROR);
+}
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_strategy_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_strategy_test.cpp
index 0085ebdb3bbe8d23601907af56c28996a106782f..6560ded5e9c710fbc8031bfcc2c0282c27bd0e99 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_strategy_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_strategy_test.cpp
@@ -104,61 +104,63 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest001, TestSize.Level0)
      * @tc.steps: step2. local not exist cloud record
      * @tc.expected: step2. insert cloud record to local
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::INSERT);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::INSERT);
     /**
-     * @tc.steps: step3. local record is newer and local not exist gid
+     * @tc.steps: step3. local record is newer and local not exist gid, while local data is not sync-ed
      * @tc.expected: step3. only update gid
      */
     localInfo.timestamp = 1u;
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
+    localInfo.flag = static_cast<uint64_t>(LogInfoFlag::FLAG_LOCAL);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
     /**
      * @tc.steps: step4. local record is newer and local exist gid
      * @tc.expected: step4. no need handle this record
      */
     localInfo.cloudGid = "gid";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
     /**
      * @tc.steps: step5. cloud record is newer
      * @tc.expected: step5. update cloud record
      */
     cloudInfo.timestamp = 2u; // mark 2 means cloud is new
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::UPDATE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE);
     /**
      * @tc.steps: step6. cloud record is newer and it is delete
      * @tc.expected: step6. delete cloud record
      */
     cloudInfo.flag = 0x01; // it means delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::DELETE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::DELETE);
     /**
      * @tc.steps: step7. cloud is new and local is delete
      * @tc.expected: step7 insert cloud record
      */
     cloudInfo.flag = 0; // it means no delete
     localInfo.flag = 0x01; // it means delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::INSERT);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::INSERT);
     /**
      * @tc.steps: step8. cloud is new and local both delete
      * @tc.expected: step8 not handle cloud record
      */
     cloudInfo.flag = 0x01; // it means delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::UPDATE_TIMESTAMP);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE_TIMESTAMP);
     /**
      * @tc.steps: step9. cloud is delete and local not exist
      * @tc.expected: step9 not handle cloud record
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
     /**
      * @tc.steps: step10. cloud is old and delete, local has gid
      * @tc.expected: step10 clear gid
      */
     localInfo.timestamp = 3u; // mark 3 means local is new
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::CLEAR_GID);
+    localInfo.flag = static_cast<uint64_t>(LogInfoFlag::FLAG_LOCAL);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::CLEAR_GID);
     /**
      * @tc.steps: step10. cloud is old and delete, local has not gid
      * @tc.expected: step10 not handle cloud record
      */
     localInfo.cloudGid = "";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
     /**
      * @tc.steps: step11. cloud has same timestamp with local, and local has empty gid
      * @tc.expected: step11 only update gid
@@ -166,7 +168,15 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest001, TestSize.Level0)
     cloudInfo.timestamp = localInfo.timestamp;
     cloudInfo.flag = 0; // it means no delete
     localInfo.flag = 0; // it means no delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
+
+    /**
+     * @tc.steps: step12. local record is newer and local not exist gid, while record is sync-ed
+     * @tc.expected: step12. update
+     */
+    localInfo.timestamp = 4u;
+    localInfo.flag = static_cast<uint64_t>(LogInfoFlag::FLAG_CLOUD);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE);
 }
 
 /**
@@ -190,33 +200,33 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest002, TestSize.Level0)
      * @tc.steps: step2. local not exist cloud record
      * @tc.expected: step2. not handle
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
 
     /**
      * @tc.steps: step3. local has cloud record but don't have gid
      * @tc.expected: step3. only update gid
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::ONLY_UPDATE_GID);
 
     /**
      * @tc.steps: step4. local has cloud record and have gid
      * @tc.expected: step4. not handle
      */
     localInfo.cloudGid = "gid";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
     localInfo.cloudGid = "";
     /**
      * @tc.steps: step5. local has cloud record(without gid) but cloud flag is delete
      * @tc.expected: step5. ONLY UPDATE GID
      */
     cloudInfo.flag = 0x01; // it means delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
     /**
      * @tc.steps: step6. local has cloud record(with gid) but cloud flag is delete
      * @tc.expected: step6. CLEAR_GID
      */
     localInfo.cloudGid = "gid";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::CLEAR_GID);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::CLEAR_GID);
 }
 
 /**
@@ -240,7 +250,7 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest003, TestSize.Level0)
      * @tc.steps: step2. local not exist cloud record(without gid) and its not deleted in cloud
      * @tc.expected: step2. insert
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::INSERT);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::INSERT);
 
     /**
      * @tc.steps: step3. local not exist cloud record and it's deleted in cloud (without gid)
@@ -248,31 +258,31 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest003, TestSize.Level0)
      */
     localInfo.cloudGid = "";
     cloudInfo.flag = 0x01; // it means delete
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
 
     /**
      * @tc.steps: step4. local not exist cloud record and it's deleted in cloud (with gid)
      * @tc.expected: step4. delete
      */
     localInfo.cloudGid = "gid";
-    EXPECT_EQ(strategy->TagSyncDataStatus(false, localInfo, cloudInfo), OpType::DELETE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(false, false, localInfo, cloudInfo), OpType::DELETE);
 
     /**
      * @tc.steps: step5. local exist cloud record and its deleted in cloud
      * @tc.expected: step5. delete
      */
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::DELETE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::DELETE);
     localInfo.cloudGid = "";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::DELETE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::DELETE);
 
     /**
      * @tc.steps: step6. local exist cloud record and its not deleted in cloud(WITH OR WITHOUT gid)
      * @tc.expected: step6. UPDATE
      */
     cloudInfo.flag = 0x00;
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::UPDATE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE);
     localInfo.cloudGid = "gid";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::UPDATE);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE);
 }
 
 /**
@@ -295,11 +305,11 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest004, TestSize.Level0)
     cloudInfo.flag = 0x01;
     localInfo.flag = 0x01;
     localInfo.cloudGid = "";
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::UPDATE_TIMESTAMP);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE_TIMESTAMP);
 
     cloudInfo.flag = 0x00;
     localInfo.flag = 0x01;
-    EXPECT_EQ(strategy->TagSyncDataStatus(true, localInfo, cloudInfo), OpType::INSERT);
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::INSERT);
 }
 
 /**
@@ -322,4 +332,40 @@ HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest005, TestSize.Level0)
     EXPECT_EQ(syncer->CallTagStatusByStrategy(true, localInfo, cloudInfo, result), -E_INTERNAL_ERROR);
     RefObject::KillAndDecObjRef(syncer);
 }
+
+/**
+ * @tc.name: TagOpTyeTest006
+ * @tc.desc: Verify cloud merge strategy for same record.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBCloudStrategyTest, TagOpTyeTest006, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. create merge strategy
+     * @tc.expected: step1. create ok
+     */
+    auto strategy = StrategyFactory::BuildSyncStrategy(SyncMode::SYNC_MODE_CLOUD_MERGE);
+    ASSERT_NE(strategy, nullptr);
+    /**
+     * @tc.steps: step2. build cloud and local info, both has same version and diff timestamp
+     * @tc.expected: step2. strategy res is NOT_HANDLE
+     */
+    LogInfo localInfo;
+    LogInfo cloudInfo;
+    localInfo.cloudGid = "gid";
+    localInfo.version = "version";
+    localInfo.timestamp = 1;
+    cloudInfo.cloudGid = "gid";
+    cloudInfo.version = "version";
+    cloudInfo.timestamp = localInfo.timestamp + 1;
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::NOT_HANDLE);
+    /**
+     * @tc.steps: step3. make timestamp gap is more than 1s
+     * @tc.expected: step3. strategy res is UPDATE
+     */
+    cloudInfo.timestamp = cloudInfo.timestamp + CloudDbConstant::ONE_SECOND;
+    EXPECT_EQ(strategy->TagSyncDataStatus(true, false, localInfo, cloudInfo), OpType::UPDATE);
+}
 }
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp
index c1921eb1b4a837aaf6f2241fed133d5bcd29e7b7..9401a1f5b544af815e13db53369b97342eaa468e 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_assets_test.cpp
@@ -223,6 +223,46 @@ void DeleteCloudDBData(int64_t begin, int64_t count, const std::string &tableNam
     }
 }
 
+void UpdateCloudDBData(int64_t begin, int64_t count, int64_t gidStart, int64_t versionStart,
+    const std::string &tableName)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    std::vector<VBucket> record;
+    std::vector<VBucket> extend;
+    GenerateDataRecords(begin, count, gidStart, record, extend);
+    for (auto &entry: extend) {
+        entry[CloudDbConstant::VERSION_FIELD] = std::to_string(versionStart++);
+    }
+    ASSERT_EQ(g_virtualCloudDb->BatchUpdate(tableName, std::move(record), extend), DBStatus::OK);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+}
+
+int QueryStatusCallback(void *data, int count, char **colValue, char **colName)
+{
+    auto status = static_cast<std::vector<int64_t> *>(data);
+    int base = 10;
+    for (int i = 0; i < count; i++) {
+        status->push_back(strtol(colValue[0], nullptr, base));
+    }
+    return 0;
+}
+
+void CheckLockStatus(sqlite3 *db, int startId, int endId, LockStatus lockStatus)
+{
+    std::string logName = DBCommon::GetLogTableName(ASSETS_TABLE_NAME);
+    std::string sql = "select status from " + logName + " where data_key >=" + std::to_string(startId) +
+        " and data_key <=" +  std::to_string(endId) + ";";
+    std::vector<int64_t> status;
+    char *str = NULL;
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), QueryStatusCallback, static_cast<void *>(&status), &str),
+        SQLITE_OK);
+    ASSERT_EQ(static_cast<size_t>(endId - startId + 1), status.size());
+
+    for (auto stat : status) {
+        ASSERT_EQ(static_cast<int64_t>(lockStatus), stat);
+    }
+}
+
 void InsertCloudDBData(int64_t begin, int64_t count, int64_t gidStart, const std::string &tableName)
 {
     std::vector<VBucket> record;
@@ -275,7 +315,7 @@ void CheckDownloadForTest001(int index, map<std::string, Assets> &assets)
 {
     for (auto &item : assets) {
         for (auto &asset : item.second) {
-            EXPECT_EQ(AssetOperationUtils::EraseBitMask(asset.status), static_cast<uint32_t>(AssetStatus::DOWNLOADING));
+            EXPECT_EQ(AssetOperationUtils::EraseBitMask(asset.status), static_cast<uint32_t>(AssetStatus::INSERT));
             if (index < 4) { // 1-4 is inserted
                 EXPECT_EQ(asset.flag, static_cast<uint32_t>(AssetOpType::INSERT));
             }
@@ -330,17 +370,13 @@ void UpdateAssetsForLocal(sqlite3 *&db, int id, uint32_t status)
 
 void CheckConsistentCount(sqlite3 *db, int64_t expectCount)
 {
-    std::string sql = "select count(*) from " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) +
-    " where flag&0x20=0;";
-    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+    EXPECT_EQ(sqlite3_exec(db, QUERY_CONSISTENT_SQL.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
         reinterpret_cast<void *>(expectCount), nullptr), SQLITE_OK);
 }
 
 void CheckCompensatedCount(sqlite3 *db, int64_t expectCount)
 {
-    std::string sql = "select count(*) from " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) +
-    " where flag&0x10!=0;";
-    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+    EXPECT_EQ(sqlite3_exec(db, QUERY_COMPENSATED_SQL.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
         reinterpret_cast<void *>(expectCount), nullptr), SQLITE_OK);
 }
 
@@ -948,7 +984,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId007, TestSize.Le
     g_virtualCloudDb->ForkUpload([](const std::string &tableName, VBucket &extend) {
         extend.erase("assets");
     });
-    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
     CheckLocaLAssets(ASSETS_TABLE_NAME, "0", {});
 
     /**
@@ -964,7 +1000,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId007, TestSize.Le
             }
         }
     });
-    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
     int beginFailFillNum = 101;
     int endFailFillNum = 120;
     std::set<int> index;
@@ -1004,7 +1040,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId008, TestSize.Le
             }
         }
     });
-    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
     CheckLocaLAssets(ASSETS_TABLE_NAME, "0", {});
 
     /**
@@ -1061,7 +1097,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId010, TestSize.Le
     std::atomic<int> count = 0;
     g_virtualCloudDb->ForkUpload([&count](const std::string &tableName, VBucket &extend) {
         if (extend.find("assets") != extend.end() && count == 0) {
-            extend["#_error"] = std::string("");
+            extend["#_error"] = static_cast<int64_t>(DBStatus::CLOUD_NETWORK_ERROR);
             count++;
         }
     });
@@ -1238,7 +1274,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId015, TestSize.Le
     std::atomic<int> count = 0;
     g_virtualCloudDb->ForkUpload([&count](const std::string &tableName, VBucket &extend) {
         if (extend.find("assets") != extend.end() && count == 0) {
-            extend["#_error"] = std::string("");
+            extend["#_error"] = static_cast<int64_t>(DBStatus::CLOUD_NETWORK_ERROR);
             count++;
         }
     });
@@ -1265,7 +1301,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId015, TestSize.Le
             num++;
         }
     });
-    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
     CheckLocaLAssets(ASSETS_TABLE_NAME, "10", {41}); // // 41th asset do not fill
 }
 
@@ -1313,14 +1349,14 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId017, TestSize.Le
     int localCount = 20;
     InsertLocalData(db, 0, localCount, ASSETS_TABLE_NAME, false);
     CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK);
-    CheckCursorData(ASSETS_TABLE_NAME, 0);
+    CheckCursorData(ASSETS_TABLE_NAME, 1);
 
     /**
      * @tc.steps:step2. sync again and optype is not change, check cursor.
      * @tc.expected: step2. return OK.
      */
     CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK);
-    CheckCursorData(ASSETS_TABLE_NAME, localCount);
+    CheckCursorData(ASSETS_TABLE_NAME, localCount + 1);
 }
 
 /**
@@ -1538,6 +1574,175 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId019, TestSize.Le
     EXPECT_EQ(g_delegate->RemoveDeviceData("", FLAG_ONLY), OK);
 }
 
+/**
+ * @tc.name: FillAssetId020
+ * @tc.desc: Test if assetId is filled when extend(lack of assets/assetId is empty/modify asset info)
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangtao
+ */
+HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId020, TestSize.Level0)
+{
+    CloudSyncConfig config;
+    config.maxUploadCount = 200; // max upload 200
+    g_delegate->SetCloudSyncConfig(config);
+ 
+    /**
+     * @tc.steps:step1. local insert assets and erase assets extends
+     * @tc.expected: step1. return OK.
+     */
+    int localCount = 50;
+    InsertLocalData(db, 0, localCount, ASSETS_TABLE_NAME);
+    g_virtualCloudDb->ForkUpload([](const std::string &tableName, VBucket &extend) {
+        extend.erase("assets");
+    });
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "0", {});
+ 
+    /**
+     * @tc.steps:step2. local insert assets and modify assetId to empty
+     * @tc.expected: step2. return OK.
+     */
+    int addLocalCount = 10;
+    InsertLocalData(db, localCount, addLocalCount, ASSETS_TABLE_NAME);
+    g_virtualCloudDb->ForkUpload([](const std::string &tableName, VBucket &extend) {
+        if (extend.find("assets") != extend.end()) {
+            for (auto &asset : std::get<Assets>(extend["assets"])) {
+                asset.assetId = "";
+            }
+        }
+    });
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
+    int beginFailFillNum = 101;
+    int endFailFillNum = 120;
+    std::set<int> index;
+    for (int i = beginFailFillNum; i <= endFailFillNum; i++) {
+        index.insert(i);
+    }
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "10", index);
+ 
+    /**
+     * @tc.steps:step3. local insert assets and modify assetId info such as asset.name
+     * @tc.expected: step3. return OK.
+     */
+    InsertLocalData(db, localCount + addLocalCount, addLocalCount, ASSETS_TABLE_NAME);
+    g_virtualCloudDb->ForkUpload([](const std::string &tableName, VBucket &extend) {
+        if (extend.find("assets") != extend.end()) {
+            for (auto &asset : std::get<Assets>(extend["assets"])) {
+                asset.name = "mod_pat";
+            }
+        }
+    });
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
+    beginFailFillNum = 121;
+    endFailFillNum = 140;
+    std::set<int> newIndex;
+    for (int i = beginFailFillNum; i <= endFailFillNum; i++) {
+        newIndex.insert(i);
+    }
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "10", newIndex);
+ 
+    /**
+     * @tc.steps:step4. local update assets and sync, check the local assetId.
+     * @tc.expected: step4. sync success.
+     */
+    g_virtualCloudDb->ForkUpload(nullptr);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK);
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "10", {});
+}
+
+/**
+ * @tc.name: FillAssetId021
+ * @tc.desc: Test if local assets missing, one records's assets missing will not mark the whole sync progress failure
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangtao
+ */
+HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId021, TestSize.Level0)
+{
+    CloudSyncConfig config;
+    config.maxUploadCount = 200; // max upload 200
+    g_delegate->SetCloudSyncConfig(config);
+ 
+    /**
+     * @tc.steps:step1. local insert assets and erase assets extends
+     * @tc.expected: step1. return OK.
+     */
+    int localCount = 50;
+    InsertLocalData(db, 0, localCount, ASSETS_TABLE_NAME);
+ 
+    /**
+     * @tc.steps:step2. ForkInsertConflict, make one record assets missing during batch insert
+     * @tc.expected: step2. SyncProgress return OK. One record's assets missing will not block other progress.
+     */
+    int uploadFailId = 0;
+    g_virtualCloudDb->ForkInsertConflict([&uploadFailId](const std::string &tableName, VBucket &extend, VBucket &record,
+        std::vector<VirtualCloudDb::CloudData> &cloudDataVec) {
+        uploadFailId++;
+        if (uploadFailId == 25) { // 25 is the middle record
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::LOCAL_ASSET_NOT_FOUND);
+            return DBStatus::LOCAL_ASSET_NOT_FOUND;
+        }
+        return OK;
+    });
+ 
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
+    int beginFailFillNum = 49;
+    int endFailFillNum = 50;
+    std::set<int> index;
+    for (int i = beginFailFillNum; i <= endFailFillNum; i++) {
+        index.insert(i);
+    }
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "10", index);
+    g_virtualCloudDb->ForkUpload(nullptr);
+}
+ 
+/**
+ * @tc.name: FillAssetId022
+ * @tc.desc: Test if local assets missing, many records's assets missing will not mark the whole sync progress failure
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangtao
+ */
+HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, FillAssetId022, TestSize.Level0)
+{
+    CloudSyncConfig config;
+    config.maxUploadCount = 200; // max upload 200
+    g_delegate->SetCloudSyncConfig(config);
+ 
+    /**
+     * @tc.steps:step1. local insert assets and erase assets extends
+     * @tc.expected: step1. return OK.
+     */
+    int localCount = 50;
+    InsertLocalData(db, 0, localCount, ASSETS_TABLE_NAME);
+ 
+    /**
+     * @tc.steps:step2. ForkInsertConflict, make one record assets missing during batch insert
+     * @tc.expected: step2. SyncProgress return OK. One record's assets missing will not block other progress.
+     */
+    int uploadFailId = 0;
+    g_virtualCloudDb->ForkInsertConflict([&uploadFailId](const std::string &tableName, VBucket &extend, VBucket &record,
+        std::vector<VirtualCloudDb::CloudData> &cloudDataVec) {
+        uploadFailId++;
+        if (uploadFailId >= 25 && uploadFailId <= 27) { // 25-27 is the middle record
+            extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::LOCAL_ASSET_NOT_FOUND);
+            return DBStatus::LOCAL_ASSET_NOT_FOUND;
+        }
+        return OK;
+    });
+ 
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::OK);
+    int beginFailFillNum = 49;
+    int endFailFillNum = 54;
+    std::set<int> index;
+    for (int i = beginFailFillNum; i <= endFailFillNum; i++) {
+        index.insert(i);
+    }
+    CheckLocaLAssets(ASSETS_TABLE_NAME, "10", index);
+    g_virtualCloudDb->ForkUpload(nullptr);
+}
+
 /**
  * @tc.name: ConsistentFlagTest001
  * @tc.desc:Assets are the different, check the 0x20 bit of flag after sync
@@ -1696,14 +1901,14 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, ConsistentFlagTest004, Test
     InsertCloudDBData(0, cloudCount, 0, ASSETS_TABLE_NAME);
 
     /**
-     * @tc.steps:step2. fork upload, return error filed of type string
+     * @tc.steps:step2. fork upload, not return error filed of CLOUD_NETWORK_ERROR
      * @tc.expected: step2. return OK.
      */
     int upIdx = 0;
     g_virtualCloudDb->ForkUpload([&upIdx](const std::string &tableName, VBucket &extend) {
         LOGD("upload index:%d", ++upIdx);
         if (upIdx == 1) {
-            extend.insert_or_assign(CloudDbConstant::ERROR_FIELD, std::string("x"));
+            extend.insert_or_assign(CloudDbConstant::ERROR_FIELD, static_cast<int64_t>(DBStatus::CLOUD_NETWORK_ERROR));
         }
     });
 
@@ -1737,7 +1942,7 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, ConsistentFlagTest004, Test
      * @tc.expected: step5. return OK.
      */
     CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK);
-    CheckConsistentCount(db, localCount - 1);
+    CheckConsistentCount(db, localCount - 2);
 }
 
 /**
@@ -2029,5 +2234,137 @@ HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, DownloadAssetTest001, TestS
         }
     }
 }
+
+/**
+ * @tc.name: DownloadAssetTest002
+ * @tc.desc: Test asset download failed and re download
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: liaoyonghuang
+ */
+HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, DownloadAssetTest002, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. init data
+     * @tc.expected: step1. return OK.
+     */
+    int cloudCount = 10; // 10 is num of cloud
+    InsertCloudDBData(0, cloudCount, 0, ASSETS_TABLE_NAME);
+
+    /**
+     * @tc.steps:step2. Set asset download status error and sync
+     * @tc.expected: step2. sync successful but download assets fail.
+     */
+    g_virtualAssetLoader->SetDownloadStatus(DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+
+    /**
+     * @tc.steps:step3. Set asset download status OK and sync
+     * @tc.expected: step3. return OK.
+     */
+    g_virtualAssetLoader->SetDownloadStatus(DBStatus::OK);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK);
+
+    /**
+     * @tc.steps:step4. Check assets status
+     * @tc.expected: step4. status is NORMAL.
+     */
+    std::string sql = "SELECT assets FROM " + ASSETS_TABLE_NAME + ";";
+    sqlite3_stmt *stmt = nullptr;
+    ASSERT_EQ(SQLiteUtils::GetStatement(db, sql, stmt), E_OK);
+    while (SQLiteUtils::StepWithRetry(stmt) != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        ASSERT_EQ(sqlite3_column_type(stmt, 0), SQLITE_BLOB);
+        Type cloudValue;
+        ASSERT_EQ(SQLiteRelationalUtils::GetCloudValueByType(stmt, TYPE_INDEX<Assets>, 0, cloudValue), E_OK);
+        Assets assets = g_virtualCloudDataTranslate->BlobToAssets(std::get<Bytes>(cloudValue));
+        for (const auto &asset : assets) {
+            EXPECT_EQ(asset.status, AssetStatus::NORMAL);
+        }
+    }
+    int errCode = E_OK;
+    SQLiteUtils::ResetStatement(stmt, true, errCode);
+    EXPECT_EQ(errCode, E_OK);
+}
+
+/**
+ * @tc.name: RecordLockFuncTest001
+ * @tc.desc: UNLOCKING->UNLOCKING Synchronous download failure wholly.
+ * @tc.type: FUNC
+ * @tc.author: lijun
+ */
+HWTEST_F(DistributedDBCloudSyncerDownloadAssetsTest, RecordLockFuncTest001, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. init local data
+     * @tc.expected: step1. return OK.
+     */
+    int localCount = 100;
+    int cloudCount = 100;
+    InsertLocalData(db, 0, localCount, ASSETS_TABLE_NAME, true);
+    std::string logName = DBCommon::GetLogTableName(ASSETS_TABLE_NAME);
+    std::string sql = "update " + logName + " SET status = 2 where data_key >=70;";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql), E_OK);
+    CheckLockStatus(db, 0, 69, LockStatus::UNLOCK);
+    CheckLockStatus(db, 70, 99, LockStatus::LOCK);
+    DeleteLocalRecord(db, 70, 30, ASSETS_TABLE_NAME);
+
+    /**
+     * @tc.steps:step2. init cloud data
+     * @tc.expected: step2. return OK.
+     */
+    InsertCloudDBData(0, cloudCount, 0, ASSETS_TABLE_NAME);
+    UpdateCloudDBData(0, 70, 0, 0, ASSETS_TABLE_NAME);
+
+    std::shared_ptr<MockAssetLoader> assetLoader = make_shared<MockAssetLoader>();
+    ASSERT_EQ(g_delegate->SetIAssetLoader(assetLoader), DBStatus::OK);
+    int index = 0;
+    EXPECT_CALL(*assetLoader, Download(testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(
+            [&index](const std::string &, const std::string &gid, const Type &, std::map<std::string, Assets> &assets) {
+                LOGD("Download GID:%s  %d", gid.c_str(), index);
+                index++;
+                if (index <= 30) {
+                    return DBStatus::CLOUD_ERROR;
+                } else {
+                    return DBStatus::OK;
+                }
+
+            });
+
+    std::mutex mtx;
+    std::condition_variable cv;
+    int queryIdx = 0;
+    g_virtualCloudDb->ForkQuery([&](const std::string &, VBucket &) {
+        LOGD("query index:%d", ++queryIdx);
+        if (queryIdx == 2) { // 2 is compensated sync
+            mtx.lock();
+            cv.notify_one();
+            mtx.unlock();
+            std::this_thread::sleep_for(std::chrono::seconds(2)); // block notify 2s
+        }
+    });
+    g_virtualAssetLoader->SetDownloadStatus(DBStatus::CLOUD_ERROR);
+    CallSync({ASSETS_TABLE_NAME}, SYNC_MODE_CLOUD_MERGE, DBStatus::OK, DBStatus::CLOUD_ERROR);
+
+    {
+        std::unique_lock<std::mutex> lock(mtx);
+        cv.wait(lock);
+    }
+    g_virtualAssetLoader->SetDownloadStatus(DBStatus::OK);
+
+    /**
+     * @tc.steps:step3. check before compensated sync
+     * @tc.expected: 70-99 is UNLOCKING.
+     */
+    CheckLockStatus(db, 0, 69, LockStatus::UNLOCK);
+    CheckLockStatus(db, 70, 99, LockStatus::UNLOCKING);
+
+    std::this_thread::sleep_for(std::chrono::seconds(3));
+    /**
+     * @tc.steps:step4. check after compensated sync
+     * @tc.expected: all is UNLOCKING.
+     */
+    CheckLockStatus(db, 0, 99, LockStatus::UNLOCK);
+}
 } // namespace
 #endif // RELATIONAL_STORE
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_test.cpp
index 1e7b84c6c9a2ff6dbd2c6528f5bac62eb58d5a15..2d0619ec26a142e95d9c7814c814090c21afdd00 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_download_test.cpp
@@ -737,13 +737,9 @@ HWTEST_F(DistributedDBCloudSyncerDownloadTest, DownloadMockTest007, TestSize.Lev
     });
     int errCode = g_cloudSyncer->CallDoDownloadInNeed(true, true);
     EXPECT_EQ(errCode, E_OK);
-    auto downloadStatus = g_cloudSyncer->GetDownloadFinishedStatus();
-    for (const auto &item : downloadStatus) {
-        for (const auto &[table, finish] : item.second) {
-            LOGI("check table %s", table.c_str());
-            EXPECT_TRUE(finish);
-        }
-    }
+    auto recorder = g_cloudSyncer->GetProcessRecorder();
+    ASSERT_NE(recorder, nullptr);
+    EXPECT_TRUE(recorder->IsDownloadFinish(0, g_cloudSyncer->GetCurrentContextTableName()));
 }
 
 /**
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_lock_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_lock_test.cpp
index d5c75540758c39e7febc10d10626cdd003855a82..b62dadef9f6546dcde0ec84ff645cf53a5f15a2c 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_lock_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_lock_test.cpp
@@ -65,6 +65,7 @@ const Asset ASSET_COPY = {.version = 1,
     .size = "256",
     .hash = "ASE"};
 const Assets ASSETS_COPY1 = { ASSET_COPY };
+const string ASSET_SUFFIX = "_copy";
 
 string g_storePath;
 string g_testDir;
@@ -115,9 +116,13 @@ protected:
     void InsertCloudDBData(int64_t begin, int64_t count, int64_t gidStart, const std::string &tableName);
     void UpdateCloudDBData(int64_t begin, int64_t count, int64_t gidStart, int64_t versionStart,
         const std::string &tableName);
+    void DeleteCloudDBData(int64_t beginGid, int64_t count, const std::string &tableName);
     void CallSync(const CloudSyncOption &option, DBStatus expectResult = OK);
 
     void TestConflictSync001(bool isUpdate);
+    void CheckAssetStatusNormal();
+    void UpdateCloudAssets(Asset &asset, Assets &assets, const std::string &version);
+    void CheckUploadAbnormal(OpType opType, int64_t expCnt, bool isCompensated = false);
     sqlite3 *db = nullptr;
 };
 
@@ -270,6 +275,22 @@ void DistributedDBCloudSyncerLockTest::UpdateCloudDBData(int64_t begin, int64_t
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
 }
 
+void DistributedDBCloudSyncerLockTest::DeleteCloudDBData(int64_t beginGid, int64_t count,
+    const std::string &tableName)
+{
+    Timestamp now = TimeHelper::GetSysCurrentTime();
+    std::vector<VBucket> extend;
+    for (int64_t i = 0; i < count; ++i) {
+        VBucket log;
+        log.insert_or_assign(CloudDbConstant::CREATE_FIELD, (int64_t)now / CloudDbConstant::TEN_THOUSAND + i);
+        log.insert_or_assign(CloudDbConstant::MODIFY_FIELD, (int64_t)now / CloudDbConstant::TEN_THOUSAND + i);
+        log.insert_or_assign(CloudDbConstant::GID_FIELD, std::to_string(beginGid + i));
+        extend.push_back(log);
+    }
+    ASSERT_EQ(g_virtualCloudDb->BatchDelete(tableName, extend), DBStatus::OK);
+    std::this_thread::sleep_for(std::chrono::milliseconds(count));
+}
+
 CloudSyncOption PrepareOption(const Query &query, LockAction action, bool isPriorityTask = false,
     bool isCompensatedSyncOnly = false)
 {
@@ -353,6 +374,74 @@ void DistributedDBCloudSyncerLockTest::TestConflictSync001(bool isUpdate)
         reinterpret_cast<void *>(1), nullptr), SQLITE_OK);
 }
 
+void DistributedDBCloudSyncerLockTest::CheckAssetStatusNormal()
+{
+    std::string sql = "SELECT asset, assets FROM " + ASSETS_TABLE_NAME + ";";
+    sqlite3_stmt *stmt = nullptr;
+    ASSERT_EQ(SQLiteUtils::GetStatement(db, sql, stmt), E_OK);
+    while (SQLiteUtils::StepWithRetry(stmt) != SQLiteUtils::MapSQLiteErrno(SQLITE_DONE)) {
+        ASSERT_EQ(sqlite3_column_type(stmt, 0), SQLITE_BLOB);
+        ASSERT_EQ(sqlite3_column_type(stmt, 1), SQLITE_BLOB);
+        Type assetBlob;
+        ASSERT_EQ(SQLiteRelationalUtils::GetCloudValueByType(stmt, TYPE_INDEX<Asset>, 0, assetBlob), E_OK);
+        Asset asset = g_virtualCloudDataTranslate->BlobToAsset(std::get<Bytes>(assetBlob));
+        EXPECT_EQ(asset.status, static_cast<uint32_t>(AssetStatus::NORMAL));
+        Type assetsBlob;
+        ASSERT_EQ(SQLiteRelationalUtils::GetCloudValueByType(stmt, TYPE_INDEX<Assets>, 0, assetsBlob), E_OK);
+        Assets assets = g_virtualCloudDataTranslate->BlobToAssets(std::get<Bytes>(assetsBlob));
+        for (const auto &as : assets) {
+            EXPECT_EQ(as.status, static_cast<uint32_t>(AssetStatus::NORMAL));
+        }
+    }
+    int errCode = E_OK;
+    SQLiteUtils::ResetStatement(stmt, true, errCode);
+}
+
+void DistributedDBCloudSyncerLockTest::UpdateCloudAssets(Asset &asset, Assets &assets, const std::string &version)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    VBucket data;
+    std::vector<VBucket> record;
+    std::vector<VBucket> extend;
+    asset.name.empty() ? data.insert_or_assign(COL_ASSET, Nil()) : data.insert_or_assign(COL_ASSET, asset);
+    data.insert_or_assign(COL_ID, 0L);
+    data.insert_or_assign(COL_NAME, "name" + std::to_string(g_nameId++));
+    assets.empty() ? data.insert_or_assign(COL_ASSETS, Nil()) : data.insert_or_assign(COL_ASSETS, assets);
+    record.push_back(data);
+    VBucket log;
+    Timestamp now = TimeHelper::GetSysCurrentTime();
+    log.insert_or_assign(CloudDbConstant::CREATE_FIELD, (int64_t)now / CloudDbConstant::TEN_THOUSAND);
+    log.insert_or_assign(CloudDbConstant::MODIFY_FIELD, (int64_t)now / CloudDbConstant::TEN_THOUSAND);
+    log.insert_or_assign(CloudDbConstant::DELETE_FIELD, false);
+    log.insert_or_assign(CloudDbConstant::GID_FIELD, std::to_string(0));
+    log.insert_or_assign(CloudDbConstant::VERSION_FIELD, version);
+    extend.push_back(log);
+    ASSERT_EQ(g_virtualCloudDb->BatchUpdate(ASSETS_TABLE_NAME, std::move(record), extend), DBStatus::OK);
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+}
+
+void DistributedDBCloudSyncerLockTest::CheckUploadAbnormal(OpType opType, int64_t expCnt, bool isCompensated)
+{
+    std::string sql = "SELECT count(*) FROM " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) + " WHERE ";
+    switch (opType) {
+        case OpType::INSERT:
+            sql += isCompensated ? " cloud_gid != '' AND version !='' AND flag&0x10=0" :
+                   " cloud_gid != '' AND version !='' AND flag=flag|0x10";
+            break;
+        case OpType::UPDATE:
+            sql += isCompensated ? " cloud_gid != '' AND version !='' AND flag&0x10=0" :
+                   " cloud_gid == '' AND version =='' AND flag=flag|0x10";
+            break;
+        case OpType::DELETE:
+            sql += " cloud_gid == '' AND version ==''";
+            break;
+        default:
+            break;
+    }
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(expCnt), nullptr), SQLITE_OK);
+}
+
 /**
  * @tc.name: RDBUnlockCloudSync001
  * @tc.desc: Test sync with no lock
@@ -372,6 +461,17 @@ HWTEST_F(DistributedDBCloudSyncerLockTest, RDBUnlockCloudSync001, TestSize.Level
     InsertCloudDBData(0, localCount, 0, ASSETS_TABLE_NAME);
     CloudSyncOption option = PrepareOption(Query::Select().FromTable({ ASSETS_TABLE_NAME }), LockAction::NONE);
     CallSync(option);
+
+    /**
+     * @tc.steps:step2. insert or replace, check version
+     * @tc.expected: step2. return ok.
+     */
+    std::string sql = "INSERT OR REPLACE INTO " + ASSETS_TABLE_NAME + " VALUES('0', 'XX', '', '');";
+    EXPECT_EQ(RelationalTestUtils::ExecSql(db, sql.c_str()), SQLITE_OK);
+    sql = "select count(*) from " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) +
+        " where version != '' and version is not null;";
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(cloudCount), nullptr), SQLITE_OK);
 }
 
 /**
@@ -473,7 +573,7 @@ HWTEST_F(DistributedDBCloudSyncerLockTest, RDBConflictCloudSync004, TestSize.Lev
      */
     g_virtualCloudDb->ForkInsertConflict([](const std::string &tableName, VBucket &extend, VBucket &record,
         std::vector<VirtualCloudDb::CloudData> &cloudDataVec) {
-        for (const auto &[cloudRecord, cloudExtend]: cloudDataVec) {
+        for (auto &[cloudRecord, cloudExtend]: cloudDataVec) {
             int64_t cloudPk;
             CloudStorageUtils::GetValueFromVBucket<int64_t>(COL_ID, record, cloudPk);
             int64_t localPk;
@@ -487,6 +587,7 @@ HWTEST_F(DistributedDBCloudSyncerLockTest, RDBConflictCloudSync004, TestSize.Lev
             CloudStorageUtils::GetValueFromVBucket<std::string>(CloudDbConstant::VERSION_FIELD, cloudExtend,
                 cloudVersion);
             if (localVersion != cloudVersion) {
+                extend[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_VERSION_CONFLICT);
                 return CLOUD_VERSION_CONFLICT;
             }
         }
@@ -616,5 +717,88 @@ HWTEST_F(DistributedDBCloudSyncerLockTest, RecordConflictTest001, TestSize.Level
     }
     g_cloudStoreHook->SetSyncFinishHook(nullptr);
 }
+
+/**
+ * @tc.name: QueryCursorTest003
+ * @tc.desc: Test whether cursor fallback
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: bty
+ */
+HWTEST_F(DistributedDBCloudSyncerLockTest, QueryCursorTest003, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. init cloud data and sync
+     * @tc.expected: step1. return ok.
+     */
+    int cloudCount = 10;
+    InsertCloudDBData(0, cloudCount, 0, ASSETS_TABLE_NAME);
+    CloudSyncOption option = PrepareOption(Query::Select().FromTable({ ASSETS_TABLE_NAME }), LockAction::INSERT);
+    CallSync(option);
+
+    /**
+     * @tc.steps:step2. delete cloud data and sync
+     * @tc.expected: step2. return ok.
+     */
+    DeleteCloudDBData(0, cloudCount, ASSETS_TABLE_NAME);
+    CallSync(option);
+
+    /**
+     * @tc.steps:step3. remove data
+     * @tc.expected: step3. return ok.
+     */
+    std::string device = "";
+    ASSERT_EQ(g_delegate->RemoveDeviceData(device, DistributedDB::FLAG_ONLY), DBStatus::OK);
+
+    /**
+     * @tc.steps:step4. insert local and check cursor
+     * @tc.expected: step4. return ok.
+     */
+    InsertLocalData(0, 1, ASSETS_TABLE_NAME, true);
+    std::string sql = "select count(*) from " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) +
+        " where cursor='31';";
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(1), nullptr), SQLITE_OK);
+}
+
+/**
+ * @tc.name: QueryCursorTest004
+ * @tc.desc: Test temp trigger under concurrency
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: bty
+ */
+HWTEST_F(DistributedDBCloudSyncerLockTest, QueryCursorTest004, TestSize.Level0)
+{
+    /**
+     * @tc.steps:step1. init cloud data
+     * @tc.expected: step1. return ok.
+     */
+    int cloudCount = 10;
+    InsertLocalData(0, cloudCount, ASSETS_TABLE_NAME, true);
+    InsertCloudDBData(0, cloudCount, 0, ASSETS_TABLE_NAME);
+
+    /**
+     * @tc.steps:step2. set tracker table before saving cloud data
+     * @tc.expected: step2. return ok.
+     */
+    g_virtualCloudDb->ForkQuery([](const std::string &table, VBucket &) {
+        TrackerSchema schema = {
+            .tableName = ASSETS_TABLE_NAME, .extendColName = COL_NAME, .trackerColNames = { COL_ID }
+        };
+        EXPECT_EQ(g_delegate->SetTrackerTable(schema), WITH_INVENTORY_DATA);
+    });
+    CloudSyncOption option = PrepareOption(Query::Select().FromTable({ ASSETS_TABLE_NAME }), LockAction::INSERT);
+    CallSync(option);
+
+    /**
+     * @tc.steps:step3. check extend_field and cursor
+     * @tc.expected: step3. return ok.
+     */
+    std::string sql = "select count(*) from " + DBCommon::GetLogTableName(ASSETS_TABLE_NAME) +
+        " where data_key='0' and extend_field='name10' and cursor='31';";
+    EXPECT_EQ(sqlite3_exec(db, sql.c_str(), CloudDBSyncUtilsTest::QueryCountCallback,
+        reinterpret_cast<void *>(1), nullptr), SQLITE_OK);
+}
 } // namespace
 #endif // RELATIONAL_STORE
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_upload_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_upload_test.cpp
index 208ce2df372034754c6d17a94c16625f627d131a..2517e93e6d3bed132b8981481670d084d7e5aacf 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_upload_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/distributeddb_cloud_syncer_upload_test.cpp
@@ -70,6 +70,7 @@ protected:
     void PrepareUploadDataUpdData(const VBucket &tmp, const VBucket &assets, CloudSyncData &uploadData);
     void PrepareUploadDataForUploadModeCheck012(CloudSyncData &uploadData);
     void PrepareCloudDBMockCheck(MockICloudDB &idb);
+    void CheckUploadFinish(TestCloudSyncer &cloudSyncer);
 };
 
 void DistributedDBCloudSyncerUploadTest::SetUpTestCase(void)
@@ -93,6 +94,7 @@ void DistributedDBCloudSyncerUploadTest::PrepareRecord(VBucket &tmp, VBucket &as
 {
     tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
                     pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1),
+                    pair<std::string, std::string>(CloudDbConstant::GID_FIELD, "0"),
                     pair<std::string, Asset>(CloudDbConstant::ASSET, ASSET_COPY) };
     assets = { pair<std::string, Asset>(CloudDbConstant::ASSET, ASSET_COPY) };
 }
@@ -138,6 +140,13 @@ void DistributedDBCloudSyncerUploadTest::PrepareCloudDBMockCheck(MockICloudDB &i
     EXPECT_CALL(idb, HeartBeat()).WillRepeatedly(Return(OK));
 }
 
+void DistributedDBCloudSyncerUploadTest::CheckUploadFinish(TestCloudSyncer &cloudSyncer)
+{
+    auto recorder = cloudSyncer.GetProcessRecorder();
+    ASSERT_NE(recorder, nullptr);
+    EXPECT_TRUE(recorder->IsUploadFinish(0, cloudSyncer.GetCurrentContextTableName()));
+}
+
 /**
  * @tc.name: UploadModeCheck001
  * @tc.desc: Test different strategies of sync task call DoUpload()
@@ -806,9 +815,10 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck012, TestSize.Level1
         cloudSyncer->CallRecordWaterMark(6u, 1u); // task id is 6
         return E_OK;
     });
-    int errCode = cloudSyncer->CallDoUpload(6u); // task id is 6
+    int errCode = cloudSyncer->CallDoUploadInNeed();
     std::this_thread::sleep_for(std::chrono::seconds(1));
     EXPECT_EQ(errCode, E_OK);
+    CheckUploadFinish(*cloudSyncer);
     uint64_t waterMark = 0u;
     cloudSyncer->CallReloadWaterMarkIfNeed(6u, waterMark); // taskId is 6
     EXPECT_EQ(waterMark, 0u);
@@ -865,10 +875,14 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck014, TestSize.Level1
             extend = uploadData2.insData.extend;
             return OK;
     });
+    EXPECT_CALL(*idb2, BatchUpdate(_, _, _)).WillOnce(Return(DBStatus::OK));
     EXPECT_CALL(*idb2, BatchInsert(_, _, _)).WillOnce([&uploadData2](const std::string &,
         std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
             record = uploadData2.updData.record;
             extend = uploadData2.updData.extend;
+            for (auto &item : extend) {
+                item[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_ERROR);
+            }
             return DB_ERROR;
     });
     int errCode = cloudSyncer2->CallDoUpload(taskId);
@@ -886,6 +900,42 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck014, TestSize.Level1
     idb2 = nullptr;
 }
 
+void SetFuncs015(MockICloudSyncStorageInterface *iCloud, std::shared_ptr<MockICloudDB> &idb,
+    CloudSyncData &uploadData)
+{
+    EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _, _))
+        .WillRepeatedly([&uploadData](const TableSchema &, const QuerySyncObject &, const Timestamp &, ContinueToken &,
+        CloudSyncData &cloudDataResult) {
+            cloudDataResult = uploadData;
+            return E_OK;
+        });
+    EXPECT_CALL(*iCloud, GetAllUploadCount(_, _, _, _, _))
+        .WillOnce([](const QuerySyncObject &, const std::vector<Timestamp> &, bool, bool, int64_t & count) {
+            count = 3000; // 3000 is the upload count
+            return E_OK;
+        });
+    EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly([&uploadData](const std::string &,
+        std::vector<VBucket> &extend) {
+            extend = uploadData.insData.extend;
+            for (auto &item : extend) {
+                item[CloudDbConstant::ERROR_FIELD] = static_cast<int64_t>(DBStatus::CLOUD_ERROR);
+            }
+        return DB_ERROR;
+    });
+    EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
+        std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
+            record = uploadData.updData.record;
+            extend = uploadData.updData.extend;
+            return OK;
+    });
+    EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
+        std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
+            record = uploadData.updData.record;
+            extend = uploadData.delData.extend;
+            return OK;
+    });
+}
+
 /**
  * @tc.name: UploadModeCheck015
  * @tc.desc: Test case3 about upload when batch api are partially successful.
@@ -908,34 +958,7 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck015, TestSize.Level1
     cloudSyncer3->InitCloudSyncer(9u, SYNC_MODE_CLOUD_FORCE_PUSH);
     CloudSyncData uploadData3(cloudSyncer3->GetCurrentContextTableName());
     cloudSyncer3->initFullCloudSyncData(uploadData3, 1000);
-    EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _, _))
-        .WillRepeatedly([&uploadData3](const TableSchema &, const QuerySyncObject &, const Timestamp &, ContinueToken &,
-        CloudSyncData &cloudDataResult) {
-        cloudDataResult = uploadData3;
-        return E_OK;
-    });
-    EXPECT_CALL(*iCloud, GetAllUploadCount(_, _, _, _, _))
-        .WillOnce([](const QuerySyncObject &, const std::vector<Timestamp> &, bool, bool, int64_t & count) {
-        count = 3000;
-        return E_OK;
-    });
-    EXPECT_CALL(*idb3, BatchDelete(_, _)).WillRepeatedly([&uploadData3](const std::string &,
-        std::vector<VBucket> &extend) {
-            extend = uploadData3.insData.extend;
-            return DB_ERROR;
-    });
-    EXPECT_CALL(*idb3, BatchInsert(_, _, _)).WillRepeatedly([&uploadData3](const std::string &,
-        std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
-            record = uploadData3.updData.record;
-            extend = uploadData3.updData.extend;
-            return OK;
-    });
-    EXPECT_CALL(*idb3, BatchUpdate(_, _, _)).WillRepeatedly([&uploadData3](const std::string &,
-        std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
-            record = uploadData3.updData.record;
-            extend = uploadData3.delData.extend;
-            return OK;
-    });
+    SetFuncs015(iCloud, idb3, uploadData3);
     EXPECT_EQ(cloudSyncer3->CallDoUpload(9u), -E_CLOUD_ERROR);
     cloudSyncer3->CallNotify();
 
@@ -950,27 +973,6 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck015, TestSize.Level1
     idb3 = nullptr;
 }
 
-static void ExpectCallForTestCase016(std::shared_ptr<MockICloudDB> idb, CloudSyncData &uploadData)
-{
-    EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
-        std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
-            record = uploadData.insData.record;
-            extend = uploadData.insData.extend;
-            return OK;
-    });
-    EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
-    std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
-            record = uploadData.updData.record;
-            extend = uploadData.updData.extend;
-            return OK;
-    });
-    EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly([&uploadData](const std::string &,
-        std::vector<VBucket> &extend) {
-        extend = uploadData.delData.extend;
-        return OK;
-    });
-}
-
 void MockCall(MockICloudSyncStorageInterface *iCloud, const std::shared_ptr<MockICloudDB> &idb)
 {
     EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
@@ -1050,4 +1052,4 @@ HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck018, TestSize.Level1
     delete iCloud;
     idb = nullptr;
 }
-}
\ No newline at end of file
+}
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp
index 10e656a16dc417c08c05bc4fd580cb542633d9fb..ecbb6e26448148b36fb05d30a7bf8174b654a912 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.cpp
@@ -46,6 +46,22 @@ DBStatus VirtualAssetLoader::RemoveLocalAssets(const std::vector<Asset> &assets)
     return DBStatus::OK;
 }
 
+DBStatus VirtualAssetLoader::RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix,
+    std::map<std::string, Assets> &assets)
+{
+    if (removeLocalAssetsCallBack_) {
+        removeLocalAssetsCallBack_(assets);
+    }
+    LOGD("RemoveLocalAssets GID:%s", gid.c_str());
+    for (auto &item: assets) {
+        for (auto &asset: item.second) {
+            LOGD("asset [name]:%s, [status]:%u, [flag]:%u", asset.name.c_str(), asset.status, asset.flag);
+            asset.status = static_cast<uint32_t>(AssetStatus::NORMAL);
+        }
+    }
+    return DBStatus::OK;
+}
+
 void VirtualAssetLoader::SetDownloadStatus(DBStatus status)
 {
     std::lock_guard<std::mutex> autoLock(dataMutex_);
@@ -62,4 +78,9 @@ void VirtualAssetLoader::ForkRemoveLocalAssets(const RemoveAssetsCallBack &callb
 {
     removeAssetsCallBack_ = callback;
 }
+
+void VirtualAssetLoader::SetRemoveLocalAssetsCallback(const RemoveLocalAssetsCallBack &callback)
+{
+    removeLocalAssetsCallBack_ = callback;
+}
 }
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h
index 1dbd8d89a0ac7f36f8470ea5e4bc50fc2e6e803b..a94bbe54fb91f5e51e3071002140920881767543 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_asset_loader.h
@@ -16,11 +16,12 @@
 #ifndef VIRTUAL_ASSETLOADER_H
 #define VIRTUAL_ASSETLOADER_H
 #include <mutex>
-#include "cloud/iAssetLoader.h"
+#include "iAssetLoader.h"
 
 namespace DistributedDB {
 using DownloadCallBack = std::function<void (std::map<std::string, Assets> &assets)>;
 using RemoveAssetsCallBack = std::function<DBStatus (const std::vector<Asset> &assets)>;
+using RemoveLocalAssetsCallBack = std::function<void (std::map<std::string, Assets> &assets)>;
 class VirtualAssetLoader : public IAssetLoader {
 public:
     VirtualAssetLoader() = default;
@@ -31,16 +32,22 @@ public:
 
     DBStatus RemoveLocalAssets(const std::vector<Asset> &assets) override;
 
+    DBStatus RemoveLocalAssets(const std::string &tableName, const std::string &gid, const Type &prefix,
+             std::map<std::string, Assets> &assets) override;
+
     void SetDownloadStatus(DBStatus status);
 
     void ForkDownload(const DownloadCallBack &callback);
 
     void ForkRemoveLocalAssets(const RemoveAssetsCallBack &callback);
+
+    void SetRemoveLocalAssetsCallback(const RemoveLocalAssetsCallBack &callback);
 private:
     std::mutex dataMutex_;
     DBStatus downloadStatus_ = OK;
     DownloadCallBack downloadCallBack_;
     RemoveAssetsCallBack removeAssetsCallBack_;
+    RemoveLocalAssetsCallBack removeLocalAssetsCallBack_;
 };
 }
 #endif // VIRTUAL_ASSETLOADER_H
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp
index ed270fdadad4fd17d238d24923d50439921bd02e..030d27e47d9365a47e50704f716620b11b85a251 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/cloud/virtual_cloud_db.cpp
@@ -50,9 +50,7 @@ DBStatus VirtualCloudDb::BatchInsert(const std::string &tableName, std::vector<V
         return status;
     }
     if (missingExtendCount_ > 0) {
-        if (!extend.empty()) {
-            extend.pop_back();
-        }
+        extend.erase(extend.end());
     } else if (missingExtendCount_ < 0) {
         VBucket vBucket;
         extend.push_back(vBucket);
@@ -142,9 +140,7 @@ DBStatus VirtualCloudDb::BatchInsertWithGid(const std::string &tableName, std::v
         cloudData_[tableName].push_back(cloudData);
     }
     if (missingExtendCount_ > 0) {
-        if (!extend.empty()) {
-            extend.pop_back();
-        }
+        extend.erase(extend.end());
     } else if (missingExtendCount_ < 0) {
         VBucket vBucket;
         extend.push_back(vBucket);
@@ -207,6 +203,9 @@ DBStatus VirtualCloudDb::HeartBeat()
 
 std::pair<DBStatus, uint32_t> VirtualCloudDb::Lock()
 {
+    if (lockStatus_) {
+        return { CLOUD_LOCK_ERROR, DBConstant::MIN_TIMEOUT };
+    }
     lockCount_++;
     if (actionStatus_ != OK) {
         return { actionStatus_, DBConstant::MIN_TIMEOUT };
@@ -416,9 +415,7 @@ DBStatus VirtualCloudDb::InnerUpdate(const std::string &tableName, std::vector<V
         return res;
     }
     if (missingExtendCount_ > 0) {
-        if (!extend.empty()) {
-            extend.pop_back();
-        }
+        extend.erase(extend.end());
     } else if (missingExtendCount_ < 0) {
         VBucket vBucket;
         extend.push_back(vBucket);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_ability_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_ability_sync_test.cpp
index da450eeb2c11e7ac85161ea038f25bd84aaf1de9..7cc95252983355534a628d1d22ef687679cb50ce 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_ability_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_ability_sync_test.cpp
@@ -534,7 +534,7 @@ HWTEST_F(DistributedDBAbilitySyncTest, AckReceiveTest001, TestSize.Level0)
      * @tc.expected: step5. AckRecv return ok GetRemoteSoftwareVersion is SOFTWARE_VERSION_CURRENT
      *     IsSchemaCompatible true;
      */
-    EXPECT_EQ(async.AckRecv(&msg1, context), OK);
+    EXPECT_EQ(async.AckRecv(&msg1, context), E_OK);
     EXPECT_TRUE(context->GetRemoteSoftwareVersion() == SOFTWARE_VERSION_CURRENT);
     EXPECT_TRUE(context->GetTaskErrCode() != -E_SCHEMA_MISMATCH);
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
index e5337b489c05352bf9071277228fd5c5b9c6451a..3b34d887b2b9a888738c162ffc068e2252d12b15 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_mock_sync_module_test.cpp
@@ -1189,7 +1189,7 @@ HWTEST_F(DistributedDBMockSyncModuleTest, MessageScheduleTest001, TestSize.Level
 HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest001, TestSize.Level1)
 {
     std::unique_ptr<MockSyncEngine> enginePtr = std::make_unique<MockSyncEngine>();
-    EXPECT_CALL(*enginePtr, CreateSyncTaskContext())
+    EXPECT_CALL(*enginePtr, CreateSyncTaskContext(_))
         .WillRepeatedly(Return(new (std::nothrow) SingleVerKvSyncTaskContext()));
     VirtualCommunicatorAggregator *virtualCommunicatorAggregator = new VirtualCommunicatorAggregator();
     MockKvSyncInterface syncDBInterface;
@@ -1248,8 +1248,8 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest002, TestSize.Level1)
      */
     auto *enginePtr = new (std::nothrow) MockSyncEngine();
     ASSERT_NE(enginePtr, nullptr);
-    EXPECT_CALL(*enginePtr, CreateSyncTaskContext())
-        .WillRepeatedly([]() {
+    EXPECT_CALL(*enginePtr, CreateSyncTaskContext(_))
+        .WillRepeatedly([](const ISyncInterface &) {
             return new (std::nothrow) SingleVerKvSyncTaskContext();
         });
     VirtualCommunicatorAggregator *virtualCommunicatorAggregator = new VirtualCommunicatorAggregator();
@@ -1324,6 +1324,24 @@ HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest003, TestSize.Level1)
     RefObject::KillAndDecObjRef(enginePtr);
 }
 
+/**
+ * @tc.name: SyncEngineTest004
+ * @tc.desc: Test SyncEngine alloc failed with null storage.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhangqiquan
+ */
+HWTEST_F(DistributedDBMockSyncModuleTest, SyncEngineTest004, TestSize.Level0)
+{
+    auto *enginePtr = new (std::nothrow) MockSyncEngine();
+    ASSERT_NE(enginePtr, nullptr);
+    int errCode = E_OK;
+    auto *context = enginePtr->CallGetSyncTaskContext("dev", errCode);
+    EXPECT_EQ(context, nullptr);
+    EXPECT_EQ(errCode, -E_INVALID_DB);
+    RefObject::KillAndDecObjRef(enginePtr);
+}
+
 /**
 * @tc.name: remote query packet 001
 * @tc.desc: Test RemoteExecutorRequestPacket Serialization And DeSerialization
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_multi_user_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_multi_user_test.cpp
index e94692e4f8f90ad5baf8180845ce2948409aaaff..01701a653a56a7dbf5f23f3f1c6c64a1071d76ed 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_multi_user_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_multi_user_test.cpp
@@ -1146,7 +1146,7 @@ HWTEST_F(DistributedDBRelationalMultiUserTest, RDBSyncOpt003, TestSize.Level0)
      */
     Query query = Query::Select(g_tableName);
     SyncStatusCallback callback = nullptr;
-    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), OK);
+    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), E_OK);
     EXPECT_EQ(messageCount, 2); // 2 contain time sync request packet and ability sync packet
     /**
      * @tc.steps: step4. create distributed table and sync again
@@ -1154,7 +1154,7 @@ HWTEST_F(DistributedDBRelationalMultiUserTest, RDBSyncOpt003, TestSize.Level0)
      */
     PrepareEnvironment("table2", g_storePath1, g_rdbDelegatePtr1);
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), OK);
+    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), E_OK);
     EXPECT_EQ(messageCount, 1);
     CloseStore();
     OS::RemoveFile(g_storePath1);
@@ -1230,7 +1230,7 @@ HWTEST_F(DistributedDBRelationalMultiUserTest, RDBSyncOpt005, TestSize.Level0)
      */
     Query query = Query::Select(g_tableName);
     SyncStatusCallback callback = nullptr;
-    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), OK);
+    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), E_OK);
     EXPECT_EQ(messageCount, 2); // 2 contain time sync request packet and ability sync packet
     /**
      * @tc.steps: step4. notify time change and sync again
@@ -1240,7 +1240,7 @@ HWTEST_F(DistributedDBRelationalMultiUserTest, RDBSyncOpt005, TestSize.Level0)
     RuntimeContext::GetInstance()->RecordAllTimeChange();
     RuntimeContext::GetInstance()->ClearAllDeviceTimeInfo();
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), OK);
+    EXPECT_EQ(g_deviceB->GenericVirtualDevice::Sync(SYNC_MODE_PUSH_ONLY, query, true), E_OK);
     EXPECT_EQ(messageCount, 1);
     CloseStore();
     OS::RemoveFile(g_storePath1);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
index e7e1a4b4f329b8e035a9ae84238347b1641a0c89..63a08c38d0e77001ea31f3d083fb7650e3fd317a 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_relational_ver_p2p_sync_test.cpp
@@ -903,7 +903,7 @@ void DistributedDBRelationalVerP2PSyncTest::TearDown(void)
     }
     PermissionCheckCallbackV2 nullCallback;
     EXPECT_EQ(RuntimeConfig::SetPermissionCheckCallback(nullCallback), OK);
-    EXPECT_EQ(DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir), OK);
+    EXPECT_EQ(DistributedDBToolsUnitTest::RemoveTestDbFiles(g_testDir), E_OK);
     if (g_communicatorAggregator != nullptr) {
         g_communicatorAggregator->RegOnDispatch(nullptr);
     }
@@ -911,6 +911,15 @@ void DistributedDBRelationalVerP2PSyncTest::TearDown(void)
     LOGD("TearDown FINISH");
 }
 
+void WaitCallCount(RelationalStoreObserverUnitTest *observer1)
+{
+    int reTry = 5;
+    while (observer1->GetCallCount() != 1u && reTry > 0) {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        reTry--;
+    }
+}
+
 /**
 * @tc.name: Normal Sync 001
 * @tc.desc: Test normal push sync for add data.
@@ -2032,6 +2041,7 @@ HWTEST_F(DistributedDBRelationalVerP2PSyncTest, Observer008, TestSize.Level3)
      * @tc.steps: step6. Call sync expect sync successful and device A check observer
      */
     EXPECT_EQ(autoObserver->GetCallCount(), 1u);
+    WaitCallCount(observer1);
     EXPECT_EQ(observer1->GetCallCount(), 1u);
     EXPECT_EQ(autoObserver->GetDataChangeDevice(), DEVICE_B);
     CheckIdentify(autoObserver);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
index 6ceb49ef947e24797c0afead0a83a6b53e8e95b1..173c6bb9c59bd7f68032d9d5e13be945b09ea62b 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_multi_user_test.cpp
@@ -552,12 +552,12 @@ HWTEST_F(DistributedDBSingleVerMultiUserTest, MultiUser004, TestSize.Level0)
     Value value = {'1'};
     Timestamp currentTime;
     (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
-    EXPECT_TRUE(g_deviceB->PutData(key, value, currentTime, 0) == OK);
+    EXPECT_TRUE(g_deviceB->PutData(key, value, currentTime, 0) == E_OK);
     /**
      * @tc.steps: step6. device B push sync to A
      * @tc.expected: step6. success.
      */
-    EXPECT_TRUE(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true) == OK);
+    EXPECT_TRUE(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true) == E_OK);
     std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_TIME));
     EXPECT_TRUE(observer->GetCallCount() == 1); // only A
     /**
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_permission_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_permission_sync_test.cpp
index d9810710cabca4d728086956f22ce31d267d9a20..2068e73e0ab705fc869817b241e10fe4433c5609 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_permission_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_permission_sync_test.cpp
@@ -815,7 +815,7 @@ HWTEST_F(DistributedDBSingleVerP2PPermissionSyncTest, PermissionCheck010, TestSi
      * @tc.expected: step4. get return OK.
      */
     VirtualDataItem actualValue;
-    EXPECT_EQ(g_deviceB->GetData(k1, actualValue), OK);
+    EXPECT_EQ(g_deviceB->GetData(k1, actualValue), E_OK);
     EXPECT_EQ(v1, actualValue.value);
     PermissionCheckCallbackV2 nullCallback = nullptr;
     EXPECT_EQ(g_mgr.SetPermissionCheckCallback(nullCallback), OK);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_simple_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_simple_sync_test.cpp
index b521762cb130892670e13d280996a9f2823eac40..2e4f73bdff734cf118e77c8fc1cb9a433b94b08d 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_simple_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_simple_sync_test.cpp
@@ -1077,10 +1077,10 @@ HWTEST_F(DistributedDBSingleVerP2PSimpleSyncTest, BlockSync001, TestSize.Level1)
         EXPECT_TRUE(pair.second == OK);
     }
     VirtualDataItem item1;
-    EXPECT_EQ(g_deviceB->GetData(KEY_1, item1), OK);
+    EXPECT_EQ(g_deviceB->GetData(KEY_1, item1), E_OK);
     EXPECT_EQ(item1.value, VALUE_1);
     VirtualDataItem item2;
-    EXPECT_EQ(g_deviceC->GetData(KEY_1, item2), OK);
+    EXPECT_EQ(g_deviceC->GetData(KEY_1, item2), E_OK);
     EXPECT_EQ(item2.value, VALUE_1);
 }
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
index c23af4efa979142ff0bdda891100fbf098d12f83..c1d575e67a4c1579a047b30b07f080353380933a 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_subscribe_sync_test.cpp
@@ -202,6 +202,7 @@ void DistributedDBSingleVerP2PSubscribeSyncTest::WaitUntilNotify(KvVirtualDevice
         LOGI("End wait notify");
     }
     virtualDevice.SetPushNotifier(nullptr);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
 }
 
 void InitSubSchemaDb()
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
index 5b82c09d2a580fac071664f9b92a69c53b6fb599..a1d388779b84e07faf34273b2e6d032fd2d32f22 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/distributeddb_single_ver_p2p_sync_check_test.cpp
@@ -18,6 +18,7 @@
 #include "ability_sync.h"
 #include "distributeddb_data_generate_unit_test.h"
 #include "distributeddb_tools_unit_test.h"
+#include "kv_store_nb_delegate_impl.h"
 #include "kv_virtual_device.h"
 #include "platform_specific.h"
 #include "process_system_api_adapter_impl.h"
@@ -71,6 +72,8 @@ public:
     static void TearDownTestCase(void);
     void SetUp();
     void TearDown();
+    void CancelTestInit(DeviceSyncOption &option, std::vector<Entry> &entries, const uint32_t mtuSize);
+    void CancelTestEnd(std::vector<Entry> &entries, const uint32_t mtuSize);
 };
 
 void DistributedDBSingleVerP2PSyncCheckTest::SetUpTestCase(void)
@@ -512,6 +515,194 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, SecOptionCheck008, TestSize.Lev
     g_syncInterfaceB->SetCompressSync(false);
 }
 
+/**
+ * @tc.name: SyncProcess001
+ * @tc.desc: sync process pull mode.
+ * @tc.type: FUNC
+ * @tc.require: AR.SR.IR-20075207.007.001
+ * @tc.author: chenghuitao
+ */
+HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, SyncProcess001, TestSize.Level1)
+{
+    std::vector<std::string> devices;
+    devices.push_back(g_deviceB->GetDeviceId());
+    devices.push_back(g_deviceC->GetDeviceId());
+
+    /**
+     * @tc.steps: step1. deviceB deviceC put bigData
+     */
+    std::vector<Entry> entries;
+    const uint32_t dataCount = 10;
+    DistributedDBUnitTest::GenerateNumberEntryVector(dataCount, entries);
+
+    for (uint32_t i = 0; i < entries.size(); i++) {
+        if (i % 2 == 0) {
+            g_deviceB->PutData(entries[i].key, entries[i].value, 0, 0);
+        } else {
+            g_deviceC->PutData(entries[i].key, entries[i].value, 0, 0);
+        }
+    }
+
+    /**
+     * @tc.steps: step2. deviceA call pull sync
+     * @tc.expected: step2. sync should return OK.
+     */
+    std::map<std::string, DeviceSyncProcess> syncProcessMap;
+    DeviceSyncOption option;
+    option.devices = devices;
+    option.mode = SYNC_MODE_PULL_ONLY;
+    option.isQuery = false;
+    option.isWait = false;
+    DBStatus status = g_tool.SyncTest(g_kvDelegatePtr, option, syncProcessMap);
+    EXPECT_EQ(status, DBStatus::OK);
+
+    /**
+     * @tc.expected: step3. onProcess should be called, DeviceA have all bigData
+     */
+    for (const auto &entry : entries) {
+        Value value;
+        EXPECT_EQ(g_kvDelegatePtr->Get(entry.key, value), DBStatus::OK);
+        EXPECT_EQ(value, entry.value);
+    }
+
+    for (const auto &entry : syncProcessMap) {
+        LOGD("[SyncProcess001] dev %s, status %d, totalCount %u, finishedCount %u", entry.first.c_str(),
+            entry.second.errCode, entry.second.pullInfo.total, entry.second.pullInfo.finishedCount);
+        EXPECT_EQ(entry.second.errCode, OK);
+        EXPECT_EQ(entry.second.process, ProcessStatus::FINISHED);
+        EXPECT_EQ(entry.second.pullInfo.total, dataCount/2);
+        EXPECT_EQ(entry.second.pullInfo.finishedCount, dataCount/2);
+        ASSERT_TRUE(entry.second.syncId > 0);
+    }
+}
+
+/**
+ * @tc.name: SyncProcess002
+ * @tc.desc: sync process pull mode.
+ * @tc.type: FUNC
+ * @tc.require: AR.SR.IR-20075207.007.001
+ * @tc.author: chenghuitao
+ */
+HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, SyncProcess002, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. deviceA put bigData
+     */
+    std::vector<Entry> entries;
+    const uint32_t dataCount = 10;
+    DistributedDBUnitTest::GenerateNumberEntryVector(dataCount, entries);
+
+    for (uint32_t i = 0; i < entries.size(); i++) {
+        g_kvDelegatePtr->Put(entries[i].key, entries[i].value);
+    }
+
+    /**
+     * @tc.steps: step2. virtual deviceB call pull sync
+     * @tc.expected: step2. sync should return OK.
+     */
+    std::map<std::string, DeviceSyncProcess> syncProcessMap;
+    DeviceSyncOption option;
+    option.mode = SYNC_MODE_PULL_ONLY;
+    option.isQuery = false;
+    option.isWait = true;
+    uint32_t processCount = 0;
+    std::vector<ProcessStatus> statuses = {ProcessStatus::PREPARED, ProcessStatus::PROCESSING, ProcessStatus::FINISHED};
+    DeviceSyncProcessCallback onProcess =
+        [&](const std::map<std::string, DeviceSyncProcess> &processMap) {
+            syncProcessMap = processMap;
+            for (const auto &entry : processMap) {
+                LOGD("[SyncProcess002-onProcess] dev %s, status %d, process %d", entry.first.c_str(),
+                    entry.second.errCode, entry.second.process);
+                EXPECT_EQ(entry.second.errCode, DBStatus::OK);
+                EXPECT_EQ(entry.second.process, statuses[processCount]);
+                // total and finishedCount must be greater than 0 when processing
+                if (entry.second.process == ProcessStatus::PROCESSING) {
+                    EXPECT_TRUE(entry.second.pullInfo.total > 0);
+                    EXPECT_TRUE(entry.second.pullInfo.finishedCount > 0);
+                }
+            }
+            processCount++;
+        };
+    int status = g_deviceB->Sync(option, onProcess);
+    EXPECT_EQ(status, E_OK);
+
+    /**
+     * @tc.expected: step3. onProcess should be called, DeviceB have all bigData
+     */
+    for (const auto &entry : entries) {
+        VirtualDataItem item;
+        EXPECT_EQ(g_deviceB->GetData(entry.key, item), E_OK);
+        EXPECT_EQ(item.value, entry.value);
+    }
+
+    for (const auto &entry : syncProcessMap) {
+        LOGD("[SyncProcess002] dev %s, status %d, totalCount %u, finishedCount %u", entry.first.c_str(),
+            entry.second.errCode, entry.second.pullInfo.total, entry.second.pullInfo.finishedCount);
+        EXPECT_EQ(entry.second.errCode, DBStatus::OK);
+        EXPECT_EQ(entry.second.process, ProcessStatus::FINISHED);
+        EXPECT_EQ(entry.second.pullInfo.total, dataCount);
+        EXPECT_EQ(entry.second.pullInfo.finishedCount, dataCount);
+        ASSERT_TRUE(entry.second.syncId > 0);
+    }
+}
+
+/**
+ * @tc.name: SyncProcess003
+ * @tc.desc: sync process pull mode with QUERY.
+ * @tc.type: FUNC
+ * @tc.require: AR.SR.IR-20075207.007.001
+ * @tc.author: chenghuitao
+ */
+HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, SyncProcess003, TestSize.Level1)
+{
+    /**
+     * @tc.steps: step1. deviceA put bigData
+     */
+    std::vector<Entry> entries;
+    const uint32_t dataCount = 10;
+    DistributedDBUnitTest::GenerateNumberEntryVector(dataCount, entries);
+
+    for (uint32_t i = 0; i < entries.size(); i++) {
+        g_kvDelegatePtr->Put(entries[i].key, entries[i].value);
+    }
+
+    /**
+     * @tc.steps: step2. virtual deviceB call pull sync
+     * @tc.expected: step2. sync should return OK.
+     */
+    std::map<std::string, DeviceSyncProcess> syncProcessMap;
+    DeviceSyncOption option;
+    option.mode = SYNC_MODE_PULL_ONLY;
+    option.isQuery = true;
+    option.isWait = true;
+    option.query = Query::Select().Limit(5);
+    DeviceSyncProcessCallback onProcess =
+        [&syncProcessMap, this](const std::map<std::string, DeviceSyncProcess> &processMap) {
+            syncProcessMap = processMap;
+        };
+    int status = g_deviceB->Sync(option, onProcess);
+    EXPECT_EQ(status, E_OK);
+
+    /**
+     * @tc.expected: step3. onProcess should be called, DeviceB have all bigData
+     */
+    for (const auto &entry : std::vector<Entry>(entries.begin(), entries.begin() + 5)) {
+        VirtualDataItem item;
+        EXPECT_EQ(g_deviceB->GetData(entry.key, item), E_OK);
+        EXPECT_EQ(item.value, entry.value);
+    }
+
+    for (const auto &entry : syncProcessMap) {
+        LOGD("[SyncProcess003] dev %s, status %d, totalCount %u, finishedCount %u", entry.first.c_str(),
+            entry.second.errCode, entry.second.pullInfo.total, entry.second.pullInfo.finishedCount);
+        EXPECT_EQ(entry.second.errCode, DBStatus::OK);
+        EXPECT_EQ(entry.second.process, ProcessStatus::FINISHED);
+        EXPECT_EQ(entry.second.pullInfo.total, 5u);
+        EXPECT_EQ(entry.second.pullInfo.finishedCount, 5u);
+        ASSERT_TRUE(entry.second.syncId > 0);
+    }
+}
+
 #ifndef LOW_LEVEL_MEM_DEV
 /**
  * @tc.name: BigDataSync001
@@ -957,7 +1148,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, AckSessionCheck001, TestSize.Le
     Value value = {'1'};
     Timestamp currentTime;
     (void)OS::GetCurrentSysTimeInMicrosecond(currentTime);
-    EXPECT_TRUE(g_deviceB->PutData(key, value, currentTime, 0) == OK);
+    EXPECT_TRUE(g_deviceB->PutData(key, value, currentTime, 0) == E_OK);
     EXPECT_TRUE(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true) == OK);
 
     Value outValue;
@@ -1724,7 +1915,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, DelaySync001, TestSize.Level3)
     std::this_thread::sleep_for(std::chrono::seconds(1)); // sleep 1s for data conflict
     Timestamp currentTime = TimeHelper::GetSysCurrentTime() + TimeHelper::BASE_OFFSET;
     Value bValue = {'b'};
-    EXPECT_EQ(g_deviceB->PutData(key, bValue, currentTime, 0), OK);
+    EXPECT_EQ(g_deviceB->PutData(key, bValue, currentTime, 0), E_OK);
 
     // delay time sync message, delay time/2 should greater than put sleep time
     g_communicatorAggregator->SetTimeout(DEVICE_B, DBConstant::MAX_TIMEOUT);
@@ -1769,7 +1960,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVAbilitySyncOpt001, TestSize.L
             return;
         }
         messageCount++;
-        EXPECT_EQ(g_kvDelegatePtr->GetTaskCount(), 1);
+        EXPECT_GE(g_kvDelegatePtr->GetTaskCount(), 1);
     });
     /**
      * @tc.steps: step2. deviceA call sync and wait
@@ -1787,6 +1978,31 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVAbilitySyncOpt001, TestSize.L
     }
 }
 
+/**
+ * @tc.name: KVAbilitySyncOpt002
+ * @tc.desc: check get task count while conn is nullptr.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: caihaoting
+ */
+HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVAbilitySyncOpt002, TestSize.Level0)
+{
+    /**
+     * @tc.steps: step1. record packet while conn is nullptr.
+     * @tc.expected: step1. sync should failed in source and get task count return DB_ERROR.
+     */
+    auto kvStoreImpl = static_cast<KvStoreNbDelegateImpl *>(g_kvDelegatePtr);
+    EXPECT_EQ(kvStoreImpl->Close(), OK);
+    std::atomic<int> messageCount = 0;
+    g_communicatorAggregator->RegOnDispatch([&messageCount](const std::string &dev, Message *msg) {
+        if (msg->GetMessageId() != ABILITY_SYNC_MESSAGE) {
+            return;
+        }
+        messageCount++;
+        EXPECT_EQ(g_kvDelegatePtr->GetTaskCount(), DB_ERROR);
+    });
+}
+
 /**
  * @tc.name: KVSyncOpt001
  * @tc.desc: check time sync and ability sync once
@@ -1907,7 +2123,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt003, TestSize.Level0)
      * @tc.expected: step4. reopen OK and sync success, no negotiation packet.
      */
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 0);
     g_communicatorAggregator->RegOnDispatch(nullptr);
 }
@@ -1966,7 +2182,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt005, TestSize.Level0)
      * @tc.steps: step2. deviceB call sync and wait
      * @tc.expected: step2. sync should return OK.
      */
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 2); // DEV_A send negotiation 2 ack packet.
     /**
      * @tc.steps: step3. reopen kv store
@@ -1978,7 +2194,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt005, TestSize.Level0)
      * @tc.expected: step4. reopen OK and sync success, no negotiation packet.
      */
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 0);
     g_communicatorAggregator->RegOnDispatch(nullptr);
 }
@@ -2003,7 +2219,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt006, TestSize.Level0)
      */
     std::vector<std::string> devices;
     devices.push_back(g_deviceB->GetDeviceId());
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 2); // 2 contain time sync request packet and ability sync packet
     /**
      * @tc.steps: step3. rebuild kv store
@@ -2023,7 +2239,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt006, TestSize.Level0)
      * @tc.expected: step4. rebuild OK and sync success, re ability sync.
      */
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 1);
     g_communicatorAggregator->RegOnDispatch(nullptr);
 }
@@ -2046,7 +2262,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt007, TestSize.Level0)
      * @tc.steps: step2. deviceB call sync and wait
      * @tc.expected: step2. sync should return OK.
      */
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 2); // DEV_A send negotiation 2 ack packet.
     /**
      * @tc.steps: step3. export and import
@@ -2061,7 +2277,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVSyncOpt007, TestSize.Level0)
      * @tc.expected: step4. reopen OK and sync success, no negotiation packet.
      */
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 1); // DEV_A send negotiation 1 ack packet.
     g_communicatorAggregator->RegOnDispatch(nullptr);
 }
@@ -2106,7 +2322,7 @@ HWTEST_F(DistributedDBSingleVerP2PSyncCheckTest, KVTimeChange001, TestSize.Level
     Sync(devices, OK);
     EXPECT_EQ(messageCount, 1); // 1 contain time sync request packet
     messageCount = 0;
-    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), OK);
+    EXPECT_EQ(g_deviceB->Sync(SYNC_MODE_PUSH_ONLY, true), E_OK);
     EXPECT_EQ(messageCount, 0);
     g_communicatorAggregator->RegOnDispatch(nullptr);
 }
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
index 4af3404b97062a257390e8fc814bc81ae2dea582..838e21214cd0a4c063defca8bdb6fd0cf16c9239 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.cpp
@@ -218,6 +218,50 @@ TimeOffset GenericVirtualDevice::GetLocalTimeOffset() const
     return metadata_->GetLocalTimeOffset();
 }
 
+void GenericVirtualDevice::OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &processMap,
+    const DeviceSyncProcessCallback &onProcess) const
+{
+    std::map<std::string, DeviceSyncProcess> result;
+    for (const auto &pair : processMap) {
+        DeviceSyncProcess info = pair.second;
+        int status = info.errCode;
+        info.errCode = SyncOperation::DBStatusTrans(status);
+        info.process = SyncOperation::DBStatusTransProcess(status);
+        result.insert(std::pair<std::string, DeviceSyncProcess>(pair.first, info));
+    }
+    if (onProcess) {
+        onProcess(result);
+    }
+}
+
+int GenericVirtualDevice::Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess)
+{
+    auto operation = new (std::nothrow) SyncOperation(1, {remoteDeviceId_}, option.mode, nullptr, option.isWait);
+    if (operation == nullptr) {
+        return -E_OUT_OF_MEMORY;
+    }
+    DeviceSyncProcessCallback onSyncProcess = std::bind(&GenericVirtualDevice::OnDeviceSyncProcess, this,
+        std::placeholders::_1, onProcess);
+    operation->SetSyncProcessCallFun(onSyncProcess);
+    operation->Initialize();
+    operation->SetOnSyncFinished([operation](int id) {
+        operation->NotifyIfNeed();
+    });
+    int errCode = E_OK;
+    if (option.isQuery) {
+        QuerySyncObject querySyncObject(option.query);
+        errCode = querySyncObject.Init();
+        if (errCode != E_OK) {
+            return errCode;
+        }
+        operation->SetQuery(querySyncObject);
+    }
+    errCode = context_->AddSyncOperation(operation);
+    operation->WaitIfNeed();
+    RefObject::KillAndDecObjRef(operation);
+    return errCode;
+}
+
 int GenericVirtualDevice::Sync(SyncMode mode, bool wait)
 {
     auto operation = new (std::nothrow) SyncOperation(1, {remoteDeviceId_}, mode, nullptr, wait);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
index 174b3b1457ea4f67e681ef55bf41402515ceecaa..462dd694848759f92d96c526854e2a3a08b1a209 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/generic_virtual_device.h
@@ -40,6 +40,9 @@ public:
     void Offline();
     int StartResponseTask();
     TimeOffset GetLocalTimeOffset() const;
+    void OnDeviceSyncProcess(const std::map<std::string, DeviceSyncProcess> &processMap,
+        const DeviceSyncProcessCallback &onProcess) const;
+    virtual int Sync(const DeviceSyncOption &option, const DeviceSyncProcessCallback &onProcess);
     virtual int Sync(SyncMode mode, bool wait);
     virtual int Sync(SyncMode mode, const Query &query, bool wait);
     virtual int Sync(SyncMode mode, const Query &query, const SyncOperation::UserCallback &callBack, bool wait);
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
index d1c44fb3dce851743a0a73c59791d21755084246..1545ea636e1005dc977e1c5f075cf3f77a1d4721 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/mock_sync_engine.h
@@ -22,12 +22,17 @@
 namespace DistributedDB {
 class MockSyncEngine : public SyncEngine {
 public:
-    MOCK_METHOD0(CreateSyncTaskContext, ISyncTaskContext *(void));
+    MOCK_METHOD1(CreateSyncTaskContext, ISyncTaskContext *(const ISyncInterface &syncInterface));
 
     void InitSubscribeManager()
     {
         subManager_ = std::make_shared<SubscribeManager>();
     }
+
+    ISyncTaskContext *CallGetSyncTaskContext(const std::string &deviceId, int &errCode)
+    {
+        return SyncEngine::GetSyncTaskContext(deviceId, errCode);
+    }
 };
 } // namespace DistributedDB
 #endif  // #define MOCK_SYNC_ENGINE_H
\ No newline at end of file
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
index c9e9b1a152001052802e337087bb05ef716076e7..7829c53e797fde0914734428836da1300dc27cad 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.cpp
@@ -106,13 +106,7 @@ int VirtualCommunicatorAggregator::GetLocalIdentity(std::string &outTarget) cons
     } else {
         outTarget = localDeviceId_;
     }
-    return E_OK;
-}
-
-void VirtualCommunicatorAggregator::SetLocalDeviceId(const std::string &deviceId)
-{
-    std::lock_guard<std::mutex> lock(localDeviceIdMutex_);
-    localDeviceId_ = deviceId;
+    return getLocalDeviceRet_;
 }
 
 void VirtualCommunicatorAggregator::OnlineDevice(const std::string &deviceId) const
@@ -365,4 +359,16 @@ void VirtualCommunicatorAggregator::RegBeforeDispatch(
 {
     beforeDispatch_ = beforeDispatch;
 }
+
+void VirtualCommunicatorAggregator::SetLocalDeviceId(const std::string &deviceId)
+{
+    std::lock_guard<std::mutex> lock(localDeviceIdMutex_);
+    localDeviceId_ = deviceId;
+}
+
+void VirtualCommunicatorAggregator::MockGetLocalDeviceRes(int mockRes)
+{
+    std::lock_guard<std::mutex> lock(localDeviceIdMutex_);
+    getLocalDeviceRet_ = mockRes;
+}
 } // namespace DistributedDB
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
index 1adc4c96fdb0209f07c4a75f8190739a379669c3..6a1f0479d325447b0e0bca6795a958257b905daf 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_communicator_aggregator.h
@@ -91,6 +91,8 @@ public:
 
     void SetLocalDeviceId(const std::string &deviceId);
 
+    void MockGetLocalDeviceRes(int mockRes);
+
     ~VirtualCommunicatorAggregator() override = default;
     VirtualCommunicatorAggregator() = default;
 
@@ -121,6 +123,7 @@ private:
 
     mutable std::mutex localDeviceIdMutex_;
     std::string localDeviceId_;
+    int getLocalDeviceRet_ = E_OK;
 };
 } // namespace DistributedDB
 
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
index b7dbb11a5abdd3e5f3181f09d9269faa15dabbe6..9dffa54a210bb528a68f578a1f7f4e622db644a2 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.cpp
@@ -341,6 +341,11 @@ int VirtualRelationalVerSyncDBInterface::SaveRemoteDeviceSchema(const std::strin
     return E_OK;
 }
 
+int VirtualRelationalVerSyncDBInterface::GetSchemaFromDB(RelationalSchemaObject &schema)
+{
+    return E_OK;
+};
+
 int VirtualRelationalVerSyncDBInterface::GetRemoteDeviceSchema(const std::string &deviceId,
     RelationalSchemaObject &schemaObj)
 {
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
index 12830ec5d181fcb0fc45cdc70d514a37c00be790..3bf32632d6bd5e0970006824601ca5a44e6416e9 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_relational_ver_sync_db_interface.h
@@ -115,6 +115,8 @@ public:
 
     int GetRemoteDeviceSchema(const std::string &deviceId, RelationalSchemaObject &schemaObj) override;
 
+    int GetSchemaFromDB(RelationalSchemaObject &schema) override;
+
     void SetPermitCreateDistributedTable(bool permitCreateDistributedTable);
 
     int GetSecurityOption(SecurityOption &option) const override;
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
index b3c402a0240973d86634cbd739f899bcb66b79ea..282e0d228ed04b2d1fabefb9ee2d8ab6279855bb 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.cpp
@@ -135,6 +135,57 @@ int VirtualSingleVerSyncDBInterface::GetSyncData(Timestamp begin, Timestamp end,
     return -E_NOT_SUPPORT;
 }
 
+int VirtualSingleVerSyncDBInterface::GetUnSyncTotal(Timestamp begin, Timestamp end, uint32_t &total) const
+{
+    total = 0;
+    for (const auto &data : dbData_) {
+        if (data.isLocal) {
+            if (data.writeTimestamp >= begin && data.writeTimestamp < end) {
+                total++;
+            }
+        }
+    }
+    return E_OK;
+}
+
+int VirtualSingleVerSyncDBInterface::GetUnSyncTotal(QueryObject &query, const SyncTimeRange &timeRange,
+    uint32_t &total) const
+{
+    if (getDataDelayTime_ > 0) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(getDataDelayTime_));
+    }
+    int errCode  = DataControl();
+    if (errCode != E_OK) {
+        return errCode;
+    }
+
+    total = 0;
+    const auto &startKey = query.GetPrefixKey();
+    Key endKey = startKey;
+    endKey.resize(DBConstant::MAX_KEY_SIZE, UCHAR_MAX);
+
+    for (const auto &data : dbData_) {
+        // Only get local data.
+        if (!data.isLocal) {
+            continue;
+        }
+
+        if ((data.flag & VirtualDataItem::DELETE_FLAG) != 0) {
+            if (data.timestamp >= timeRange.deleteBeginTime && data.timestamp < timeRange.deleteEndTime) {
+                total++;
+            }
+        } else {
+            if (data.timestamp >= timeRange.beginTime && data.timestamp < timeRange.endTime &&
+                data.key >= startKey && data.key <= endKey) {
+                    total++;
+            }
+        }
+    }
+
+    LOGD("GetUnSyncTotal %u", total);
+    return E_OK;
+}
+
 int VirtualSingleVerSyncDBInterface::GetSyncDataNext(std::vector<DataItem> &dataItems, ContinueToken &continueStmtToken,
     const DataSizeSpecInfo &dataSizeInfo) const
 {
diff --git a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
index b6e141163d49ce9094ac859cb7bff0af589879ec..415750056f868bf830d89e831003205759ac4ec9 100644
--- a/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
+++ b/kv_store/frameworks/libs/distributeddb/test/unittest/common/syncer/virtual_single_ver_sync_db_Interface.h
@@ -85,6 +85,10 @@ public:
 
     int GetSyncData(QueryObject &query, const SyncTimeRange &timeRange, const DataSizeSpecInfo &dataSizeInfo,
         ContinueToken &continueStmtToken, std::vector<SingleVerKvEntry *> &entries) const override;
+    
+    int GetUnSyncTotal(Timestamp begin, Timestamp end, uint32_t &total) const override;
+
+    int GetUnSyncTotal(QueryObject &query, const SyncTimeRange &timeRange, uint32_t &total) const override;
 
     int GetSyncDataNext(std::vector<SingleVerKvEntry *> &entries, ContinueToken &continueStmtToken,
         const DataSizeSpecInfo &dataSizeInfo) const override;
diff --git a/kv_store/interfaces/innerkits/distributeddata/BUILD.gn b/kv_store/interfaces/innerkits/distributeddata/BUILD.gn
index c9ad7d309457f5f8fb438dd563eaa40a97bee6e2..96917de5c10369b9adeeb833790ce3f86da746c6 100644
--- a/kv_store/interfaces/innerkits/distributeddata/BUILD.gn
+++ b/kv_store/interfaces/innerkits/distributeddata/BUILD.gn
@@ -78,7 +78,6 @@ old_source_config = [
 kvdb_source_config = [
   "../../../frameworks/innerkitsimpl/kvdb/src/backup_manager.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/convertor.cpp",
-  "../../../frameworks/innerkitsimpl/kvdb/src/data_change_notifier.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/dev_manager.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/device_convertor.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/kv_types_util.cpp",
@@ -93,6 +92,7 @@ kvdb_source_config = [
   "../../../frameworks/innerkitsimpl/kvdb/src/system_api.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/task_executor.cpp",
   "../../../frameworks/innerkitsimpl/kvdb/src/task_executor_adapter.cpp",
+  "../../../frameworks/innerkitsimpl/kvdb/src/kv_hiview_reporter.cpp",
 ]
 
 deps_config = [
@@ -103,6 +103,8 @@ deps_config = [
 ]
 
 external_deps_config = [
+  "access_token:libaccesstoken_sdk",
+  "access_token:libtokenid_sdk",
   "c_utils:utils",
   "device_manager:devicemanagersdk",
   "hisysevent:libhisysevent",
@@ -125,12 +127,22 @@ ohos_shared_library("distributeddata_inner") {
     debug = false
   }
   sources = old_source_config + kvdb_source_config
-
+  if (qemu_disable) {
+    sources +=
+        [ "../../../frameworks/innerkitsimpl/kvdb/src/auto_sync_timer.cpp" ]
+  } else {
+    sources += [
+      "../../../frameworks/innerkitsimpl/kvdb/src/auto_sync_timer_mock.cpp",
+    ]
+  }
   configs = [ ":distributeddatafwk_config" ]
   public_configs = [ ":distributeddatafwk_public_config" ]
 
   deps = deps_config
   external_deps = external_deps_config
+  if (dms_service_enable && qemu_disable) {
+    external_deps += [ "dmsfwk:distributed_sdk" ]
+  }
   innerapi_tags = [ "platformsdk" ]
   subsystem_name = "distributeddatamgr"
   part_name = "kv_store"
diff --git a/kv_store/interfaces/innerkits/distributeddata/include/types.h b/kv_store/interfaces/innerkits/distributeddata/include/types.h
index aa7a67166d740e3efa6598d2a98a985fdf47f62d..3a8ace34aa89037052f0b3b1592ff8f749b2354a 100644
--- a/kv_store/interfaces/innerkits/distributeddata/include/types.h
+++ b/kv_store/interfaces/innerkits/distributeddata/include/types.h
@@ -412,6 +412,21 @@ enum DataType : uint32_t {
     TYPE_DYNAMICAL,
 };
 
+/**
+ * @brief Verify data synchronization based on the account type.
+*/
+enum AuthType : uint32_t {
+    /**
+      * DEFAULT: means all types of checks.
+    */
+    DEFAULT = 0,
+
+    /**
+      * IDENTICAL_ACCOUNT_CHECK: means verify the same account type.
+    */
+    IDENTICAL_ACCOUNT
+};
+
 /**
  * @brief Provide configuration information for database creation.
 */
@@ -426,6 +441,11 @@ struct Options {
      * It is not encrypted by default.
     */
     bool encrypt = false;
+    /**
+     * Set whether the rekey takes effect.
+     * It does not take effect by default.
+    */
+    bool autoRekey = false;
     /**
      * Data storage disk by default.
     */
@@ -543,6 +563,10 @@ struct Options {
      * Set cloud config of kv store.
     */
     CloudConfig cloudConfig;
+    /**
+     * Set authType of kv store.
+    */
+    AuthType authType = AuthType::DEFAULT;
 };
 
 /**
diff --git a/kv_store/kv_store.gni b/kv_store/kv_store.gni
index e73872057e662542ddb5be3cc9e252f19882b53d..53071fb36425a284991ce7ec02aab420c7ed1b08 100644
--- a/kv_store/kv_store.gni
+++ b/kv_store/kv_store.gni
@@ -22,3 +22,18 @@ third_party_path = "//third_party"
 use_platform_win = "${current_os}_${current_cpu}" == "mingw_x86_64"
 use_platforn_mac = "${current_os}_${current_cpu}" == "mac_x64" ||
                    "${current_os}_${current_cpu}" == "mac_arm64"
+
+declare_args() {
+  if (!defined(global_parts_info) ||
+      defined(global_parts_info.ability_dmsfwk)) {
+    dms_service_enable = true
+  } else {
+    dms_service_enable = false
+  }
+
+  if (product_name != "qemu-arm-linux-min") {
+    qemu_disable = true
+  } else {
+    qemu_disable = false
+  }
+}
diff --git a/kv_store/test/unittest/distributeddata/KvManagerDataPromiseJsTest.js b/kv_store/test/unittest/distributeddata/KvManagerDataPromiseJsTest.js
index c6b6f23108ccb919f485336a6fd20f2c9e06e7d4..2c9220ec49af5684bbd4c1e7dfa8cbebe9540cdb 100644
--- a/kv_store/test/unittest/distributeddata/KvManagerDataPromiseJsTest.js
+++ b/kv_store/test/unittest/distributeddata/KvManagerDataPromiseJsTest.js
@@ -25,7 +25,6 @@ var kvManager = null;
 var kvStore = null;
 const STORE_KEY = 'key_test_string';
 const STORE_VALUE = 'value-test-string';
-var kvStoreNew = null;
 
 describe('KvManagerPromiseTest', function () {
     const config = {
@@ -51,12 +50,6 @@ describe('KvManagerPromiseTest', function () {
         await factory.createKVManager(config).then((manager) => {
             kvManager = manager;
             console.info('beforeAll createKVManager success');
-            kvManager.getKVStore(TEST_STORE_ID, options).then((store) => {
-                console.info("beforeAll getKVStore success");
-                kvStoreNew = store;
-            }).catch((err) => {
-                console.info("beforeAll getKVStore err: "  + JSON.stringify(err));
-            });
         }).catch((err) => {
             console.error('beforeAll createKVManager err ' + `, error code is ${err.code}, message is ${err.message}`);
         });
@@ -827,56 +820,6 @@ describe('KvManagerPromiseTest', function () {
         done();
     })
 
-    /**
-     * @tc.name: KVStorePutPromiseTest001
-     * @tc.desc: Test Js Api KVManager.Put() testcase 001
-     * @tc.type: FUNC
-     * @tc.require: issueNumber
-     */
-    it('KVStorePutPromiseTest001', 0, async function (done) {
-        console.info('KVStorePutPromiseTest001');
-        try {
-            await kvStoreNew.put(TEST_BUNDLE_NAME, TEST_STORE_ID).then((data) => {
-                if (err != undefined){
-                    console.info('KVStorePutPromiseTest001 put promise fail');
-                } else {
-                    console.info('KVStorePutPromiseTest001 put promise success');
-                    expect(null).assertFail();
-                }
-                done();
-            });
-        } catch (e) {
-            console.error('KVStorePutPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
-            done();
-        }
-    })
-
-    /**
-     * @tc.name: KVStoreDeletePromiseTest001
-     * @tc.desc: Test Js Api KVManager.Delete testcase 001
-     * @tc.type: FUNC
-     * @tc.require: issueNumber
-     */
-    it('KVStoreDeletePromiseTest001', 0, async function (done) {
-        console.info('KVStoreDeletePromiseTest001');
-        try {
-            kvStoreNew.put(STORE_KEY, STORE_VALUE).then((data) => {
-                console.info('KVStoreDeletePromiseTest001 getKVStore success');
-                kvStoreNew.delete(STORE_KEY).then((data) => {
-                    console.info("testKVStoreDelete001  promise delete success");
-                    expect(null).assertFail();
-                }).catch((err) => {
-                    console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
-                });
-            }).catch((err) => {
-                console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
-            });
-        }catch (e) {
-            console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
-        }
-        done();
-    })
-
     /**
      * @tc.name: CreateKVManagerPromiseTest001
      * @tc.desc: Test Js Api createKVManager testcase 001
diff --git a/kv_store/test/unittest/distributeddata/SingleKvStoreDataPromiseJsTest.js b/kv_store/test/unittest/distributeddata/SingleKvStoreDataPromiseJsTest.js
index a064c1b141382c540e5b156836f2338929e5951a..9bb590fda6812441f0279570d3d5d03d6c5fce23 100644
--- a/kv_store/test/unittest/distributeddata/SingleKvStoreDataPromiseJsTest.js
+++ b/kv_store/test/unittest/distributeddata/SingleKvStoreDataPromiseJsTest.js
@@ -2800,4 +2800,54 @@ describe('singleKvStorePromiseTest', function () {
         });
         done();
     })
+
+    /**
+     * @tc.name: KVStorePutPromiseTest001
+     * @tc.desc: Test Js Api KVManager.Put() testcase 001
+     * @tc.type: FUNC
+     * @tc.require: issueNumber
+     */
+    it('KVStorePutPromiseTest001', 0, async function (done) {
+        console.info('KVStorePutPromiseTest001');
+        try {
+            await kvStore.put(TEST_BUNDLE_NAME, TEST_STORE_ID).then((data) => {
+                if (err != undefined){
+                    console.info('KVStorePutPromiseTest001 put promise fail');
+                } else {
+                    console.info('KVStorePutPromiseTest001 put promise success');
+                    expect(null).assertFail();
+                }
+                done();
+            });
+        } catch (e) {
+            console.error('KVStorePutPromiseTest001 e ' + `, error code is ${e.code}, message is ${e.message}`);
+            done();
+        }
+    })
+
+    /**
+     * @tc.name: KVStoreDeletePromiseTest001
+     * @tc.desc: Test Js Api KVManager.Delete testcase 001
+     * @tc.type: FUNC
+     * @tc.require: issueNumber
+     */
+    it('KVStoreDeletePromiseTest001', 0, async function (done) {
+        console.info('KVStoreDeletePromiseTest001');
+        try {
+            kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => {
+                console.info('KVStoreDeletePromiseTest001 getKVStore success');
+                kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => {
+                    console.info("testKVStoreDelete001  promise delete success");
+                    expect(null).assertFail();
+                }).catch((err) => {
+                    console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
+                });
+            }).catch((err) => {
+                console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
+            });
+        }catch (e) {
+            console.error('KVStoreDeletePromiseTest001 promise delete fail err' + `, error code is ${err.code}, message is ${err.message}`);
+        }
+        done();
+    })    
 })
diff --git a/mock/CMakeLists.txt b/mock/CMakeLists.txt
index c2cd98414a4e4057d4e3c013b48377ce9ba030ce..ce20853e0491a326ddb44e14ac7b57aeddcdf0b8 100644
--- a/mock/CMakeLists.txt
+++ b/mock/CMakeLists.txt
@@ -45,6 +45,7 @@ target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/fra
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/frame_aware_sched/frame_ui_intf/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/multimedia_image_standard/image/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/multimedia_image_standard/image_native/include)
+target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/multimedia_image_standard/image_native/ndk/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/input/libmmi-client/include/event/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/input/libmmi-client/include/proxy/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/form_fwk/fmskit_native/include)
@@ -212,6 +213,7 @@ target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/use
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/samgr_standard/lsamgr/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/samgr_standard/samgr_proxy/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/samgr_standard/samgr_common/include)
+target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/screenlock_mgr/interfaces/inner_api/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/power_manager_native/powermgr_client/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/drivers_peripheral_usb/usbd_client/include)
 target_include_directories(mock PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/innerkits/hisysevent_native/libhisyseventmanager/include)
diff --git a/mock/innerkits/ability_base/base/include/int_wrapper.h b/mock/innerkits/ability_base/base/include/int_wrapper.h
index 5960f50d701350165f8c1e39655b6e4eeea1de7a..4f0ce2f3bf1dbeb4e6f8f832b5223a80822cb347 100644
--- a/mock/innerkits/ability_base/base/include/int_wrapper.h
+++ b/mock/innerkits/ability_base/base/include/int_wrapper.h
@@ -36,7 +36,11 @@ public:
 
     std::string ToString() override;
 
-    static sptr<IInteger> Box(int value); /* [in] */
+    static sptr<IInteger> Box(int value)
+    {
+        return sptr<IInteger>();
+    }
+    /* [in] */
 
     static int Unbox(IInteger *object); /* [in] */
 
diff --git a/mock/innerkits/common_event_service/cesfwk_innerkits/include/common_event_publish_info.h b/mock/innerkits/common_event_service/cesfwk_innerkits/include/common_event_publish_info.h
index 54ad1ff177dbbce567a0df2365b99c9b7f7ff360..a883bf63140d52a8ca189df2afa8735593bd2c0d 100644
--- a/mock/innerkits/common_event_service/cesfwk_innerkits/include/common_event_publish_info.h
+++ b/mock/innerkits/common_event_service/cesfwk_innerkits/include/common_event_publish_info.h
@@ -1,17 +1,17 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
 #ifndef FOUNDATION_EVENT_CESFWK_KITS_NATIVE_INCLUDE_PUBLISH_INFO_H
 #define FOUNDATION_EVENT_CESFWK_KITS_NATIVE_INCLUDE_PUBLISH_INFO_H
@@ -20,110 +20,150 @@
 
 namespace OHOS {
 namespace EventFwk {
+
+enum SubscriberType {
+    ALL_SUBSCRIBER_TYPE,
+    SYSTEM_SUBSCRIBER_TYPE
+};
+
 class CommonEventPublishInfo : public Parcelable {
 public:
     CommonEventPublishInfo();
 
     /**
-     * A constructor used to create a CommonEventPublishInfo instance by copying
-     * parameters from an existing one.
-     *
-     * @param commonEventPublishInfo Indicates the publish info.
-     */
+    * A constructor used to create a CommonEventPublishInfo instance by copying
+    * parameters from an existing one.
+    *
+    * @param commonEventPublishInfo Indicates the publish info.
+    */
     explicit CommonEventPublishInfo(const CommonEventPublishInfo &commonEventPublishInfo);
 
     ~CommonEventPublishInfo();
 
     /**
-     * Sets whether the type of a common event is sticky or not.
-     *
-     * @param sticky Indicates the type of a common event is sticky or not
-     */
+    * Sets whether the type of a common event is sticky or not.
+    *
+    * @param sticky Indicates the type of a common event is sticky or not
+    */
     void SetSticky(bool sticky);
 
     /**
-     * Obtains whether it is a sticky common event, which can be set
-     * by SetSticky(bool).
-     *
-     * @return Returns the common event is sticky or not.
-     */
+    * Obtains whether it is a sticky common event, which can be set
+    * by SetSticky(bool).
+    *
+    * @return Returns the common event is sticky or not.
+    */
     bool IsSticky() const;
 
     /**
-     * Sets permissions for subscribers.
-     *
-     * @param subscriberPermissions Indicates the permissions for subscribers.
-     */
+    * Sets permissions for subscribers.
+    *
+    * @param subscriberPermissions Indicates the permissions for subscribers.
+    */
     void SetSubscriberPermissions(const std::vector<std::string> &subscriberPermissions);
 
     /**
-     * Obtains subscriber permissions to a common event, which can be set by
-     * setSubscriberPermissions(const std::vector<std::string>&).
-     *
-     * @return Returns the permissions for subscribers.
-     */
+    * Obtains subscriber permissions to a common event, which can be set by
+    * setSubscriberPermissions(const std::vector<std::string>&).
+    *
+    * @return Returns the permissions for subscribers.
+    */
     const std::vector<std::string> &GetSubscriberPermissions() const;
 
     /**
-     * Sets whether the type of a common event is ordered or not.
-     *
-     * @param ordered Indicates the type of a common event is ordered or not.
-     */
+    * Sets whether the type of a common event is ordered or not.
+    *
+    * @param ordered Indicates the type of a common event is ordered or not.
+    */
     void SetOrdered(bool ordered);
 
     /**
-     *
-     * Obtains whether it is an ordered common event, which can be set by setOrdered(boolean).
-     * set by SetOrdered(bool).
-     *
-     * @return Returns the type of a common event is ordered or not.
-     */
+    *
+    * Obtains whether it is an ordered common event, which can be set by setOrdered(boolean).
+    * set by SetOrdered(bool).
+    *
+    * @return Returns the type of a common event is ordered or not.
+    */
     bool IsOrdered() const;
 
     /**
-     * Sets the bundleName.
-     *
-     * @param bundleName Indicates the bundleName of a common event.
-     */
+    * Sets the bundleName.
+    *
+    * @param bundleName Indicates the bundleName of a common event.
+    */
     void SetBundleName(const std::string &bundleName);
 
     /**
-     * Obtains the bundleName of a common event
-     *
-     * @return Returns the bundleName of a common event.
-     */
+    * Sets uid of subscriber. A maximum of three receiver UIDs are supported.
+    * If there are more subscribers, the publisher needs to control the permission.
+    *
+    * @param subscriberUids Indicates the uids of subscribers.
+    */
+    void SetSubscriberUid(const std::vector<int32_t> &subscriberUids);
+
+    /**
+    * Obtains the uids of subscribers of this CommonEventPublishInfo object.
+    *
+    * @return Returns the uids of subscribers.
+    */
+    std::vector<int32_t> GetSubscriberUid() const;
+
+    /**
+    * Sets type of subscriber.
+    *
+    * @param subscriberType Indicates the type of subscriber, which can be ALL_SUBSCRIBER_TYPE = 0
+    * or SYSTEM_SUBSCRIBER_TYPE = 1. default is ALL_SUBSCRIBER_TYPE when param is out of range.
+    */
+    void SetSubscriberType(const int32_t &subscriberType);
+
+    /**
+    * Obtains the type of subscriber of this CommonEventPublishInfo object.
+    *
+    * @return Returns the type of subscriber.
+    */
+    int32_t GetSubscriberType() const;
+
+    /**
+    * Obtains the bundleName of a common event
+    *
+    * @return Returns the bundleName of a common event.
+    */
     std::string GetBundleName() const;
 
     /**
-     * Marshals a CommonEventData object into a Parcel.
-     *
-     * @param parcel Indicates specified Parcel object.
-     * @return Returns true if success; false otherwise.
-     */
+    * Marshals a CommonEventData object into a Parcel.
+    *
+    * @param parcel Indicates specified Parcel object.
+    * @return Returns true if success; false otherwise.
+    */
     virtual bool Marshalling(Parcel &parcel) const override;
 
     /**
-     * UnMarshals a Parcel object into a CommonEventData.
-     *
-     * @return Returns the common event data.
-     */
+    * UnMarshals a Parcel object into a CommonEventData.
+    *
+    * @return Returns the common event data.
+    */
     static CommonEventPublishInfo *Unmarshalling(Parcel &parcel);
 
 private:
     /**
-     * Reads a CommonEventData object from a Parcel.
-     *
-     * @param parcel Indicates specified Parcel object.
-     */
+    * Reads a CommonEventData object from a Parcel.
+    *
+    * @param parcel Indicates specified Parcel object.
+    */
     bool ReadFromParcel(Parcel &parcel);
 
+    bool isSubscriberType(int32_t subsciberType);
+
 private:
     bool sticky_;
     bool ordered_;
     std::string bundleName_;
     std::vector<std::string> subscriberPermissions_;
+    std::vector<int32_t> subscriberUids_;
+    int32_t subscriberType_;
 };
-}  // namespace EventFwk
-}  // namespace OHOS
+} // namespace EventFwk
+} // namespace OHOS
 
-#endif  // FOUNDATION_EVENT_CESFWK_KITS_NATIVE_INCLUDE_PUBLISH_INFO_H
\ No newline at end of file
+#endif // FOUNDATION_EVENT_CESFWK_KITS_NATIVE_INCLUDE_PUBLISH_INFO_H
\ No newline at end of file
diff --git a/mock/innerkits/device_manager/devicemanagersdk/include/device_manager.h b/mock/innerkits/device_manager/devicemanagersdk/include/device_manager.h
index ddd92e92d56051399d2e87df296bcc4de9f6aad9..9ea3c792df506c2abf5e1acf7f56c1abd5e4d271 100644
--- a/mock/innerkits/device_manager/devicemanagersdk/include/device_manager.h
+++ b/mock/innerkits/device_manager/devicemanagersdk/include/device_manager.h
@@ -252,6 +252,8 @@ public:
     */
    virtual int32_t GenerateEncryptedUuid(const std::string &pkgName, const std::string &uuid, const std::string &appId,
        std::string &encryptedUuid) = 0;
+
+   virtual bool IsSameAccount(const std::string &netWorkId) = 0;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/mock/innerkits/device_manager/devicemanagersdk/include/device_manager_impl.h b/mock/innerkits/device_manager/devicemanagersdk/include/device_manager_impl.h
index 4215fde3fce87e7aacda633ecef5f2c9e0fcb2a1..aeb0c3a7039d623e975410a2cc59525d8cb8906c 100644
--- a/mock/innerkits/device_manager/devicemanagersdk/include/device_manager_impl.h
+++ b/mock/innerkits/device_manager/devicemanagersdk/include/device_manager_impl.h
@@ -190,7 +190,7 @@ public:
 
     virtual int32_t GenerateEncryptedUuid(const std::string &pkgName, const std::string &uuid,
         const std::string &appId, std::string &encryptedUuid) override;
-
+    bool IsSameAccount(const std::string &netWorkId) override;
     int32_t GetDeviceInfo(const std::string &pkgName, const std::string networkId, DmDeviceInfo &deviceInfo) override;
     int32_t SetUserOperation(const std::string &pkgName, int32_t action, const std::string &params) override;
 
diff --git a/mock/innerkits/hilog_native/libhilog/include/hilog/log.h b/mock/innerkits/hilog_native/libhilog/include/hilog/log.h
index 4b0bc93cb3b12df3172510f57c9fb15a46ce0314..ae7724851451bbb2cb8a0b8e69e5e463b33e8320 100644
--- a/mock/innerkits/hilog_native/libhilog/include/hilog/log.h
+++ b/mock/innerkits/hilog_native/libhilog/include/hilog/log.h
@@ -18,5 +18,5 @@
 
 #include "hilog/log_c.h"
 #include "hilog/log_cpp.h"
-
+#define __FILE_NAME__ __FILE__
 #endif  // HIVIEWDFX_HILOG_H
\ No newline at end of file
diff --git a/mock/innerkits/memmgr/memmgrclient/include/bundle_priority.h b/mock/innerkits/memmgr/memmgrclient/include/bundle_priority.h
index d997f6e1715df80715208c2bdff2b8273ccd465a..88aad6d475cdf1bb302fc64c8ee8f8c04147d02d 100644
--- a/mock/innerkits/memmgr/memmgrclient/include/bundle_priority.h
+++ b/mock/innerkits/memmgr/memmgrclient/include/bundle_priority.h
@@ -24,7 +24,7 @@ namespace OHOS {
 namespace Memory {
 class BundlePriority {
 public:
-    BundlePriority();
+    BundlePriority() {}
     BundlePriority(int32_t uid, std::string name, int32_t priority, int32_t accountId) : uid_(uid), name_(name),
         priority_(priority), accountId_(accountId) {};
     int32_t uid_ {0};
diff --git a/mock/innerkits/multimedia_image_standard/image_native/include/pixel_map.h b/mock/innerkits/multimedia_image_standard/image_native/include/pixel_map.h
index 1ae840123074a86187177c09adbdad346dd8e40e..2e1030531834ea3b010e95046e376d4d4c0a66d3 100644
--- a/mock/innerkits/multimedia_image_standard/image_native/include/pixel_map.h
+++ b/mock/innerkits/multimedia_image_standard/image_native/include/pixel_map.h
@@ -128,6 +128,8 @@ public:
 
     NATIVEEXPORT bool Marshalling(Parcel &data) const override;
     NATIVEEXPORT static PixelMap *Unmarshalling(Parcel &data);
+    NATIVEEXPORT virtual bool EncodeTlv(std::vector<uint8_t> &buff) const;
+    NATIVEEXPORT static PixelMap *DecodeTlv(std::vector<uint8_t> &buff);
 
 #ifdef IMAGE_COLORSPACE_FLAG
     // -------[inner api for ImageSource/ImagePacker codec] it will get a colorspace object pointer----begin----
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_format_convert_mdk_kits.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_format_convert_mdk_kits.h
new file mode 100644
index 0000000000000000000000000000000000000000..004ca6778d67f9dfbbe6a1ac26ba1785b9f88f3a
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_format_convert_mdk_kits.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_FORMAT_CONVERT_MDK_KITS_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_FORMAT_CONVERT_MDK_KITS_H
+
+#include "common_utils.h"
+#include "image_format_convert.h"
+#include "napi/native_api.h"
+
+namespace OHOS {
+namespace Media {
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef struct ImageFormatConvertArgs {
+    std::shared_ptr<PixelMap> srcPixelMap = nullptr;
+    std::shared_ptr<PixelMap> destPixelMap = nullptr;
+    PixelFormat destPixelFormat;
+    int32_t srcFormatType;
+    int32_t destFormatType;
+    napi_env env;
+    napi_value pixelMapValue;
+    napi_value *result;
+} ImageFormatCovnertArgs;
+
+enum {
+    UNKNOWN,
+    YUV_TYPE,
+    RGB_TYPE
+};
+
+enum {
+    CTX_FUNC_IMAGE_CONVERT_EXEC,
+    CTX_FUNC_IMAGE_CONVERT_JS_TO_C_PIXEL_MAP,
+    CTX_FUNC_IMAGE_CONVERT_C_TO_JS_PIXEL_MAP
+};
+
+int32_t ImageConvertNativeCall(int32_t mode, ImageFormatConvertArgs *args);
+
+#ifdef __cplusplus
+};
+#endif
+} // namespace Media
+} // namespace OHOS
+
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_FORMAT_CONVERT_MDK_KITS_H
\ No newline at end of file
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_mdk_kits.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_mdk_kits.h
new file mode 100644
index 0000000000000000000000000000000000000000..62e2a77b8f90687956d6f1af228585bac9b324e4
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_mdk_kits.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_NAPI_KITS_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_NAPI_KITS_H
+
+#include "common_utils.h"
+#include "native_image.h"
+#include "image_napi.h"
+#include "image_mdk.h"
+
+namespace OHOS {
+namespace Media {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ImageNapiArgs {
+    int32_t inNum0;
+    struct OhosImageRect* outRect;
+    struct OhosImageSize* outSize;
+    int32_t* outNum0;
+    napi_value* outVal;
+    struct OhosImageComponent* outComponent;
+};
+
+enum {
+    CTX_FUNC_IMAGE_CLIP_RECT,
+    CTX_FUNC_IMAGE_SIZE,
+    CTX_FUNC_IMAGE_FORMAT,
+    CTX_FUNC_IMAGE_GET_COMPONENT
+};
+
+ImageNapi* ImageNapi_Unwrap(napi_env env, napi_value value);
+int32_t ImageNapiNativeCtxCall(int32_t mode, ImageNapi* native, struct ImageNapiArgs* args);
+#ifdef __cplusplus
+};
+#endif
+} // namespace Media
+} // namespace OHOS
+
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_NAPI_KITS_H
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_mdk_kits.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_mdk_kits.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1556b6853d8ac8bfe32d8d0d80b229cd462bce8
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_mdk_kits.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_MDK_KITS_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_MDK_KITS_H
+
+#include "common_utils.h"
+#include "image_packer_napi.h"
+#include "image_packer_mdk.h"
+
+namespace OHOS {
+namespace Media {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ImagePackerArgs {
+    napi_env inEnv;
+    ImagePackerNapi* inNapi;
+    int32_t inNum0 = -1;
+    napi_value inVal;
+    ImagePacker_Opts* inOpts;
+    uint8_t* outData;
+    size_t* dataSize;
+    napi_value* outVal;
+};
+
+enum {
+    ENV_FUNC_IMAGEPACKER_CREATE,
+    CTX_FUNC_IMAGEPACKER_PACKTODATA,
+    CTX_FUNC_IMAGEPACKER_PACKTOFILE,
+};
+ImagePackerNapi* ImagePackerNapi_Unwrap(napi_env env, napi_value value);
+int32_t ImagePackerNativeCall(int32_t mode, struct ImagePackerArgs* args);
+#ifdef __cplusplus
+};
+#endif
+} // namespace Media
+} // namespace OHOS
+
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_MDK_KITS_H
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_native_impl.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_native_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ca6146566654967fa3c173a8bc9882afe75bbbe
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_packer_native_impl.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_NATIVE_IMPL_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_NATIVE_IMPL_H
+#include <stdint.h>
+#include "image_packer.h"
+#include "image_source_native.h"
+#include "pixelmap_native.h"
+#include "picture_native.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OH_ImagePackerNative {
+public:
+    OH_ImagePackerNative();
+    OH_ImagePackerNative(std::shared_ptr<OHOS::Media::ImagePacker> imagePacker);
+    ~OH_ImagePackerNative();
+
+    int32_t PackingFromImageSource(OHOS::Media::PackOption *option, struct OH_ImageSourceNative *imageSource,
+        uint8_t *outData, int64_t *size);
+
+    int32_t PackingFromPixelmap(OHOS::Media::PackOption *option, struct OH_PixelmapNative *pixelmap,
+        uint8_t *outData, int64_t *size);
+
+    int32_t PackToDataMultiFrames(OHOS::Media::PackOption *option, std::vector<OH_PixelmapNative*> &pixelmap,
+        uint8_t *outData, int64_t *size);
+
+    int32_t PackToDataFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
+        uint8_t *outData, int64_t *size);
+
+    int32_t PackToFileFromImageSource(OHOS::Media::PackOption *option, struct OH_ImageSourceNative *imageSource,
+        const int fd);
+
+    int32_t PackToFileFromPixelmap(OHOS::Media::PackOption *option, struct OH_PixelmapNative *pixelmap,
+        const int32_t fd);
+
+    int32_t PackToFileMultiFrames(OHOS::Media::PackOption *option, std::vector<OH_PixelmapNative*> &pixelmap,
+        int32_t fd);
+
+    int32_t PackToFileFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
+        const int32_t fd);
+
+    std::shared_ptr<OHOS::Media::ImagePacker> GetInnerImagePacker();
+
+private:
+    std::shared_ptr<OHOS::Media::ImagePacker> imagePacker_;
+};
+
+#ifdef __cplusplus
+};
+#endif
+/** @} */
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_PACKER_NATIVE_IMPL_H
\ No newline at end of file
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_mdk_kits.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_mdk_kits.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b89d2e0a72115834129008b9ed7a10f11778bea
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_mdk_kits.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_MDK_KITS_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_MDK_KITS_H
+
+#include "common_utils.h"
+#include "native_image.h"
+#include "image_receiver_napi.h"
+#include "image_receiver_mdk.h"
+
+namespace OHOS {
+namespace Media {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct ImageReceiverArgs {
+    char* id;
+    size_t inLen;
+    int32_t inNum0;
+    int32_t inNum1;
+    int32_t inNum2;
+    int32_t inNum3;
+    napi_env inEnv;
+    OH_Image_Receiver_On_Callback callback;
+    napi_value* outValue;
+    int32_t* outNum0;
+    struct OhosImageSize* outSize;
+};
+
+enum {
+    ENV_FUNC_IMAGE_RECEIVER_CREATE,
+    CTX_FUNC_IMAGE_RECEIVER_GET_RECEIVER_ID,
+    CTX_FUNC_IMAGE_RECEIVER_READ_LATEST_IMAGE,
+    CTX_FUNC_IMAGE_RECEIVER_READ_NEXT_IMAGE,
+    CTX_FUNC_IMAGE_RECEIVER_ON,
+    CTX_FUNC_IMAGE_RECEIVER_GET_SIZE,
+    CTX_FUNC_IMAGE_RECEIVER_GET_CAPACITY,
+    CTX_FUNC_IMAGE_RECEIVER_GET_FORMAT,
+};
+
+ImageReceiverNapi* ImageReceiver_Unwrap(napi_env env, napi_value value);
+int32_t ImageReceiverNativeEnvCall(int32_t mode, napi_env env, struct ImageReceiverArgs* args);
+int32_t ImageReceiverNativeCtxCall(int32_t mode, ImageReceiverNapi* native, struct ImageReceiverArgs* args);
+#ifdef __cplusplus
+};
+#endif
+} // namespace Media
+} // namespace OHOS
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_MDK_KITS_H
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_napi_listener.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_napi_listener.h
new file mode 100644
index 0000000000000000000000000000000000000000..0918cea4a80cae7343d31b331fb266089211a8aa
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_receiver_napi_listener.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_NAPI_LISTENER_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_NAPI_LISTENER_H
+
+#include "image_receiver.h"
+#include "image_receiver_mdk.h"
+
+namespace OHOS {
+namespace Media {
+class ImageReceiverNapiListener : public SurfaceBufferAvaliableListener {
+public:
+    ~ImageReceiverNapiListener() override
+    {
+        callBack = nullptr;
+    }
+    void OnSurfaceBufferAvaliable() __attribute__((no_sanitize("cfi"))) override
+    {
+        if (callBack != nullptr) {
+            callBack();
+        }
+    }
+    OH_Image_Receiver_On_Callback callBack = nullptr;
+};
+} // namespace Media
+} // namespace OHOS
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_RECEIVER_NAPI_LISTENER_H
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_mdk_kits.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_mdk_kits.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6de02dacbd2f09327fb131c26599793f5992c3a
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_mdk_kits.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_MDK_KITS_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_MDK_KITS_H
+
+#include "common_utils.h"
+#include "image_source_napi.h"
+#include "image_source_mdk.h"
+#include "raw_file.h"
+
+namespace OHOS {
+namespace Media {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct DataArray {
+    uint8_t* data = nullptr;
+    uint32_t dataSize = 0;
+};
+
+struct ImageSourceArgs {
+    struct OhosImageSource* source;
+    struct OhosImageSourceOps* sourceOps;
+    struct OhosImageDecodingOps* decodingOps;
+    struct OhosImageSourceDelayTimeList* outDelayTimes;
+    struct OhosImageSourceSupportedFormatList* outFormats;
+    struct OhosImageSourceInfo* outInfo;
+    struct OhosImageSourceProperty* inPropertyKey;
+    struct OhosImageSourceProperty* propertyVal;
+    struct OhosImageSourceUpdateData* inUpdateData;
+    DataArray dataArray;
+    std::string uri;
+    int32_t fd = -1;
+    RawFileDescriptor rawFile;
+    ImageSourceNapi* napi;
+    napi_env inEnv;
+    napi_value inVal;
+    int32_t inInt32;
+    napi_value *outVal;
+    uint32_t* outUint32;
+};
+
+enum {
+    ENV_FUNC_IMAGE_SOURCE_CREATE,
+    ENV_FUNC_IMAGE_SOURCE_CREATE_FROM_URI,
+    ENV_FUNC_IMAGE_SOURCE_CREATE_FROM_FD,
+    ENV_FUNC_IMAGE_SOURCE_CREATE_FROM_DATA,
+    ENV_FUNC_IMAGE_SOURCE_CREATE_FROM_RAW_FILE,
+    ENV_FUNC_IMAGE_SOURCE_CREATE_INCREMENTAL,
+    ENV_FUNC_IMAGE_SOURCE_UNWRAP,
+    STA_FUNC_IMAGE_SOURCE_GET_SUPPORTED_FORMATS,
+    CTX_FUNC_IMAGE_SOURCE_CREATE_PIXELMAP,
+    CTX_FUNC_IMAGE_SOURCE_CREATE_PIXELMAP_LIST,
+    CTX_FUNC_IMAGE_SOURCE_GET_DELAY_TIME,
+    CTX_FUNC_IMAGE_SOURCE_GET_FRAME_COUNT,
+    CTX_FUNC_IMAGE_SOURCE_GET_IMAGE_INFO,
+    CTX_FUNC_IMAGE_SOURCE_GET_IMAGE_PROPERTY,
+    CTX_FUNC_IMAGE_SOURCE_MODIFY_IMAGE_PROPERTY,
+    CTX_FUNC_IMAGE_SOURCE_UPDATE_DATA
+};
+
+int32_t ImageSourceNativeCall(int32_t mode, struct ImageSourceArgs* args);
+#ifdef __cplusplus
+};
+#endif
+} // namespace Media
+} // namespace OHOS
+
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_MDK_KITS_H
\ No newline at end of file
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_native_impl.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_native_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d904a702e714ac9410406a8e176792e4a0f2251
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/image_source_native_impl.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_NATIVE_IMPL_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_NATIVE_IMPL_H
+#include <stdint.h>
+#include "image_source.h"
+//#include "image_source_native.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OH_ImageSourceNative {
+public:
+    OH_ImageSourceNative(std::shared_ptr<OHOS::Media::ImageSource> imageSource);
+    OH_ImageSourceNative(char *uri, size_t size, OHOS::Media::SourceOptions ops);
+    OH_ImageSourceNative(int32_t fd, OHOS::Media::SourceOptions ops);
+    OH_ImageSourceNative(uint8_t *data, size_t dataSize, OHOS::Media::SourceOptions ops);
+//    OH_ImageSourceNative(RawFileDescriptor rawFile, OHOS::Media::SourceOptions ops);
+    ~OH_ImageSourceNative();
+    std::shared_ptr<OHOS::Media::ImageSource> GetInnerImageSource();
+    std::string filePath_ = "";
+    int fileDescriptor_ = -1;
+    void *fileBuffer_ = nullptr;
+    size_t fileBufferSize_ = 0;
+private:
+    std::string UrlToPath(const std::string &path);
+    std::shared_ptr<OHOS::Media::ImageSource> innerImageSource_;
+};
+
+//struct OH_DecodingOptionsForPicture {
+//public:
+//    OH_DecodingOptionsForPicture(std::shared_ptr<OHOS::Media::DecodingOptionsForPicture> decodingOptionsForPicture);
+//    ~OH_DecodingOptionsForPicture();
+//    std::shared_ptr<OHOS::Media::DecodingOptionsForPicture> GetInnerDecodingOptForPicture();
+//
+//private:
+//    std::shared_ptr<OHOS::Media::DecodingOptionsForPicture> decodingOptionsForPicture_;
+//};
+
+#ifdef __cplusplus
+};
+#endif
+/** @} */
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_IMAGE_SOURCE_NATIVE_IMPL_H
\ No newline at end of file
diff --git a/mock/innerkits/multimedia_image_standard/image_native/ndk/include/pixelmap_native_impl.h b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/pixelmap_native_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..3399f7fac32460d1c291aec17d34e89ec1ec3b42
--- /dev/null
+++ b/mock/innerkits/multimedia_image_standard/image_native/ndk/include/pixelmap_native_impl.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FRAMEWORKS_KITS_JS_COMMON_INCLUDE_PIXELMAP_NATIVE_IMPL_H
+#define FRAMEWORKS_KITS_JS_COMMON_INCLUDE_PIXELMAP_NATIVE_IMPL_H
+#include <stdint.h>
+#include "pixel_map.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OH_PixelmapNative {
+public:
+    OH_PixelmapNative(std::shared_ptr<OHOS::Media::PixelMap> pixelMap);
+    OH_PixelmapNative(const uint32_t *colors, uint32_t colorLength, const OHOS::Media::InitializationOptions &opts);
+    OH_PixelmapNative(const OHOS::Media::InitializationOptions &opts);
+    OH_PixelmapNative(OH_PixelmapNative *OH_PixelmapNative, const OHOS::Media::InitializationOptions &opts);
+    ~OH_PixelmapNative();
+
+    std::shared_ptr<OHOS::Media::PixelMap> GetInnerPixelmap();
+
+private:
+    std::shared_ptr<OHOS::Media::PixelMap> pixelmap_;
+};
+
+#ifdef __cplusplus
+};
+#endif
+/** @} */
+#endif // FRAMEWORKS_KITS_JS_COMMON_INCLUDE_PIXELMAP_NATIVE_IMPL_H
\ No newline at end of file
diff --git a/mock/innerkits/napi/common.h b/mock/innerkits/napi/common.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea69ca2427d59440f27b1573303a9869860ffa5e
--- /dev/null
+++ b/mock/innerkits/napi/common.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_COMMON_H
+#define FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_COMMON_H
+
+typedef enum {
+    napi_qos_background = 0,
+    napi_qos_utility = 1,
+    napi_qos_default = 2,
+    napi_qos_user_initiated = 3,
+    uv_qos_user_initiated = 4,
+} napi_qos_t;
+
+typedef enum {
+    napi_event_mode_default = 0,
+    napi_event_mode_nowait = 1,
+} napi_event_mode;
+
+typedef enum {
+    napi_priority_immediate = 0,
+    napi_priority_high = 1,
+    napi_priority_low = 2,
+    napi_priority_idle = 3,
+} napi_task_priority;
+
+#endif /* FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_API_H */
\ No newline at end of file
diff --git a/mock/innerkits/napi/native_api.h b/mock/innerkits/napi/native_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f94f1d5a24054f23fa31a45f757ac883c5f4af1
--- /dev/null
+++ b/mock/innerkits/napi/native_api.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_API_H
+#define FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_API_H
+
+#ifndef NAPI_VERSION
+#define NAPI_VERSION 8
+#endif
+
+#ifndef NAPI_EXPERIMENTAL
+#define NAPI_EXPERIMENTAL
+#endif
+
+#include "common.h"
+#include "node_api.h"
+
+#ifdef NAPI_TEST
+#ifdef _WIN32
+#define NAPI_INNER_EXTERN __declspec(dllexport)
+#else
+#define NAPI_INNER_EXTERN __attribute__((visibility("default")))
+#endif
+#else
+#ifdef _WIN32
+#define NAPI_INNER_EXTERN __declspec(deprecated)
+#else
+#define NAPI_INNER_EXTERN __attribute__((__deprecated__))
+#endif
+#endif
+
+NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err);
+
+
+NAPI_EXTERN napi_status napi_create_string_utf16(napi_env env,
+                                                 const char16_t* str,
+                                                 size_t length,
+                                                 napi_value* result);
+
+NAPI_EXTERN napi_status napi_get_value_string_utf16(napi_env env,
+                                                    napi_value value,
+                                                    char16_t* buf,
+                                                    size_t bufsize,
+                                                    size_t* result);
+
+NAPI_EXTERN napi_status napi_type_tag_object(napi_env env,
+                                             napi_value value,
+                                             const napi_type_tag* type_tag);
+
+NAPI_EXTERN napi_status napi_check_object_type_tag(napi_env env,
+                                                   napi_value value,
+                                                   const napi_type_tag* type_tag,
+                                                   bool* result);
+
+NAPI_INNER_EXTERN napi_status napi_adjust_external_memory(napi_env env,
+                                                          int64_t change_in_bytes,
+                                                          int64_t* adjusted_value);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (*napi_native_binding_detach_callback)(napi_env env, void* native_object, void* hint);
+typedef napi_value (*napi_native_binding_attach_callback)(napi_env env, void* native_object, void* hint);
+
+NAPI_EXTERN napi_status napi_run_script_path(napi_env env, const char* path, napi_value* result);
+NAPI_EXTERN napi_status napi_queue_async_work_with_qos(napi_env env, napi_async_work work, napi_qos_t qos);
+NAPI_EXTERN napi_status napi_load_module(napi_env env, const char* path, napi_value* result);
+NAPI_EXTERN napi_status napi_load_module_with_info(napi_env env,
+                                                   const char* path,
+                                                   const char* module_info,
+                                                   napi_value* result);
+NAPI_EXTERN napi_status napi_get_instance_data(napi_env env, void** data);
+NAPI_EXTERN napi_status napi_set_instance_data(napi_env env,
+                                               void* data,
+                                               napi_finalize finalize_cb,
+                                               void* finalize_hint);
+NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env, void (*fun)(void* arg), void* arg);
+NAPI_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env, void (*fun)(void* arg), void* arg);
+NAPI_EXTERN napi_status napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle);
+NAPI_EXTERN napi_status napi_add_async_cleanup_hook(napi_env env,
+                                                    napi_async_cleanup_hook hook,
+                                                    void* arg,
+                                                    napi_async_cleanup_hook_handle* remove_handle);
+NAPI_EXTERN napi_status napi_async_destroy(napi_env env,
+                                           napi_async_context async_context);
+NAPI_EXTERN napi_status napi_async_init(napi_env env,
+                                        napi_value async_resource,
+                                        napi_value async_resource_name,
+                                        napi_async_context* result);
+NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env, napi_callback_scope scope);
+NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
+                                                 napi_value resource_object,
+                                                 napi_async_context context,
+                                                 napi_callback_scope* result);
+NAPI_EXTERN napi_status node_api_get_module_file_name(napi_env env, const char** result);
+NAPI_EXTERN napi_status napi_create_object_with_properties(napi_env env,
+                                                           napi_value* result,
+                                                           size_t property_count,
+                                                           const napi_property_descriptor* properties);
+NAPI_EXTERN napi_status napi_create_object_with_named_properties(napi_env env,
+                                                                 napi_value* result,
+                                                                 size_t property_count,
+                                                                 const char** keys,
+                                                                 const napi_value* values);
+NAPI_EXTERN napi_status napi_coerce_to_native_binding_object(napi_env env,
+                                                             napi_value js_object,
+                                                             napi_native_binding_detach_callback detach_cb,
+                                                             napi_native_binding_attach_callback attach_cb,
+                                                             void* native_object,
+                                                             void* hint);
+NAPI_EXTERN napi_status napi_add_finalizer(napi_env env,
+                                           napi_value js_object,
+                                           void* native_object,
+                                           napi_finalize finalize_cb,
+                                           void* finalize_hint,
+                                           napi_ref* result);
+NAPI_EXTERN napi_status napi_run_event_loop(napi_env env, napi_event_mode mode);
+NAPI_EXTERN napi_status napi_stop_event_loop(napi_env env);
+NAPI_EXTERN napi_status napi_create_ark_runtime(napi_env *env);
+NAPI_EXTERN napi_status napi_destroy_ark_runtime(napi_env *env);
+
+NAPI_EXTERN napi_status napi_serialize(napi_env env,
+                                       napi_value object,
+                                       napi_value transfer_list,
+                                       napi_value clone_list,
+                                       void** result);
+NAPI_EXTERN napi_status napi_deserialize(napi_env env, void* buffer, napi_value* object);
+NAPI_EXTERN napi_status napi_delete_serialization_data(napi_env env, void* buffer);
+NAPI_EXTERN napi_status napi_is_concurrent_function(napi_env env, napi_value value, bool* result);
+
+
+NAPI_EXTERN napi_status napi_call_threadsafe_function_with_priority(napi_threadsafe_function func,
+                                                                    void *data,
+                                                                    napi_task_priority priority,
+                                                                    bool isTail);
+NAPI_EXTERN napi_status napi_create_map(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_map_set_property(napi_env env, napi_value map, napi_value key, napi_value value);
+NAPI_EXTERN napi_status napi_map_set_named_property(napi_env env,
+                                                    napi_value map,
+                                                    const char* utf8name,
+                                                    napi_value value);
+NAPI_EXTERN napi_status napi_map_get_property(napi_env env, napi_value map, napi_value key, napi_value* result);
+NAPI_EXTERN napi_status napi_map_get_named_property(napi_env env,
+                                                    napi_value map,
+                                                    const char* utf8name,
+                                                    napi_value* result);
+NAPI_EXTERN napi_status napi_map_has_property(napi_env env, napi_value map, napi_value key, bool* result);
+NAPI_EXTERN napi_status napi_map_has_named_property(napi_env env, napi_value map, const char* utf8name, bool* result);
+NAPI_EXTERN napi_status napi_map_delete_property(napi_env env, napi_value map, napi_value key);
+NAPI_EXTERN napi_status napi_map_clear(napi_env env, napi_value map);
+NAPI_EXTERN napi_status napi_map_get_size(napi_env env, napi_value map, uint32_t* result);
+NAPI_EXTERN napi_status napi_map_get_entries(napi_env env, napi_value map, napi_value* result);
+NAPI_EXTERN napi_status napi_map_get_keys(napi_env env, napi_value map, napi_value* result);
+NAPI_EXTERN napi_status napi_map_get_values(napi_env env, napi_value map, napi_value* result);
+NAPI_EXTERN napi_status napi_map_iterator_get_next(napi_env env, napi_value iterator, napi_value* result);
+
+// ======================================= sendable api begin ======================================= //
+NAPI_EXTERN napi_status napi_define_sendable_class(napi_env env,
+                                                   const char* utf8name,
+                                                   size_t length,
+                                                   napi_callback constructor,
+                                                   void* data,
+                                                   size_t property_count,
+                                                   const napi_property_descriptor* properties,
+                                                   napi_value parent,
+                                                   napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_object_with_properties(napi_env env,
+                                                                    size_t property_count,
+                                                                    const napi_property_descriptor* properties,
+                                                                    napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_array(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_array_with_length(napi_env env, size_t length, napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_arraybuffer(napi_env env, size_t byte_length,
+                                                         void** data, napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_typedarray(napi_env env,
+                                                        napi_typedarray_type type,
+                                                        size_t length,
+                                                        napi_value arraybuffer,
+                                                        size_t byte_offset,
+                                                        napi_value* result);
+NAPI_EXTERN napi_status napi_create_sendable_map(napi_env env, napi_value* result);
+/*
+ * Determine whether it can be held by a sendable object, including the sendable object and primitive type.
+ */
+NAPI_EXTERN napi_status napi_is_sendable(napi_env env, napi_value value, bool* result);
+NAPI_EXTERN napi_status napi_wrap_sendable(napi_env env,
+                                           napi_value js_object,
+                                           void* native_object,
+                                           napi_finalize finalize_cb,
+                                           void* finalize_hint);
+NAPI_EXTERN napi_status napi_wrap_sendable_with_size(napi_env env,
+                                                     napi_value js_object,
+                                                     void* native_object,
+                                                     napi_finalize finalize_cb,
+                                                     void* finalize_hint,
+                                                     size_t native_binding_size);
+NAPI_EXTERN napi_status napi_unwrap_sendable(napi_env env, napi_value js_object, void** result);
+NAPI_EXTERN napi_status napi_remove_wrap_sendable(napi_env env, napi_value js_object, void** result);
+// ======================================== sendable api end ======================================== //
+#ifdef __cplusplus
+}
+#endif
+#endif /* FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_API_H */
diff --git a/mock/innerkits/napi/native_common.h b/mock/innerkits/napi/native_common.h
index 673301787a088c67cb8558ae6c18ae6d29fe24b8..5b753ed2e0b8182b365f3b4fcecf0a882ba5b40a 100644
--- a/mock/innerkits/napi/native_common.h
+++ b/mock/innerkits/napi/native_common.h
@@ -1,17 +1,17 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
 #ifndef FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_COMMON_H
 #define FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_COMMON_H
@@ -19,80 +19,108 @@
 #define NAPI_RETVAL_NOTHING
 
 #define GET_AND_THROW_LAST_ERROR(env)                                                                   \
-    do {                                                                                                \
-        const napi_extended_error_info* errorInfo = nullptr;                                            \
-        napi_get_last_error_info((env), &errorInfo);                                                    \
-        bool isPending = false;                                                                         \
-        napi_is_exception_pending((env), &isPending);                                                   \
-        if (!isPending && errorInfo != nullptr) {                                                       \
-            const char* errorMessage =                                                                  \
-                errorInfo->error_message != nullptr ? errorInfo->error_message : "empty error message"; \
-            napi_throw_error((env), nullptr, errorMessage);                                             \
-        }                                                                                               \
-    } while (0)
+   do {                                                                                                \
+       const napi_extended_error_info* errorInfo = nullptr;                                            \
+       napi_get_last_error_info((env), &errorInfo);                                                    \
+       bool isPending = false;                                                                         \
+       napi_is_exception_pending((env), &isPending);                                                   \
+       if (!isPending && errorInfo != nullptr) {                                                       \
+           const char* errorMessage =                                                                  \
+               errorInfo->error_message != nullptr ? errorInfo->error_message : "empty error message"; \
+           napi_throw_error((env), nullptr, errorMessage);                                             \
+       }                                                                                               \
+   } while (0)
 
 #define NAPI_ASSERT_BASE(env, assertion, message, retVal)                                    \
-    do {                                                                                     \
-        if (!(assertion)) {                                                                  \
-            napi_throw_error((env), nullptr, "assertion (" #assertion ") failed: " message); \
-            return retVal;                                                                   \
-        }                                                                                    \
-    } while (0)
+   do {                                                                                     \
+       if (!(assertion)) {                                                                  \
+           napi_throw_error((env), nullptr, "assertion (" #assertion ") failed: " message); \
+           return retVal;                                                                   \
+       }                                                                                    \
+   } while (0)
 
 #define NAPI_ASSERT(env, assertion, message) NAPI_ASSERT_BASE(env, assertion, message, nullptr)
 
 #define NAPI_ASSERT_RETURN_VOID(env, assertion, message) NAPI_ASSERT_BASE(env, assertion, message, NAPI_RETVAL_NOTHING)
 
 #define NAPI_CALL_BASE(env, theCall, retVal) \
-    do {                                     \
-        if ((theCall) != napi_ok) {          \
-            GET_AND_THROW_LAST_ERROR((env)); \
-            return retVal;                   \
-        }                                    \
-    } while (0)
+   do {                                     \
+       if ((theCall) != napi_ok) {          \
+           GET_AND_THROW_LAST_ERROR((env)); \
+           return retVal;                   \
+       }                                    \
+   } while (0)
 
 #define NAPI_CALL(env, theCall) NAPI_CALL_BASE(env, theCall, nullptr)
 
 #define NAPI_CALL_RETURN_VOID(env, theCall) NAPI_CALL_BASE(env, theCall, NAPI_RETVAL_NOTHING)
 
 #define DECLARE_NAPI_PROPERTY(name, val)                                       \
-    {                                                                          \
-        (name), nullptr, nullptr, nullptr, nullptr, val, napi_default, nullptr \
-    }
+   {                                                                          \
+       (name), nullptr, nullptr, nullptr, nullptr, val, napi_default, nullptr \
+   }
+
+#define DECLARE_NAPI_INSTANCE_PROPERTY(name, val)                                           \
+   {                                                                                       \
+       (name), nullptr, nullptr, nullptr, nullptr, val,                                    \
+           static_cast<napi_property_attributes>(NATIVE_INSTANCE | napi_writable), nullptr \
+   }
+
+#define DECLARE_NAPI_INSTANCE_OBJECT_PROPERTY(name)                                                \
+   {                                                                                              \
+       (name), nullptr, nullptr, nullptr, nullptr, nullptr,                                       \
+           static_cast<napi_property_attributes>(NATIVE_INSTANCE_OBJECT | napi_writable), nullptr \
+   }
+
+#define DECLARE_NAPI_INSTANCE_GENERIC_PROPERTY(name)                                                \
+   {                                                                                              \
+       (name), nullptr, nullptr, nullptr, nullptr, nullptr,                                       \
+           static_cast<napi_property_attributes>(NATIVE_INSTANCE_GENERIC | napi_writable), nullptr \
+   }
+
+#define DECLARE_NAPI_DEFAULT_PROPERTY(name, val)                                          \
+   {                                                                                     \
+       (name), nullptr, nullptr, nullptr, nullptr, val, napi_default_jsproperty, nullptr \
+   }
 
 #define DECLARE_NAPI_STATIC_PROPERTY(name, val)                               \
-    {                                                                         \
-        (name), nullptr, nullptr, nullptr, nullptr, val, napi_static, nullptr \
-    }
+   {                                                                         \
+       (name), nullptr, nullptr, nullptr, nullptr, val, napi_static, nullptr \
+   }
 
 #define DECLARE_NAPI_FUNCTION(name, func)                                         \
-    {                                                                             \
-        (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, nullptr \
-    }
+   {                                                                             \
+       (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, nullptr \
+   }
+
+#define DECLARE_NAPI_DEFAULT_PROPERTY_FUNCTION(name, func)                                   \
+   {                                                                                        \
+       (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default_jsproperty, nullptr \
+   }
 
 #define DECLARE_NAPI_FUNCTION_WITH_DATA(name, func, data)                      \
-    {                                                                          \
-        (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, data \
-    }
+   {                                                                          \
+       (name), nullptr, (func), nullptr, nullptr, nullptr, napi_default, data \
+   }
 
 #define DECLARE_NAPI_STATIC_FUNCTION(name, func)                                 \
-    {                                                                            \
-        (name), nullptr, (func), nullptr, nullptr, nullptr, napi_static, nullptr \
-    }
+   {                                                                            \
+       (name), nullptr, (func), nullptr, nullptr, nullptr, napi_static, nullptr \
+   }
 
 #define DECLARE_NAPI_GETTER(name, getter)                                           \
-    {                                                                               \
-        (name), nullptr, nullptr, (getter), nullptr, nullptr, napi_default, nullptr \
-    }
+   {                                                                               \
+       (name), nullptr, nullptr, (getter), nullptr, nullptr, napi_default, nullptr \
+   }
 
 #define DECLARE_NAPI_SETTER(name, setter)                                           \
-    {                                                                               \
-        (name), nullptr, nullptr, nullptr, (setter), nullptr, napi_default, nullptr \
-    }
+   {                                                                               \
+       (name), nullptr, nullptr, nullptr, (setter), nullptr, napi_default, nullptr \
+   }
 
 #define DECLARE_NAPI_GETTER_SETTER(name, getter, setter)                             \
-    {                                                                                \
-        (name), nullptr, nullptr, (getter), (setter), nullptr, napi_default, nullptr \
-    }
+   {                                                                                \
+       (name), nullptr, nullptr, (getter), (setter), nullptr, napi_default, nullptr \
+   }
 
 #endif /* FOUNDATION_ACE_NAPI_INTERFACES_KITS_NAPI_NATIVE_COMMON_H */
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_callback_interface.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_callback_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..d86fb059d9a8fff5901961a66745b25e7d7a9157
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_callback_interface.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef I_SCREENLOCK_CALLBACK_INTERFACE_H
+#define I_SCREENLOCK_CALLBACK_INTERFACE_H
+
+#include "iremote_broker.h"
+namespace OHOS {
+namespace ScreenLock {
+struct ErrorInfo {
+    uint32_t errorCode_ = 0;
+    std::string message_;
+};
+
+class ScreenLockCallbackInterface : public IRemoteBroker {
+public:
+    DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.ScreenLock.ScreenLockCallbackInterface");
+    virtual void OnCallBack(int32_t screenLockResult) = 0;
+    enum Message { ON_CALLBACK = 0 };
+};
+} // namespace ScreenLock
+} // namespace OHOS
+
+#endif // I_SCREENLOCK_CALLBACK_INTERFACE_H
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_common.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c0464a8168777ce29808e7b243dff31fc2b6c85
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_common.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERVICES_INCLUDE_SCREENLOCK_COMMON_H
+#define SERVICES_INCLUDE_SCREENLOCK_COMMON_H
+
+#include <string>
+
+#include "errors.h"
+
+namespace OHOS {
+namespace ScreenLock {
+#define SCREENLOCK_SERVICE_NAME "ScreenLockService"
+#define PARAM_ZERO 0
+#define PARAM_ONE 1
+#define PARAM_TWO 2
+
+const std::string BEGIN_WAKEUP = "beginWakeUp";
+const std::string END_WAKEUP = "endWakeUp";
+const std::string BEGIN_SCREEN_ON = "beginScreenOn";
+const std::string END_SCREEN_ON = "endScreenOn";
+const std::string BEGIN_SLEEP = "beginSleep";
+const std::string END_SLEEP = "endSleep";
+const std::string BEGIN_SCREEN_OFF = "beginScreenOff";
+const std::string END_SCREEN_OFF = "endScreenOff";
+const std::string STRONG_AUTH_CHANGED = "strongAuthChanged";
+const std::string CHANGE_USER = "changeUser";
+const std::string SCREENLOCK_ENABLED = "screenlockEnabled";
+const std::string EXIT_ANIMATION = "beginExitAnimation";
+const std::string UNLOCKSCREEN = "unlockScreen";
+const std::string UNLOCK_SCREEN_RESULT = "unlockScreenResult";
+const std::string LOCKSCREEN = "lockScreen";
+const std::string LOCK_SCREEN_RESULT = "lockScreenResult";
+const std::string SCREEN_DRAWDONE = "screenDrawDone";
+const std::string SYSTEM_READY = "systemReady";
+const std::string SERVICE_RESTART = "serviceRestart";
+const int USER_NULL = -10000;
+enum ScreenLockModule {
+    SCREENLOCK_MODULE_SERVICE_ID = 0x04,
+};
+// time error offset, used only in this file.
+constexpr ErrCode SCREENLOCK_ERR_OFFSET = ErrCodeOffset(SUBSYS_SMALLSERVICES, SCREENLOCK_MODULE_SERVICE_ID);
+
+enum ScreenLockError {
+    E_SCREENLOCK_OK = SCREENLOCK_ERR_OFFSET,
+    E_SCREENLOCK_SA_DIED,
+    E_SCREENLOCK_READ_PARCEL_ERROR,
+    E_SCREENLOCK_WRITE_PARCEL_ERROR,
+    E_SCREENLOCK_PUBLISH_FAIL,
+    E_SCREENLOCK_TRANSACT_ERROR,
+    E_SCREENLOCK_DEAL_FAILED,
+    E_SCREENLOCK_PARAMETERS_INVALID,
+    E_SCREENLOCK_SET_RTC_FAILED,
+    E_SCREENLOCK_NOT_FOUND,
+    E_SCREENLOCK_NO_PERMISSION,
+    E_SCREENLOCK_NULLPTR,
+    E_SCREENLOCK_SENDREQUEST_FAILED,
+    E_SCREENLOCK_NOT_SYSTEM_APP,
+    E_SCREENLOCK_NOT_FOCUS_APP,
+};
+
+enum TraceTaskId : int32_t {
+    HITRACE_UNLOCKSCREEN,
+    HITRACE_LOCKSCREEN,
+    HITRACE_BUTT,
+};
+
+enum ScreenChange {
+    SCREEN_SUCC = 0,
+    SCREEN_FAIL,
+    SCREEN_CANCEL,
+};
+
+enum JsErrorCode : uint32_t {
+    ERR_NO_PERMISSION = 201,
+    ERR_NOT_SYSTEM_APP = 202,
+    ERR_INVALID_PARAMS = 401,
+    ERR_CANCEL_UNLOCK = 13200001,
+    ERR_SERVICE_ABNORMAL = 13200002,
+    ERR_ILLEGAL_USE = 13200003,
+};
+
+enum class Action : uint8_t {
+    LOCK = 0,
+    UNLOCK,
+    UNLOCKSCREEN,
+};
+
+enum class StrongAuthReasonFlags : int32_t {
+    NONE = 0x00000000,
+    AFTER_BOOT = 0x00000001,
+    AFTER_TIMEOUT = 0x00000002,
+    ACTIVE_REQUEST = 0x00000004,
+    DPM_RESTRICT = 0x00000008,
+};
+
+constexpr int BEGIN_SLEEP_DEVICE_ADMIN_REASON = 1;
+constexpr int BEGIN_SLEEP_USER_REASON = 2;
+constexpr int BEGIN_SLEEP_LONG_TIME_UNOPERATOR = 3;
+
+constexpr int END_SLEEP_DEVICE_ADMIN_REASON = 1;
+constexpr int END_SLEEP_USER_REASON = 2;
+constexpr int END_SLEEP_LONG_TIME_UNOPERATE = 3;
+
+constexpr int SCREENLOCK_APP_CAN_USE = 1;
+constexpr int SCREENLOCK_APP_CAN_NOT_USE = 0;
+
+constexpr std::int32_t DEFAULT_ERROR = -1;
+constexpr int32_t NONE_EVENT_TYPE = 0;
+constexpr int ARGV_ZERO = 0;
+constexpr int ARGV_ONE = 1;
+constexpr int ARGV_TWO = 2;
+constexpr int ARGV_THREE = 3;
+constexpr int ARGV_NORMAL = -100;
+constexpr std::int32_t MAX_VALUE_LEN = 4096;
+constexpr const std::int32_t STR_MAX_SIZE = 256;
+constexpr int RESULT_COUNT = 2;
+constexpr int PARAMTWO = 2;
+constexpr std::int32_t ARGS_SIZE_ZERO = 0;
+constexpr std::int32_t ARGS_SIZE_ONE = 1;
+constexpr std::int32_t ARGS_SIZE_TWO = 2;
+constexpr std::int32_t ARGS_SIZE_THREE = 3;
+constexpr std::int32_t ARGS_SIZE_FOUR = 4;
+constexpr std::int32_t RESULT_ZERO = 0;
+} // namespace ScreenLock
+} // namespace OHOS
+#endif // SERVICES_INCLUDE_SCREENLOCK_COMMON_H
\ No newline at end of file
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..f268bf5b6d582b90474630126c19e8c433470329
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERVICES_INCLUDE_SCLOCK_MANAGER_H
+#define SERVICES_INCLUDE_SCLOCK_MANAGER_H
+
+#include <mutex>
+#include <string>
+
+#include "iremote_object.h"
+#include "refbase.h"
+#include "screenlock_callback_interface.h"
+#include "screenlock_common.h"
+#include "screenlock_manager_interface.h"
+#include "visibility.h"
+
+namespace OHOS {
+namespace ScreenLock {
+class ScreenLockManager : public RefBase {
+public:
+    SCREENLOCK_API static sptr<ScreenLockManager> GetInstance();
+    /**
+     * Lock the screen.
+     *
+     * @param userId Indicates the user ID.
+     * @return Returns E_SCREENLOCK_OK if success; otherwise failed.
+     */
+    SCREENLOCK_API int32_t Lock(int32_t userId);
+
+    /**
+     * Check whether the screen is currently locked.
+     *
+     * @param isLocked Indicates the screen lock state.
+     * @return Returns E_SCREENLOCK_OK if success; otherwise failed.
+     */
+    SCREENLOCK_API int32_t IsLocked(bool &isLocked);
+
+    SCREENLOCK_API bool IsScreenLocked();
+    SCREENLOCK_API bool GetSecure();
+    SCREENLOCK_API int32_t Unlock(Action action, const sptr<ScreenLockCallbackInterface> &listener);
+    int32_t Lock(const sptr<ScreenLockCallbackInterface> &listener);
+};
+} // namespace ScreenLock
+} // namespace OHOS
+#endif // SERVICES_INCLUDE_SCLOCK_SERVICES_MANAGER_H
\ No newline at end of file
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager_interface.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..819e7644b956adf3951cd271505f9beed600426c
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_manager_interface.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SERVICES_INCLUDE_SCLOCK_SERVICE_INTERFACE_H
+#define SERVICES_INCLUDE_SCLOCK_SERVICE_INTERFACE_H
+
+#include <string>
+
+#include "iremote_broker.h"
+#include "screenlock_callback_interface.h"
+#include "screenlock_common.h"
+#include "screenlock_system_ability_interface.h"
+
+namespace OHOS {
+namespace ScreenLock {
+class ScreenLockManagerInterface : public IRemoteBroker {
+public:
+    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.screenlock.ScreenLockManagerInterface");
+    virtual int32_t IsLocked(bool &isLocked) = 0;
+    virtual bool IsScreenLocked() = 0;
+    virtual bool GetSecure() = 0;
+    virtual int32_t Unlock(const sptr<ScreenLockCallbackInterface> &listener) = 0;
+    virtual int32_t UnlockScreen(const sptr<ScreenLockCallbackInterface> &listener) = 0;
+    virtual int32_t Lock(const sptr<ScreenLockCallbackInterface> &listener) = 0;
+    virtual int32_t Lock(int32_t userId) = 0;
+    virtual int32_t OnSystemEvent(const sptr<ScreenLockSystemAbilityInterface> &listener) = 0;
+    virtual int32_t SendScreenLockEvent(const std::string &event, int param) = 0;
+    virtual int32_t IsScreenLockDisabled(int userId, bool &isDisabled) = 0;
+    virtual int32_t SetScreenLockDisabled(bool disable, int userId) = 0;
+    virtual int32_t SetScreenLockAuthState(int authState, int32_t userId, std::string &authToken) = 0;
+    virtual int32_t GetScreenLockAuthState(int userId, int32_t &authState) = 0;
+    virtual int32_t RequestStrongAuth(int reasonFlag, int32_t userId) = 0;
+    virtual int32_t GetStrongAuth(int32_t userId, int32_t &reasonFlag) = 0;
+};
+} // namespace ScreenLock
+} // namespace OHOS
+#endif // SERVICES_INCLUDE_SCLOCK_SERVICE_INTERFACE_H
\ No newline at end of file
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_system_ability_interface.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_system_ability_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..a20bda7564edb5e8ccc8afcb5096d55f248f3d69
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/screenlock_system_ability_interface.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef I_SCREENLOCK_CALLBACK_LISTENER_H
+#define I_SCREENLOCK_CALLBACK_LISTENER_H
+
+#include "iremote_broker.h"
+#include "iremote_object.h"
+
+namespace OHOS {
+namespace ScreenLock {
+struct SystemEvent {
+    std::string eventType_;
+    std::string params_;
+    int32_t userId_;
+    explicit SystemEvent(std::string eventType = "", std::string params = "", int32_t userId = -1)
+        : eventType_(eventType), params_(params), userId_(userId)
+    {}
+};
+
+class ScreenLockSystemAbilityInterface : public IRemoteBroker {
+public:
+    DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.ScreenLock.ScreenLockSystemAbilityInterface");
+    virtual void OnCallBack(const SystemEvent &systemEvent) = 0;
+    enum Message {
+        ON_CALLBACK = 0
+    };
+};
+} // namespace ScreenLock
+} // namespace OHOS
+
+#endif // I_SCREENLOCK_CALLBACK_LISTENER_H
diff --git a/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/visibility.h b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/visibility.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0885e698b5f234d3f00fe41617e63a1c0c64b78
--- /dev/null
+++ b/mock/innerkits/screenlock_mgr/interfaces/inner_api/include/visibility.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OH_SCREENLOCK_API_VISIBILITY_H
+#define OH_SCREENLOCK_API_VISIBILITY_H
+
+#ifndef SCREENLOCK_API
+#define SCREENLOCK_API __attribute__ ((visibility ("default")))
+#endif
+
+#endif // OH_SCREENLOCK_API_VISIBILITY_H
diff --git a/mock/napi/src/js_native_api_types.h b/mock/napi/src/js_native_api_types.h
index b9eddbcba04772f2be61d63981af43087c24d6a7..0c0ac347d92ecb4d15c2405f5434b4f70e0dd620 100644
--- a/mock/napi/src/js_native_api_types.h
+++ b/mock/napi/src/js_native_api_types.h
@@ -4,153 +4,155 @@
 // This file needs to be compatible with C compilers.
 // This is a public include file, and these includes have essentially
 // became part of it's API.
-#include <stddef.h>  // NOLINT(modernize-deprecated-headers)
-#include <stdint.h>  // NOLINT(modernize-deprecated-headers)
+#include <stddef.h> // NOLINT(modernize-deprecated-headers)
+#include <stdint.h> // NOLINT(modernize-deprecated-headers)
 
 #if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)
-    typedef uint16_t char16_t;
+typedef uint16_t char16_t;
 #endif
 
 // JSVM API types are all opaque pointers for ABI stability
 // typedef undefined structs instead of void* for compile time type safety
-typedef struct napi_env__* napi_env;
-typedef struct napi_value__* napi_value;
-typedef struct napi_ref__* napi_ref;
-typedef struct napi_handle_scope__* napi_handle_scope;
-typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope;
-typedef struct napi_callback_info__* napi_callback_info;
-typedef struct napi_deferred__* napi_deferred;
+typedef struct napi_env__ *napi_env;
+typedef struct napi_value__ *napi_value;
+typedef struct napi_ref__ *napi_ref;
+typedef struct napi_handle_scope__ *napi_handle_scope;
+typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
+typedef struct napi_callback_info__ *napi_callback_info;
+typedef struct napi_deferred__ *napi_deferred;
 
 typedef enum {
-  napi_default = 0,
-  napi_writable = 1 << 0,
-  napi_enumerable = 1 << 1,
-  napi_configurable = 1 << 2,
-
-  // Used with napi_define_class to distinguish static properties
-  // from instance properties. Ignored by napi_define_properties.
-  napi_static = 1 << 10,
-
-#ifdef NAPI_EXPERIMENTAL
-  // Default for class methods.
-  napi_default_method = napi_writable | napi_configurable,
-
-  // Default for object properties, like in JS obj[prop].
-  napi_default_jsproperty = napi_writable |
-                            napi_enumerable |
-                            napi_configurable,
-#endif  // NAPI_EXPERIMENTAL
+    napi_default = 0,
+    napi_writable = 1 << 0,
+    napi_enumerable = 1 << 1,
+    napi_configurable = 1 << 2,
+
+    // Used with napi_define_class to distinguish static properties
+    // from instance properties. Ignored by napi_define_properties.
+    napi_static = 1 << 10,
+
+#if NAPI_VERSION >= 8
+    // Default for class methods.
+    napi_default_method = napi_writable | napi_configurable,
+
+    // Default for object properties, like in JS obj[prop].
+    napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable,
+#endif // NAPI_VERSION >= 8
 } napi_property_attributes;
 
 typedef enum {
-  // ES6 types (corresponds to typeof)
-  napi_undefined,
-  napi_null,
-  napi_boolean,
-  napi_number,
-  napi_string,
-  napi_symbol,
-  napi_object,
-  napi_function,
-  napi_external,
-  napi_bigint,
+    // ES6 types (corresponds to typeof)
+    napi_undefined,
+    napi_null,
+    napi_boolean,
+    napi_number,
+    napi_string,
+    napi_symbol,
+    napi_object,
+    napi_function,
+    napi_external,
+    napi_bigint,
 } napi_valuetype;
 
 typedef enum {
-  napi_int8_array,
-  napi_uint8_array,
-  napi_uint8_clamped_array,
-  napi_int16_array,
-  napi_uint16_array,
-  napi_int32_array,
-  napi_uint32_array,
-  napi_float32_array,
-  napi_float64_array,
-  napi_bigint64_array,
-  napi_biguint64_array,
+    napi_int8_array,
+    napi_uint8_array,
+    napi_uint8_clamped_array,
+    napi_int16_array,
+    napi_uint16_array,
+    napi_int32_array,
+    napi_uint32_array,
+    napi_float32_array,
+    napi_float64_array,
+    napi_bigint64_array,
+    napi_biguint64_array,
 } napi_typedarray_type;
 
 typedef enum {
-  napi_ok,
-  napi_invalid_arg,
-  napi_object_expected,
-  napi_string_expected,
-  napi_name_expected,
-  napi_function_expected,
-  napi_number_expected,
-  napi_boolean_expected,
-  napi_array_expected,
-  napi_generic_failure,
-  napi_pending_exception,
-  napi_cancelled,
-  napi_escape_called_twice,
-  napi_handle_scope_mismatch,
-  napi_callback_scope_mismatch,
-  napi_queue_full,
-  napi_closing,
-  napi_bigint_expected,
-  napi_date_expected,
-  napi_arraybuffer_expected,
-  napi_detachable_arraybuffer_expected,
+    napi_ok,
+    napi_invalid_arg,
+    napi_object_expected,
+    napi_string_expected,
+    napi_name_expected,
+    napi_function_expected,
+    napi_number_expected,
+    napi_boolean_expected,
+    napi_array_expected,
+    napi_generic_failure,
+    napi_pending_exception,
+    napi_cancelled,
+    napi_escape_called_twice,
+    napi_handle_scope_mismatch,
+    napi_callback_scope_mismatch,
+    napi_queue_full,
+    napi_closing,
+    napi_bigint_expected,
+    napi_date_expected,
+    napi_arraybuffer_expected,
+    napi_detachable_arraybuffer_expected,
+    napi_would_deadlock, // unused
+    napi_create_ark_runtime_too_many_envs = 22,
+    napi_create_ark_runtime_only_one_env_per_thread = 23,
+    napi_destroy_ark_runtime_env_not_exist = 24
 } napi_status;
 // Note: when adding a new enum value to `napi_status`, please also update
-// `const int last_status` in `napi_get_last_error_info()' definition,
-// in file js_native_api_v8.cc. Please also update the definition of
-// `napi_status` in doc/api/n-api.md to reflect the newly added value(s).
+//   * `const int last_status` in the definition of `napi_get_last_error_info()'
+//     in file js_native_api_v8.cc.
+//   * `const char* error_messages[]` in file js_native_api_v8.cc with a brief
+//     message explaining the error.
+//   * the definition of `napi_status` in doc/api/n-api.md to reflect the newly
+//     added value(s).
 
-typedef napi_value (*napi_callback)(napi_env env,
-                                    napi_callback_info info);
-typedef void (*napi_finalize)(napi_env env,
-                              void* finalize_data,
-                              void* finalize_hint);
+typedef napi_value (*napi_callback)(napi_env env, napi_callback_info info);
+typedef void (*napi_finalize)(napi_env env, void *finalize_data, void *finalize_hint);
 
 typedef struct {
-  // One of utf8name or name should be NULL.
-  const char* utf8name;
-  napi_value name;
+    // One of utf8name or name should be NULL.
+    const char *utf8name;
+    napi_value name;
 
-  napi_callback method;
-  napi_callback getter;
-  napi_callback setter;
-  napi_value value;
+    napi_callback method;
+    napi_callback getter;
+    napi_callback setter;
+    napi_value value;
 
-  napi_property_attributes attributes;
-  void* data;
+    napi_property_attributes attributes;
+    void *data;
 } napi_property_descriptor;
 
 typedef struct {
-  const char* error_message;
-  void* engine_reserved;
-  uint32_t engine_error_code;
-  napi_status error_code;
+    const char *error_message;
+    void *engine_reserved;
+    uint32_t engine_error_code;
+    napi_status error_code;
 } napi_extended_error_info;
 
 #if NAPI_VERSION >= 6
 typedef enum {
-  napi_key_include_prototypes,
-  napi_key_own_only
+    napi_key_include_prototypes,
+    napi_key_own_only
 } napi_key_collection_mode;
 
 typedef enum {
-  napi_key_all_properties = 0,
-  napi_key_writable = 1,
-  napi_key_enumerable = 1 << 1,
-  napi_key_configurable = 1 << 2,
-  napi_key_skip_strings = 1 << 3,
-  napi_key_skip_symbols = 1 << 4
+    napi_key_all_properties = 0,
+    napi_key_writable = 1,
+    napi_key_enumerable = 1 << 1,
+    napi_key_configurable = 1 << 2,
+    napi_key_skip_strings = 1 << 3,
+    napi_key_skip_symbols = 1 << 4
 } napi_key_filter;
 
 typedef enum {
-  napi_key_keep_numbers,
-  napi_key_numbers_to_strings
+    napi_key_keep_numbers,
+    napi_key_numbers_to_strings
 } napi_key_conversion;
-#endif  // NAPI_VERSION >= 6
+#endif // NAPI_VERSION >= 6
 
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION >= 8
 typedef struct {
-  uint64_t lower;
-  uint64_t upper;
+    uint64_t lower;
+    uint64_t upper;
 } napi_type_tag;
-#endif  // NAPI_EXPERIMENTAL
+#endif // NAPI_VERSION >= 8
 
-#endif  // SRC_JS_NATIVE_API_TYPES_H_
+#endif // SRC_JS_NATIVE_API_TYPES_H_
diff --git a/mock/src/mock_device_manager.cpp b/mock/src/mock_device_manager.cpp
index 4296e63a11f50fd6fb5ef248c799c6541882b534..3360ef894e8d5004ca45c1354dac9bb13668ad29 100644
--- a/mock/src/mock_device_manager.cpp
+++ b/mock/src/mock_device_manager.cpp
@@ -187,4 +187,9 @@ int32_t DeviceManagerImpl::GenerateEncryptedUuid(const std::string &pkgName, con
     encryptedUuid = uuid;
     return 0;
 }
+
+bool DeviceManagerImpl::IsSameAccount(const std::string &netWorkId)
+{
+    return false;
+}
 }
\ No newline at end of file
diff --git a/mock/src/mock_image..cpp b/mock/src/mock_image..cpp
index 5fda61b40a44855acde11e84177007bded01c300..4fac1b20e1c90cb4bb553efdbbc82b37731b7d6b 100644
--- a/mock/src/mock_image..cpp
+++ b/mock/src/mock_image..cpp
@@ -12,11 +12,49 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "image_source_native_impl.h"
 #include "pixel_map.h"
 #include "pixel_map_napi.h"
+#include "pixelmap_native_impl.h"
+std::shared_ptr<OHOS::Media::PixelMap> OH_PixelmapNative::GetInnerPixelmap()
+{
+    return std::make_shared<OHOS::Media::PixelMap>();
+}
+OH_PixelmapNative::OH_PixelmapNative(std::shared_ptr<OHOS::Media::PixelMap> pixelMap) {}
+OH_PixelmapNative::OH_PixelmapNative(const uint32_t *colors, uint32_t colorLength,
+    const OHOS::Media::InitializationOptions &opts)
+{
+}
+OH_PixelmapNative::OH_PixelmapNative(const OHOS::Media::InitializationOptions &opts) {}
+OH_PixelmapNative::OH_PixelmapNative(OH_PixelmapNative *OH_PixelmapNative,
+    const OHOS::Media::InitializationOptions &opts)
+{
+}
+OH_PixelmapNative::~OH_PixelmapNative() {}
+
+std::shared_ptr<OHOS::Media::ImageSource> OH_ImageSourceNative::GetInnerImageSource()
+{
+    return nullptr;
+}
+OH_ImageSourceNative::OH_ImageSourceNative(std::shared_ptr<OHOS::Media::ImageSource> imageSource) {}
+OH_ImageSourceNative::OH_ImageSourceNative(char *uri, size_t size, OHOS::Media::SourceOptions ops) {}
+OH_ImageSourceNative::OH_ImageSourceNative(int32_t fd, OHOS::Media::SourceOptions ops) {}
+OH_ImageSourceNative::OH_ImageSourceNative(uint8_t *data, size_t dataSize, OHOS::Media::SourceOptions ops) {}
+OH_ImageSourceNative::~OH_ImageSourceNative() {}
+std::string OH_ImageSourceNative::UrlToPath(const std::string &path)
+{
+    return std::string();
+}
+
 namespace OHOS::Media {
-std::shared_ptr<PixelMap> PixelMapNapi::GetPixelMap(napi_env env, napi_value pixelmap) { return nullptr; }
-napi_value PixelMapNapi::CreatePixelMap(napi_env env, std::shared_ptr<PixelMap> pixelmap) { return nullptr; }
+std::shared_ptr<PixelMap> PixelMapNapi::GetPixelMap(napi_env env, napi_value pixelmap)
+{
+    return nullptr;
+}
+napi_value PixelMapNapi::CreatePixelMap(napi_env env, std::shared_ptr<PixelMap> pixelmap)
+{
+    return nullptr;
+}
 bool PixelMap::Marshalling(Parcel &data) const
 {
     data.WriteInt32(imageInfo_.size.width);
@@ -93,9 +131,7 @@ bool PixelMap::GetARGB32Color(int32_t x, int32_t y, uint32_t &color)
 {
     return false;
 }
-void PixelMap::SetPixelsAddr(void *addr, void *context, uint32_t size, AllocatorType type, CustomFreePixelMap func)
-{
-}
+void PixelMap::SetPixelsAddr(void *addr, void *context, uint32_t size, AllocatorType type, CustomFreePixelMap func) {}
 int32_t PixelMap::GetPixelBytes()
 {
     return 0;
@@ -120,18 +156,10 @@ int32_t PixelMap::GetBaseDensity()
 {
     return 0;
 }
-void PixelMap::scale(float xAxis, float yAxis)
-{
-}
-void PixelMap::translate(float xAxis, float yAxis)
-{
-}
-void PixelMap::rotate(float degrees)
-{
-}
-void PixelMap::flip(bool xAxis, bool yAxis)
-{
-}
+void PixelMap::scale(float xAxis, float yAxis) {}
+void PixelMap::translate(float xAxis, float yAxis) {}
+void PixelMap::rotate(float degrees) {}
+void PixelMap::flip(bool xAxis, bool yAxis) {}
 uint32_t PixelMap::crop(const Rect &rect)
 {
     return 0;
@@ -218,9 +246,7 @@ bool PixelMap::WritePixels(const uint32_t &color)
 {
     return false;
 }
-void PixelMap::FreePixelMap()
-{
-}
+void PixelMap::FreePixelMap() {}
 AllocatorType PixelMap::GetAllocatorType()
 {
     return AllocatorType::DEFAULT;
@@ -229,4 +255,12 @@ void *PixelMap::GetFd() const
 {
     return nullptr;
 }
-}
\ No newline at end of file
+bool PixelMap::EncodeTlv(std::vector<uint8_t> &buff) const
+{
+    return false;
+}
+PixelMap *PixelMap::DecodeTlv(std::vector<uint8_t> &buff)
+{
+    return nullptr;
+}
+} // namespace OHOS::Media
\ No newline at end of file
diff --git a/mock/src/mock_js_napi.cpp b/mock/src/mock_js_napi.cpp
index 2f61bcdba183aecab0b564f39b2954b684ce7ed7..6fb33ee3a94010455799104721830ca6afbfdabb 100644
--- a/mock/src/mock_js_napi.cpp
+++ b/mock/src/mock_js_napi.cpp
@@ -12,13 +12,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <libuv/include/uv.h>
+
+#include "js_native_api.h"
 #include "napi/native_api.h"
 #include "napi/native_common.h"
 #include "napi/native_node_api.h"
-#include "js_native_api.h"
-
-#include <libuv/include/uv.h>
 extern "C" {
+napi_status napi_create_object_with_properties(napi_env env, napi_value *result, size_t property_count,
+    const napi_property_descriptor *properties)
+{
+    return napi_ok;
+}
+
 napi_status napi_get_named_property(napi_env env, napi_value object, const char *utf8name, napi_value *result)
 {
     return napi_ok;
@@ -33,70 +39,202 @@ napi_status napi_get_cb_info(napi_env env, napi_callback_info cbinfo, size_t *ar
 {
     return napi_ok;
 }
-napi_status napi_get_global(napi_env env, napi_value *result) { return napi_ok; }
+napi_status napi_get_global(napi_env env, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_get_value_string_utf8(napi_env env, napi_value value, char *buf, size_t bufsize, size_t *result)
 {
     return napi_ok;
 }
-napi_status napi_get_array_length(napi_env env, napi_value value, uint32_t *result) { return napi_ok; }
-napi_status napi_is_typedarray(napi_env env, napi_value value, bool *result) { return napi_ok; }
+napi_status napi_get_array_length(napi_env env, napi_value value, uint32_t *result)
+{
+    return napi_ok;
+}
+napi_status napi_is_typedarray(napi_env env, napi_value value, bool *result)
+{
+    return napi_ok;
+}
 napi_status napi_get_typedarray_info(napi_env env, napi_value typedarray, napi_typedarray_type *type, size_t *length,
-    void **data, napi_value *arraybuffer, size_t *byte_offset) { return napi_ok; }
-napi_status napi_get_element(napi_env env, napi_value object, uint32_t index, napi_value *result) { return napi_ok; }
-napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype *result) { return napi_ok; }
-napi_status napi_get_value_bool(napi_env env, napi_value value, bool *result) { return napi_ok; }
-napi_status napi_set_element(napi_env env, napi_value object, uint32_t index, napi_value value) { return napi_ok; }
-napi_status napi_get_last_error_info(napi_env env, const napi_extended_error_info **result) { return napi_ok; }
-napi_status napi_is_exception_pending(napi_env env, bool *result) { return napi_ok; }
-napi_status napi_throw_error(napi_env env, const char *code, const char *msg) { return napi_ok; }
-napi_status napi_get_value_double(napi_env env, napi_value value, double *result) { return napi_ok; }
-napi_status napi_create_array_with_length(napi_env env, size_t length, napi_value *result) { return napi_ok; }
-napi_status napi_create_string_utf8(napi_env env, const char *str, size_t length,
-    napi_value *result) { return napi_ok; }
-napi_status napi_create_arraybuffer(napi_env env, size_t byte_length, void **data,
-    napi_value *result) { return napi_ok; }
+    void **data, napi_value *arraybuffer, size_t *byte_offset)
+{
+    return napi_ok;
+}
+napi_status napi_get_element(napi_env env, napi_value object, uint32_t index, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_value_bool(napi_env env, napi_value value, bool *result)
+{
+    return napi_ok;
+}
+napi_status napi_set_element(napi_env env, napi_value object, uint32_t index, napi_value value)
+{
+    return napi_ok;
+}
+napi_status napi_get_last_error_info(napi_env env, const napi_extended_error_info **result)
+{
+    return napi_ok;
+}
+napi_status napi_is_exception_pending(napi_env env, bool *result)
+{
+    return napi_ok;
+}
+napi_status napi_throw_error(napi_env env, const char *code, const char *msg)
+{
+    return napi_ok;
+}
+napi_status napi_get_value_double(napi_env env, napi_value value, double *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_array_with_length(napi_env env, size_t length, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_string_utf8(napi_env env, const char *str, size_t length, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_arraybuffer(napi_env env, size_t byte_length, void **data, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_create_typedarray(napi_env env, napi_typedarray_type type, size_t length, napi_value arraybuffer,
-    size_t byte_offset, napi_value *result) { return napi_ok; }
-napi_status napi_create_int32(napi_env env, int32_t value, napi_value *result) { return napi_ok; }
-napi_status napi_create_int64(napi_env env, int64_t value, napi_value *result) { return napi_ok; }
-napi_status napi_create_double(napi_env env, double value, napi_value *result) { return napi_ok; }
-napi_status napi_create_date(napi_env env, double value, napi_value *result) { return napi_ok; }
-napi_status napi_get_boolean(napi_env env, bool value, napi_value *result) { return napi_ok; }
+    size_t byte_offset, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_int32(napi_env env, int32_t value, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_int64(napi_env env, int64_t value, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_double(napi_env env, double value, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_create_date(napi_env env, double value, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_boolean(napi_env env, bool value, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_define_class(napi_env env, const char *utf8name, size_t length, napi_callback constructor,
-    void *callback_data, size_t property_count, const napi_property_descriptor *properties,
-    napi_value *result) { return napi_ok; }
-napi_status napi_unwrap(napi_env env, napi_value obj, void **result) { return napi_ok; }
-napi_status napi_delete_reference(napi_env env, napi_ref ref) { return napi_ok; }
-napi_status napi_create_reference(napi_env env, napi_value value, uint32_t initial_refcount,
-    napi_ref *result) { return napi_ok; }
+    void *callback_data, size_t property_count, const napi_property_descriptor *properties, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_unwrap(napi_env env, napi_value obj, void **result)
+{
+    return napi_ok;
+}
+napi_status napi_delete_reference(napi_env env, napi_ref ref)
+{
+    return napi_ok;
+}
+napi_status napi_create_reference(napi_env env, napi_value value, uint32_t initial_refcount, napi_ref *result)
+{
+    return napi_ok;
+}
 napi_status napi_wrap(napi_env env, napi_value js_object, void *native_object, napi_finalize finalize_cb,
-    void *finalize_hint, napi_ref *result) { return napi_ok; }
-napi_status napi_get_undefined(napi_env env, napi_value* result) { return napi_ok; }
+    void *finalize_hint, napi_ref *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_undefined(napi_env env, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_create_async_work(napi_env env, napi_value async_resource, napi_value async_resource_name,
-    napi_async_execute_callback execute, napi_async_complete_callback complete, void *data,
-    napi_async_work *result) { return napi_ok; }
-napi_status napi_set_named_property(napi_env env, napi_value object, const char *utf8name,
-    napi_value value) { return napi_ok; }
-napi_status napi_get_new_target(napi_env env, napi_callback_info cbinfo, napi_value *result) { return napi_ok; }
-napi_status napi_get_reference_value(napi_env env, napi_ref ref, napi_value *result) { return napi_ok; }
+    napi_async_execute_callback execute, napi_async_complete_callback complete, void *data, napi_async_work *result)
+{
+    return napi_ok;
+}
+napi_status napi_set_named_property(napi_env env, napi_value object, const char *utf8name, napi_value value)
+{
+    return napi_ok;
+}
+napi_status napi_get_new_target(napi_env env, napi_callback_info cbinfo, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_reference_value(napi_env env, napi_ref ref, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_new_instance(napi_env env, napi_value constructor, size_t argc, const napi_value *argv,
-    napi_value *result) { return napi_ok; }
-napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t *result) { return napi_ok; }
-napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) { return napi_ok; }
-napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) { return napi_ok; }
-napi_status napi_get_property_names(napi_env env, napi_value object, napi_value *result) { return napi_ok; }
-napi_status napi_get_property(napi_env env, napi_value object, napi_value key, napi_value *result) { return napi_ok; }
-napi_status napi_delete_async_work(napi_env env, napi_async_work work) { return napi_ok; }
-napi_status napi_create_error(napi_env env, napi_value code, napi_value msg, napi_value *result) { return napi_ok; }
-napi_status napi_resolve_deferred(napi_env env, napi_deferred deferred, napi_value resolution) { return napi_ok; }
-napi_status napi_reject_deferred(napi_env env, napi_deferred deferred, napi_value resolution) { return napi_ok; }
-napi_status napi_queue_async_work(napi_env env, napi_async_work work) { return napi_ok; }
-napi_status napi_queue_async_work_with_qos(napi_env env, napi_async_work work, napi_qos_t qos) {return napi_ok;}
-napi_status napi_create_promise(napi_env env, napi_deferred *deferred, napi_value *promise) { return napi_ok; }
-napi_status napi_create_object(napi_env env, napi_value* result) { return napi_ok; }
+    napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_value_int32(napi_env env, napi_value value, int32_t *result)
+{
+    return napi_ok;
+}
+napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t *result)
+{
+    return napi_ok;
+}
+napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_property_names(napi_env env, napi_value object, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_get_property(napi_env env, napi_value object, napi_value key, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_delete_async_work(napi_env env, napi_async_work work)
+{
+    return napi_ok;
+}
+napi_status napi_create_error(napi_env env, napi_value code, napi_value msg, napi_value *result)
+{
+    return napi_ok;
+}
+napi_status napi_resolve_deferred(napi_env env, napi_deferred deferred, napi_value resolution)
+{
+    return napi_ok;
+}
+napi_status napi_reject_deferred(napi_env env, napi_deferred deferred, napi_value resolution)
+{
+    return napi_ok;
+}
+napi_status napi_queue_async_work(napi_env env, napi_async_work work)
+{
+    return napi_ok;
+}
+napi_status napi_queue_async_work_with_qos(napi_env env, napi_async_work work, napi_qos_t qos)
+{
+    return napi_ok;
+}
+napi_status napi_create_promise(napi_env env, napi_deferred *deferred, napi_value *promise)
+{
+    return napi_ok;
+}
+napi_status napi_create_object(napi_env env, napi_value *result)
+{
+    return napi_ok;
+}
 napi_status napi_define_properties(napi_env env, napi_value object, size_t property_count,
-    const napi_property_descriptor *properties) { return napi_ok; }
-void napi_module_register(napi_module* mod) { }
+    const napi_property_descriptor *properties)
+{
+    return napi_ok;
+}
+void napi_module_register(napi_module *mod) {}
 
 napi_status napi_async_init(napi_env env, napi_value async_resource, napi_value async_resource_name,
     napi_async_context *result)
@@ -356,51 +494,379 @@ napi_status napi_adjust_external_memory(napi_env env, int64_t change_in_bytes, i
     return napi_escape_called_twice;
 }
 
+UV_EXTERN int uv_queue_work(uv_loop_t *loop, uv_work_t *req, uv_work_cb work_cb, uv_after_work_cb after_work_cb)
+{
+    return 0;
+}
+UV_EXTERN int uv_queue_work_with_qos(uv_loop_t *loop, uv_work_t *req, uv_work_cb work_cb,
+    uv_after_work_cb after_work_cb, int num)
+{
+    return 0;
+}
 
-UV_EXTERN int uv_queue_work(uv_loop_t* loop,
-    uv_work_t* req,
-    uv_work_cb work_cb,
-    uv_after_work_cb after_work_cb) { return 0; }
-UV_EXTERN int uv_queue_work_with_qos(uv_loop_t* loop,
-    uv_work_t* req,
-    uv_work_cb work_cb,
-    uv_after_work_cb after_work_cb,
-    int num) { return 0; }
-
-NAPI_EXTERN napi_status napi_object_freeze(napi_env env,
-    napi_value object)
+NAPI_EXTERN napi_status napi_object_freeze(napi_env env, napi_value object)
 {
     return napi_ok;
 }
-int uv_cancel(uv_req_t* req)
+int uv_cancel(uv_req_t *req)
 {
     return napi_ok;
 }
-NAPI_EXTERN napi_status napi_get_all_property_names(napi_env env,
-    napi_value object,
-    napi_key_collection_mode key_mode,
-    napi_key_filter key_filter,
-    napi_key_conversion key_conversion,
-    napi_value* result)
+NAPI_EXTERN napi_status napi_get_all_property_names(napi_env env, napi_value object, napi_key_collection_mode key_mode,
+    napi_key_filter key_filter, napi_key_conversion key_conversion, napi_value *result)
 {
     return napi_ok;
 }
 
-napi_status napi_add_finalizer(napi_env env, napi_value js_object, void* native_object, napi_finalize finalize_cb,
-                               void* finalize_hint, napi_ref* result)
+napi_status napi_add_finalizer(napi_env env, napi_value js_object, void *native_object, napi_finalize finalize_cb,
+    void *finalize_hint, napi_ref *result)
 {
     return napi_ok;
 }
 
-NAPI_EXTERN napi_status napi_create_bigint_words(napi_env env, int sign_bit, size_t word_count, const uint64_t* words,
-                                     napi_value* result)
+NAPI_EXTERN napi_status napi_create_bigint_words(napi_env env, int sign_bit, size_t word_count, const uint64_t *words,
+    napi_value *result)
 {
     return napi_ok;
 }
 
-NAPI_EXTERN napi_status napi_get_value_bigint_words(napi_env env, napi_value value, int* sign_bit, size_t* word_count,
-    uint64_t* words)
+NAPI_EXTERN napi_status napi_get_value_bigint_words(napi_env env, napi_value value, int *sign_bit, size_t *word_count,
+    uint64_t *words)
+{
+    return napi_ok;
+}
+}
+napi_status napi_is_sendable(napi_env env, napi_value value, bool *result)
+{
+    return napi_ok;
+}
+napi_status napi_is_map(napi_env env, napi_value value, bool *result)
 {
     return napi_ok;
 }
-}
\ No newline at end of file
+napi_status napi_is_callable(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_runtime(napi_env env, napi_env *result_env)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_serialize(napi_env env, napi_value object, napi_value transfer_list, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_deserialize(napi_env env, napi_value recorder, napi_value *object)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_delete_serialization_data(napi_env env, napi_value value)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_get_exception_info_for_worker(napi_env env, napi_value obj)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_run_buffer_script(napi_env env, std::vector<uint8_t> &buffer, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_run_actor(napi_env env, std::vector<uint8_t> &buffer, const char *descriptor, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_set_promise_rejection_callback(napi_env env, napi_ref ref, napi_ref checkRef)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_arguments_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_async_function(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_boolean_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_generator_function(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_date(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_map_iterator(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_set_iterator(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_generator_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_module_namespace_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_proxy(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_reg_exp(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_number_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_set(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_string_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_symbol_object(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_weak_map(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_weak_set(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_sendable_typedarray(napi_env env,
+    napi_typedarray_type type,
+    size_t length,
+    napi_value arraybuffer,
+    size_t byte_offset,
+    napi_value* result)
+{
+    return napi_ok;
+}
+
+napi_status napi_map_get_size(napi_env env, napi_value map, uint32_t* result)
+{
+    return napi_ok;
+}
+napi_status napi_create_sendable_array_with_length(napi_env env, size_t length, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_fatal_exception(napi_env env, napi_value err)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_type_tag_object(napi_env env, napi_value value, const napi_type_tag *type_tag)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_check_object_type_tag(napi_env env, napi_value value, const napi_type_tag *type_tag, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_run_script_path(napi_env env, const char *path, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_load_module(napi_env env, const char *path, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_load_module_with_info(napi_env env, const char *path, const char *module_info, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_get_instance_data(napi_env env, void **data)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_set_instance_data(napi_env env, void *data, napi_finalize finalize_cb, void *finalize_hint)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_remove_env_cleanup_hook(napi_env env, void (*fun)(void *), void *arg)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_add_env_cleanup_hook(napi_env env, void (*fun)(void *), void *arg)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_add_async_cleanup_hook(napi_env env, napi_async_cleanup_hook hook, void *arg,
+    napi_async_cleanup_hook_handle *remove_handle)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_close_callback_scope(napi_env env, napi_callback_scope scope)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_open_callback_scope(napi_env env, napi_value resource_object, napi_async_context context,
+    napi_callback_scope *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status node_api_get_module_file_name(napi_env env, const char **result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_object_with_named_properties(napi_env env, napi_value *result, size_t property_count,
+    const char **keys, const napi_value *values)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_coerce_to_native_binding_object(napi_env env, napi_value js_object,
+    napi_native_binding_detach_callback detach_cb, napi_native_binding_attach_callback attach_cb, void *native_object,
+    void *hint)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_run_event_loop(napi_env env, napi_event_mode mode)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_stop_event_loop(napi_env env)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_ark_runtime(napi_env *env)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_destroy_ark_runtime(napi_env *env)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_serialize(napi_env env, napi_value object, napi_value transfer_list, napi_value clone_list,
+    void **result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_deserialize(napi_env env, void *buffer, napi_value *object)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_delete_serialization_data(napi_env env, void *buffer)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_is_concurrent_function(napi_env env, napi_value value, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_call_threadsafe_function_with_priority(napi_threadsafe_function func, void *data,
+    napi_task_priority priority, bool isTail)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_map(napi_env env, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_set_property(napi_env env, napi_value map, napi_value key, napi_value value)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_set_named_property(napi_env env, napi_value map, const char *utf8name, napi_value value)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_get_property(napi_env env, napi_value map, napi_value key, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_get_named_property(napi_env env, napi_value map, const char *utf8name, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_has_property(napi_env env, napi_value map, napi_value key, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_has_named_property(napi_env env, napi_value map, const char *utf8name, bool *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_delete_property(napi_env env, napi_value map, napi_value key)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_clear(napi_env env, napi_value map)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_get_entries(napi_env env, napi_value map, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_get_keys(napi_env env, napi_value map, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_get_values(napi_env env, napi_value map, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_map_iterator_get_next(napi_env env, napi_value iterator, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_define_sendable_class(napi_env env, const char *utf8name, size_t length, napi_callback constructor,
+    void *data, size_t property_count, const napi_property_descriptor *properties, napi_value parent,
+    napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_sendable_object_with_properties(napi_env env, size_t property_count,
+    const napi_property_descriptor *properties, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_sendable_array(napi_env env, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_sendable_arraybuffer(napi_env env, size_t byte_length, void **data, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_create_sendable_map(napi_env env, napi_value *result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_wrap_sendable(napi_env env, napi_value js_object, void *native_object, napi_finalize finalize_cb,
+    void *finalize_hint)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_wrap_sendable_with_size(napi_env env, napi_value js_object, void *native_object,
+    napi_finalize finalize_cb, void *finalize_hint, size_t native_binding_size)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_unwrap_sendable(napi_env env, napi_value js_object, void **result)
+{
+    return napi_escape_called_twice;
+}
+napi_status napi_remove_wrap_sendable(napi_env env, napi_value js_object, void **result)
+{
+    return napi_escape_called_twice;
+}
diff --git a/mock/src/mock_mem_mgr.cpp b/mock/src/mock_mem_mgr.cpp
index 0afd6acfed59df414e8d6c78b139bb6d634c3b14..21dc0e945477b29573db69378d1e44ed6458c22b 100644
--- a/mock/src/mock_mem_mgr.cpp
+++ b/mock/src/mock_mem_mgr.cpp
@@ -36,7 +36,8 @@ BundlePriorityList *BundlePriorityList::Unmarshalling(Parcel &parcel)
 void BundlePriorityList::SetCount(int32_t count) {}
 const std::vector<BundlePriority> &BundlePriorityList::GetList()
 {
-    return {};
+    static std::vector<BundlePriority> LIST = {};
+    return LIST;
 }
 int32_t BundlePriorityList::Size() const
 {
diff --git a/mock/src/mock_notification.cpp b/mock/src/mock_notification.cpp
index 3d70b809ea7b8a2aa63b4dd7d81aa2c6179df697..30d46db003b7bbc6a134646d914911c4545d8711 100644
--- a/mock/src/mock_notification.cpp
+++ b/mock/src/mock_notification.cpp
@@ -33,12 +33,71 @@ bool WantParams::Marshalling(OHOS::Parcel &parcel) const
 {
     return true;
 }
+
 const std::map<std::string, sptr<IInterface>> &WantParams::GetParams() const { return params_; }
 WantParams &WantParams::operator=(const WantParams &other)
 {
     params_ = other.params_;
     return *this;
 }
+bool WantParams::operator==(const WantParams &other)
+{
+    return false;
+}
+sptr<IInterface> WantParams::GetInterfaceByType(int typeId, const std::string &value)
+{
+    return sptr<IInterface>();
+}
+bool WantParams::CompareInterface(const sptr<IInterface> iIt1, const sptr<IInterface> iIt2, int typeId)
+{
+    return false;
+}
+int WantParams::GetDataType(const sptr<IInterface> iIt)
+{
+    return 0;
+}
+std::string WantParams::GetStringByType(const sptr<IInterface> iIt, int typeId)
+{
+    return std::string();
+}
+sptr<IInterface> WantParams::GetParam(const std::string &key) const
+{
+    return sptr<IInterface>();
+}
+WantParams WantParams::GetWantParams(const std::string &key) const
+{
+    return WantParams();
+}
+std::string WantParams::GetStringParam(const std::string &key) const
+{
+    return std::string();
+}
+int WantParams::GetIntParam(const std::string &key, const int defaultValue) const
+{
+    return 0;
+}
+const std::set<std::string> WantParams::KeySet() const
+{
+    return std::set<std::string>();
+}
+void WantParams::Remove(const std::string &key) {}
+bool WantParams::HasParam(const std::string &key) const
+{
+    return false;
+}
+int WantParams::Size() const
+{
+    return 0;
+}
+bool WantParams::IsEmpty() const
+{
+    return false;
+}
+WantParams *WantParams::Unmarshalling(Parcel &parcel)
+{
+    return nullptr;
+}
+void WantParams::DumpInfo(int level) const {}
 
 Want::Want() {}
 Want::Want(OHOS::AAFwk::Want const &ref):params_(ref.params_) {}
@@ -271,6 +330,36 @@ CommonEventPublishInfo::CommonEventPublishInfo() {}
 CommonEventPublishInfo::CommonEventPublishInfo(const CommonEventPublishInfo &commonEventPublishInfo) {}
 CommonEventPublishInfo::~CommonEventPublishInfo() {}
 bool CommonEventPublishInfo::Marshalling(Parcel &parcel) const { return false;}
+void CommonEventPublishInfo::SetSticky(bool sticky) {}
+bool CommonEventPublishInfo::IsSticky() const
+{
+    return false;
+}
+void CommonEventPublishInfo::SetSubscriberPermissions(const std::vector<std::string> &subscriberPermissions) {}
+const std::vector<std::string> &CommonEventPublishInfo::GetSubscriberPermissions() const
+{
+    return {};
+}
+void CommonEventPublishInfo::SetOrdered(bool ordered) {}
+bool CommonEventPublishInfo::IsOrdered() const
+{
+    return false;
+}
+void CommonEventPublishInfo::SetBundleName(const std::string &bundleName) {}
+void CommonEventPublishInfo::SetSubscriberUid(const std::vector<int32_t> &subscriberUids) {}
+std::vector<int32_t> CommonEventPublishInfo::GetSubscriberUid() const
+{
+    return std::vector<int32_t>();
+}
+void CommonEventPublishInfo::SetSubscriberType(const int32_t &subscriberType) {}
+int32_t CommonEventPublishInfo::GetSubscriberType() const
+{
+    return 0;
+}
+std::string CommonEventPublishInfo::GetBundleName() const
+{
+    return std::string();
+}
 }
 
 Uri::Uri(std::string const &uri) : uriString_(uri) {}
diff --git a/mock/src/mock_screenlock_mgr.cpp b/mock/src/mock_screenlock_mgr.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66335173bbe26f50607e8fa4b7c31f93de0074c5
--- /dev/null
+++ b/mock/src/mock_screenlock_mgr.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "screenlock_manager.h"
+
+namespace OHOS::ScreenLock {
+sptr<ScreenLockManager> ScreenLockManager::GetInstance()
+{
+    static sptr<ScreenLockManager> instance = new ScreenLockManager;
+    return instance;
+}
+
+int32_t ScreenLockManager::Lock(int32_t userId)
+{
+    return 0;
+}
+int32_t ScreenLockManager::IsLocked(bool &isLocked)
+{
+    return 0;
+}
+bool ScreenLockManager::IsScreenLocked()
+{
+    return false;
+}
+bool ScreenLockManager::GetSecure()
+{
+    return false;
+}
+int32_t ScreenLockManager::Unlock(Action action, const sptr<ScreenLockCallbackInterface> &listener)
+{
+    return 0;
+}
+int32_t ScreenLockManager::Lock(const sptr<ScreenLockCallbackInterface> &listener)
+{
+    return 0;
+}
+} // namespace OHOS::ScreenLock
\ No newline at end of file
diff --git a/preferences/OAT.xml b/preferences/OAT.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a3830f9a3372d145c1b9e517155e404360f204f6
--- /dev/null
+++ b/preferences/OAT.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+
+-->
+<!-- OAT(OSS Audit Tool) configuration guide:
+basedir: Root dir, the basedir + project path is the real source file location.
+licensefile:
+1.If the project don't have "LICENSE" in root dir, please define all the license files in this project in , OAT will check license files according to this rule.
+
+tasklist(only for batch mode):
+1. task: Define oat check thread, each task will start a new thread.
+2. task name: Only an name, no practical effect.
+3. task policy: Default policy for projects under this task, this field is required and the specified policy must defined in policylist.
+4. task filter: Default filefilter for projects under this task, this field is required and the specified filefilter must defined in filefilterlist.
+5. task project: Projects to be checked, the path field define the source root dir of the project.
+
+
+policyList:
+1. policy: All policyitems will be merged to default OAT.xml rules, the name of policy doesn't affect OAT check process.
+2. policyitem: The fields type, name, path, desc is required, and the fields rule, group, filefilter is optional,the default value is:
+<policyitem type="" name="" path="" desc="" rule="may" group="defaultGroup" filefilter="defaultPolicyFilter"/>
+3. policyitem type:
+    "compatibility" is used to check license compatibility in the specified path;
+    "license" is used to check source license header in the specified path;
+    "copyright" is used to check source copyright header in the specified path;
+    "import" is used to check source dependency in the specified path, such as import ... ,include ...
+    "filetype" is used to check file type in the specified path, supported file types: archive, binary
+    "filename" is used to check whether the specified file exists in the specified path(support projectroot in default OAT.xml), supported file names: LICENSE, README, README.OpenSource
+
+4. policyitem name: This field is used for define the license, copyright, "*" means match all, the "!" prefix means could not match this value. For example, "!GPL" means can not use GPL license.
+5. policyitem path: This field is used for define the source file scope to apply this policyitem, the "!" prefix means exclude the files. For example, "!.*/lib/.*" means files in lib dir will be exclude while process this policyitem.
+6. policyitem rule and group: These two fields are used together to merge policy results. "may" policyitems in the same group means any one in this group passed, the result will be passed.
+7. policyitem filefilter: Used to bind filefilter which define filter rules.
+8. filefilter: Filter rules, the type filename is used to filter file name, the type filepath is used to filter file path.
+
+Note:If the text contains special characters, please escape them according to the following rules:
+" == &gt;
+& == &gt;
+' == &gt;
+< == &gt;
+> == &gt;
+-->
+<configuration>
+    <oatconfig>
+        <licensefile>LICENSE</licensefile>
+        <filefilterlist>
+            <filefilter name="binaryFileTypePolicyFilter" desc="Filters for binary file policies">
+                <filteritem type="filepath" name="test/js/unittest/stage_unittest/preferences/src/entry/src/main/resources/base/media/icon.png" desc="png for unittest"/>
+                <filteritem type="filepath" name="figures/zh-cn_首选项运行机制.png" desc="png for readme_zh"/>
+                <filteritem type="filepath" name="figures/en-us_How_the_preferences_database_works.png" desc="png for readme"/>
+            </filefilter>
+        </filefilterlist>
+    </oatconfig>
+</configuration>
\ No newline at end of file
diff --git a/preferences/bundle.json b/preferences/bundle.json
index 3739d88e7fd9d049a4d3431f57448395ef11e086..db254b99c168c2287e163b00a58875a7edfce4d3 100644
--- a/preferences/bundle.json
+++ b/preferences/bundle.json
@@ -50,19 +50,23 @@
         "deps": {
             "components": [
                 "ability_runtime",
+                "access_token",
                 "napi",
                 "hilog",
                 "c_utils",
                 "ability_base",
                 "common_event_service",
+                "hisysevent",
                 "hitrace",
                 "ipc",
+                "bounds_checking_function",
                 "libxml2"
             ]
         },
         "build": {
             "sub_component": [
                 "//foundation/distributeddatamgr/preferences/interfaces/inner_api:native_preferences",
+                "//foundation/distributeddatamgr/preferences/interfaces/ndk:ohpreferences",
                 "//foundation/distributeddatamgr/preferences/frameworks/cj:cj_preferences_ffi",
                 "//foundation/distributeddatamgr/preferences/frameworks/js/napi/common:preferences_jscommon",
                 "//foundation/distributeddatamgr/preferences/frameworks/js/napi/preferences:preferences",
@@ -83,6 +87,18 @@
                         ],
                         "header_base": "//foundation/distributeddatamgr/preferences/interfaces/inner_api/include"
                     }
+                },
+                {
+                    "name": "//foundation/distributeddatamgr/preferences/interfaces/ndk:ohpreferences",
+                    "header": {
+                        "header_files": [
+                            "oh_preferences.h",
+                            "oh_preferences_value.h",
+                            "oh_preferences_option.h",
+                            "oh_preferences_value.h"
+                        ],
+                        "header_base": "//foundation/distributeddatamgr/preferences/interfaces/ndk/include"
+                    }
                 }
             ],
             "test": [
diff --git a/preferences/frameworks/cj/src/preferences_ffi.cpp b/preferences/frameworks/cj/src/preferences_ffi.cpp
index 45040af12dec398e45ec1df6e5a9200af25f5d4c..526c7003da02acbaec498e8fea45d8801227bc31 100644
--- a/preferences/frameworks/cj/src/preferences_ffi.cpp
+++ b/preferences/frameworks/cj/src/preferences_ffi.cpp
@@ -32,6 +32,9 @@ int64_t FfiOHOSPreferencesGetPreferences(OHOS::AbilityRuntime::Context* context,
     const char* dataGroupId, int32_t* errCode)
 {
     auto nativePreferences = FFIData::Create<PreferencesImpl>(context, name, dataGroupId, errCode);
+    if (!nativePreferences) {
+        return 0;
+    }
     return nativePreferences->GetID();
 }
 
@@ -119,8 +122,7 @@ int32_t FfiOHOSPreferencesDelete(int64_t id, const char* key)
     return instance->Delete(key);
 }
     
-int32_t FfiOHOSPreferencesOn(int64_t id, const char* mode,
-    void (*callback)(const char* value), void (*callbackRef)(const char* valueRef))
+int32_t FfiOHOSPreferencesOn(int64_t id, const char* mode, void (*callbackRef)(const char* valueRef))
 {
     auto instance = FFIData::GetData<PreferencesImpl>(id);
     if (!instance) {
@@ -129,18 +131,17 @@ int32_t FfiOHOSPreferencesOn(int64_t id, const char* mode,
     }
     auto onChange = [lambda = CJLambda::Create(callbackRef)](const std::string& valueRef) ->
         void { lambda(valueRef.c_str()); };
-    return instance->RegisterObserver(mode, (std::function<void(std::string)>*)(callback), onChange);
+    return instance->RegisterObserver(mode, (std::function<void(std::string)>*)(callbackRef), onChange);
 }
 
-int32_t FfiOHOSPreferencesOff(int64_t id, const char* mode, void (*callback)(const char* value))
+int32_t FfiOHOSPreferencesOff(int64_t id, const char* mode, void (*callbackRef)(const char* value))
 {
     auto instance = FFIData::GetData<PreferencesImpl>(id);
     if (!instance) {
         LOGE("[Preferences] instance not exist. %{public}" PRId64, id);
         return ERR_INVALID_INSTANCE_CODE;
     }
-    auto onChange = [lambda = CJLambda::Create(callback)](const std::string& value) -> void { lambda(value.c_str()); };
-    return instance->UnRegisterObserver(mode, (std::function<void(std::string)>*)(callback));
+    return instance->UnRegisterObserver(mode, (std::function<void(std::string)>*)(callbackRef));
 }
 
 int32_t FfiOHOSPreferencesOffAll(int64_t id, const char* mode)
diff --git a/preferences/frameworks/cj/src/preferences_ffi.h b/preferences/frameworks/cj/src/preferences_ffi.h
index a669808a9de2f5c3285088b30ec7f77bd17e74f7..6f82829871a9a65d6d651a63c3d26e26ecc0dc70 100644
--- a/preferences/frameworks/cj/src/preferences_ffi.h
+++ b/preferences/frameworks/cj/src/preferences_ffi.h
@@ -39,10 +39,9 @@ extern "C" {
 
     FFI_EXPORT bool FfiOHOSPreferencesHas(int64_t id, const char* key);
 
-    FFI_EXPORT int32_t FfiOHOSPreferencesOn(int64_t id, const char* mode, void (*callback)(const char* value),
-        void (*callbackRef)(const char* valueRef));
+    FFI_EXPORT int32_t FfiOHOSPreferencesOn(int64_t id, const char* mode, void (*callbackRef)(const char* valueRef));
 
-    FFI_EXPORT int32_t FfiOHOSPreferencesOff(int64_t id, const char* mode, void (*callback)(const char* value));
+    FFI_EXPORT int32_t FfiOHOSPreferencesOff(int64_t id, const char* mode, void (*callbackRef)(const char* valueRef));
 
     FFI_EXPORT int32_t FfiOHOSPreferencesOffAll(int64_t id, const char* mode);
 
diff --git a/preferences/frameworks/cj/src/preferences_impl.cpp b/preferences/frameworks/cj/src/preferences_impl.cpp
index 9c92936d96d4084b97e6322241a3b0a94b209a79..1e163f3dc1c8374cfa2687dbe3e6d35792f03247 100644
--- a/preferences/frameworks/cj/src/preferences_impl.cpp
+++ b/preferences/frameworks/cj/src/preferences_impl.cpp
@@ -163,25 +163,17 @@ OHOS::FFI::RuntimeType* PreferencesImpl::GetClassType()
     return &runtimeType;
 }
 
-bool isSameFunction(const std::function<void(std::string)> *f1, const std::function<void(std::string)> *f2)
+static bool IsSameFunction(const std::function<void(std::string)> *f1, const std::function<void(std::string)> *f2)
 {
     return f1 == f2;
 }
 
-bool PreferencesImpl::HasRegisteredObserver(std::function<void(std::string)> *callback, RegisterMode mode)
-{
-    const auto &observers = (mode == RegisterMode::LOCAL_CHANGE) ? localObservers_ : multiProcessObservers_;
-    return std::any_of(observers.begin(), observers.end(), [callback](const auto& it) {
-        return isSameFunction(callback, it->m_callback);
-    });
-}
-
 RegisterMode PreferencesImpl::ConvertToRegisterMode(const std::string &mode)
 {
     return (mode == strChange) ? RegisterMode::LOCAL_CHANGE : RegisterMode::MULTI_PRECESS_CHANGE;
 }
 
-PreferencesValue ValueTypeToPreferencesValue(const ValueType &value)
+static PreferencesValue CValueTypeToNativeValue(const ValueType &value)
 {
     NativePreferences::PreferencesValue preferencesValue = NativePreferences::PreferencesValue(-1);
     switch (value.tag) {
@@ -232,7 +224,7 @@ PreferencesValue ValueTypeToPreferencesValue(const ValueType &value)
     return preferencesValue;
 }
 
-void freeValueType(ValueType v)
+static void FreeValueType(ValueType &v)
 {
     switch (v.tag) {
         case TYPE_STR: {
@@ -259,10 +251,21 @@ void freeValueType(ValueType v)
     }
 }
 
-CArrDouble vectorToDoubleArray(const std::vector<double> &doubles)
+static void FreeValueTypes(ValueType *v, int count)
 {
+    for (int i = 0; i < count; i++) {
+        FreeValueType(v[i]);
+    }
+}
+
+static CArrDouble VectorToDoubleArray(const std::vector<double> &doubles, int32_t &code)
+{
+    if (doubles.size() == 0) {
+        return CArrDouble{0};
+    }
     double* head = static_cast<double*>(malloc(doubles.size() * sizeof(double)));
     if (head == nullptr) {
+        code = E_ERROR;
         return CArrDouble{0};
     }
     for (unsigned long i = 0; i < doubles.size(); i++) {
@@ -272,10 +275,14 @@ CArrDouble vectorToDoubleArray(const std::vector<double> &doubles)
     return doubleArray;
 }
 
-CArrBool vectorToBoolArray(std::vector<bool> bools)
+static CArrBool VectorToBoolArray(std::vector<bool> &bools, int32_t &code)
 {
+    if (bools.size() == 0) {
+        return CArrBool{0};
+    }
     bool* head = static_cast<bool*>(malloc(bools.size() * sizeof(bool)));
     if (head == nullptr) {
+        code = E_ERROR;
         return CArrBool{0};
     }
     for (unsigned long i = 0; i < bools.size(); i++) {
@@ -285,28 +292,47 @@ CArrBool vectorToBoolArray(std::vector<bool> bools)
     return boolArray;
 }
 
-CArrStr vectorToStringArray(std::vector<std::string> strings)
+static void FreeCharPointer(char** ptr, int count)
+{
+    for (int i = 0; i < count; i++) {
+        free(ptr[i]);
+    }
+}
+
+static char** VectorToCharPointer(std::vector<std::string> &vec, int32_t &code)
+{
+    if (vec.size() == 0) {
+        return nullptr;
+    }
+    char** result = static_cast<char**>(malloc(sizeof(char*) * vec.size()));
+    if (result == nullptr) {
+        code = E_ERROR;
+        return nullptr;
+    }
+    for (size_t i = 0; i < vec.size(); i++) {
+        result[i] = MallocCString(vec[i]);
+        if (result[i] == nullptr) {
+            FreeCharPointer(result, i);
+            free(result);
+            code = E_ERROR;
+            return nullptr;
+        }
+    }
+    return result;
+}
+
+static CArrStr VectorToStringArray(std::vector<std::string> &strings, int32_t &code)
 {
     CArrStr strArray;
     strArray.size = static_cast<int64_t>(strings.size());
-    strArray.head = static_cast<char**>(malloc(strArray.size * sizeof(char*)));
-    if (strArray.head == nullptr) {
-        return strArray;
-    }
-    for (int64_t i = 0; i < strArray.size; i++) {
-        strArray.head[i] = static_cast<char*>(malloc((strings[i].length() + 1) * sizeof(char)));
-        if (strArray.head[i] == nullptr) {
-            return strArray;
-        }
-        errno_t ret = strcpy_s(strArray.head[i], (strings[i].length() + 1) * sizeof(char), strings[i].c_str());
-        if (ret != EOK) {
-            return strArray;
-        }
+    strArray.head = VectorToCharPointer(strings, code);
+    if (code != E_OK) {
+        return CArrStr{0};
     }
     return strArray;
 }
 
-ValueType PreferencesValueToValueType(const PreferencesValue &pValue)
+static ValueType NativeValueToCValueType(const PreferencesValue &pValue, int32_t &code)
 {
     ValueType v = {0};
     if (pValue.IsInt()) {
@@ -331,15 +357,15 @@ ValueType PreferencesValueToValueType(const PreferencesValue &pValue)
         v.tag = TYPE_BOOL;
     } else if (pValue.IsBoolArray()) {
         auto boolVector = std::get<std::vector<bool>>(pValue.value_);
-        v.boolArray = vectorToBoolArray(boolVector);
+        v.boolArray = VectorToBoolArray(boolVector, code);
         v.tag = TYPE_BOOLARR;
     } else if (pValue.IsDoubleArray()) {
         auto doubleVector = std::get<std::vector<double>>(pValue.value_);
-        v.doubleArray = vectorToDoubleArray(doubleVector);
+        v.doubleArray = VectorToDoubleArray(doubleVector, code);
         v.tag = TYPE_DOUARR;
     } else if (pValue.IsStringArray()) {
         auto stringVector = std::get<std::vector<std::string>>(pValue.value_);
-        v.stringArray = vectorToStringArray(stringVector);
+        v.stringArray = VectorToStringArray(stringVector, code);
         v.tag = TYPE_STRARR;
     } else {
         v.tag = -1;
@@ -347,40 +373,42 @@ ValueType PreferencesValueToValueType(const PreferencesValue &pValue)
     return v;
 }
 
-ValueTypes PreferencesValuesToValueTypes(const std::map<std::string, PreferencesValue> &objects)
+static ValueTypes NativeValuesToCValueTypes(const std::map<std::string, PreferencesValue> &objects, int32_t &code)
 {
     ValueTypes valueTypes = {0};
     valueTypes.size = static_cast<int64_t>(objects.size());
     valueTypes.key = static_cast<char**>(malloc(valueTypes.size * sizeof(char*)));
     if (valueTypes.key == nullptr) {
+        code = E_ERROR;
         return valueTypes;
     }
     valueTypes.head = static_cast<ValueType*>(malloc(valueTypes.size * sizeof(ValueType)));
     if (valueTypes.head == nullptr) {
         free(valueTypes.key);
+        code = E_ERROR;
         return valueTypes;
     }
     int i = 0;
     for (auto const& [key, value] : objects) {
-        // 将键转换成 char*
-        valueTypes.key[i] = static_cast<char*>(malloc((key.length() + 1) * sizeof(char)));
+        valueTypes.key[i] = MallocCString(key);
         if (valueTypes.key[i] == nullptr) {
-            for (int j = i - 1; j >= 0; j--) {
-                free(valueTypes.key[j]);
-                freeValueType(valueTypes.head[i]);
-            }
+            FreeCharPointer(valueTypes.key, i);
+            FreeValueTypes(valueTypes.head, i);
+            free(valueTypes.key);
+            free(valueTypes.head);
+            code = E_ERROR;
             return valueTypes;
         }
-        errno_t ret = strcpy_s(valueTypes.key[i], (key.length() + 1) * sizeof(char), key.c_str());
-        if (ret != EOK) {
-            for (int j = i - 1; j >= 0; j--) {
-                free(valueTypes.key[j]);
-                freeValueType(valueTypes.head[i]);
-            }
+        valueTypes.head[i] = NativeValueToCValueType(value, code);
+        if (code != E_OK) {
+            free(valueTypes.key[i]);
+            FreeCharPointer(valueTypes.key, i);
+            FreeValueTypes(valueTypes.head, i);
+            free(valueTypes.key);
+            free(valueTypes.head);
+            code = E_ERROR;
             return valueTypes;
         }
-        // 将值转换成 ValueType
-        valueTypes.head[i] = PreferencesValueToValueType(value);
         i++;
     }
     return valueTypes;
@@ -392,7 +420,13 @@ ValueType PreferencesImpl::Get(const std::string &key, const ValueType &defValue
         LOGE("The preferences is nullptr.");
         return ValueType{0};
     }
-    return PreferencesValueToValueType(preferences->Get(key, ValueTypeToPreferencesValue(defValue)));
+    PreferencesValue p = CValueTypeToNativeValue(defValue);
+    int32_t err = E_OK;
+    ValueType v = NativeValueToCValueType(preferences->Get(key, p), err);
+    if (err != E_OK) {
+        return ValueType{0};
+    }
+    return v;
 }
 
 int32_t PreferencesImpl::Put(const std::string &key, const ValueType &value)
@@ -401,7 +435,7 @@ int32_t PreferencesImpl::Put(const std::string &key, const ValueType &value)
         LOGE("The preferences is nullptr.");
         return E_ERROR;
     }
-    return preferences->Put(key, ValueTypeToPreferencesValue(value));
+    return preferences->Put(key, CValueTypeToNativeValue(value));
 }
 
 ValueTypes PreferencesImpl::GetAll()
@@ -410,27 +444,30 @@ ValueTypes PreferencesImpl::GetAll()
         LOGE("The preferences is nullptr.");
         return ValueTypes{0};
     }
-    return PreferencesValuesToValueTypes(preferences->GetAll());
+    int32_t err = E_OK;
+    ValueTypes vs = NativeValuesToCValueTypes(preferences->GetAll(), err);
+    if (err != E_OK) {
+        return ValueTypes{0};
+    }
+    return vs;
 }
 
 int32_t PreferencesImpl::RegisterObserver(const std::string &mode, std::function<void(std::string)> *callback,
     const std::function<void(std::string)>& callbackRef)
 {
     std::lock_guard<std::mutex> lck(listMutex_);
-    if (!HasRegisteredObserver(callback, ConvertToRegisterMode(mode))) {
-        auto observer = std::make_shared<CJPreferencesObserver>(callback, callbackRef);
-        if (preferences == nullptr) {
-            LOGE("The preferences is nullptr.");
-            return E_ERROR;
-        }
-        int errCode = preferences->RegisterObserver(observer, ConvertToRegisterMode(mode));
-        if (errCode != E_OK) {
-            return errCode;
-        }
-        auto &observers = (ConvertToRegisterMode(mode) == RegisterMode::LOCAL_CHANGE) ?
-                            localObservers_ : multiProcessObservers_;
-        observers.push_back(observer);
+    auto observer = std::make_shared<CJPreferencesObserver>(callback, callbackRef);
+    if (preferences == nullptr) {
+        LOGE("The preferences is nullptr.");
+        return E_ERROR;
     }
+    int errCode = preferences->RegisterObserver(observer, ConvertToRegisterMode(mode));
+    if (errCode != E_OK) {
+        return errCode;
+    }
+    auto &observers = (ConvertToRegisterMode(mode) == RegisterMode::LOCAL_CHANGE) ?
+                        localObservers_ : multiProcessObservers_;
+    observers.push_back(observer);
     return E_OK;
 }
 
@@ -445,7 +482,7 @@ int32_t PreferencesImpl::UnRegisterObserver(const std::string &mode, std::functi
         return E_ERROR;
     }
     while (it != observers.end()) {
-        if (isSameFunction(callback, (*it)->m_callback)) {
+        if (IsSameFunction(callback, (*it)->m_callback)) {
             int errCode = preferences->UnRegisterObserver(*it, ConvertToRegisterMode(mode));
             if (errCode != E_OK) {
                 return errCode;
diff --git a/preferences/frameworks/common/include/log_print.h b/preferences/frameworks/common/include/log_print.h
index 2df903cbf6bb4187834db9f0b58ad096e8cdf20f..84ac7ce3a3ab0626093f3204c21d8b35481330cb 100644
--- a/preferences/frameworks/common/include/log_print.h
+++ b/preferences/frameworks/common/include/log_print.h
@@ -34,6 +34,14 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
     return { LOG_CORE, 0xD001653, "NativePreferences" };
 }
 }
+
+namespace PreferencesNdk {
+static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
+{
+    return { LOG_CORE, 0xD001653, "PreferencesNdk" };
+}
+}
+
 namespace StorageJsKit {
 static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
 {
diff --git a/preferences/frameworks/js/napi/common/BUILD.gn b/preferences/frameworks/js/napi/common/BUILD.gn
index 7bf9f7cc306161d874f8abf249adeae5208b036e..d5612bc78dc34228a8deb2dca176edb780333f8d 100644
--- a/preferences/frameworks/js/napi/common/BUILD.gn
+++ b/preferences/frameworks/js/napi/common/BUILD.gn
@@ -60,6 +60,7 @@ if (is_ohos) {
     external_deps = [
       "ability_runtime:abilitykit_native",
       "ability_runtime:napi_base_context",
+      "bounds_checking_function:libsec_shared",
       "hilog:libhilog",
       "napi:ace_napi",
     ]
diff --git a/preferences/frameworks/js/napi/common/src/js_common_utils.cpp b/preferences/frameworks/js/napi/common/src/js_common_utils.cpp
index ded3d1ec362d1ca2c6d12063234579116d31c0fa..e1b878d91a778eb372ffe0dc67d45ef9157f0e36 100644
--- a/preferences/frameworks/js/napi/common/src/js_common_utils.cpp
+++ b/preferences/frameworks/js/napi/common/src/js_common_utils.cpp
@@ -22,11 +22,6 @@
 #include "js_native_api_types.h"
 #include "log_print.h"
 
-#ifndef MAC_PLATFORM
-#include "securec.h"
-#endif
-
-
 namespace OHOS {
 namespace PreferencesJsKit {
 using namespace OHOS::NativePreferences;
diff --git a/preferences/frameworks/js/napi/common/src/napi_async_call.cpp b/preferences/frameworks/js/napi/common/src/napi_async_call.cpp
index 1fa2622b53a83e53ff4f9fe5ac5ac649c1011c33..5b3d57d1c6c0a98f61313cb8d6df4e8f6e8d6f53 100644
--- a/preferences/frameworks/js/napi/common/src/napi_async_call.cpp
+++ b/preferences/frameworks/js/napi/common/src/napi_async_call.cpp
@@ -150,7 +150,7 @@ void AsyncCall::OnComplete(napi_env env, void *data)
     BaseContext *context = reinterpret_cast<BaseContext *>(data);
     if (context->execCode_ != NativePreferences::E_OK) {
         context->SetError(std::make_shared<InnerError>(context->execCode_));
-        LOG_ERROR("The async execute status is %{public}d", context->execCode_);
+        LOG_ERROR("The execute status is %{public}d", context->execCode_);
     }
     // if async execute status is not napi_ok then un-execute out function
     if ((context->error == nullptr) && context->output_) {
diff --git a/preferences/frameworks/js/napi/preferences/src/napi_preferences.cpp b/preferences/frameworks/js/napi/preferences/src/napi_preferences.cpp
index 278cd0c02a20105210f93fd15882b20ffd83ee11..82dc2ce9dbe94306d1504a3e19b02d9cb92f8a98 100644
--- a/preferences/frameworks/js/napi/preferences/src/napi_preferences.cpp
+++ b/preferences/frameworks/js/napi/preferences/src/napi_preferences.cpp
@@ -25,7 +25,6 @@
 #include "preferences.h"
 #include "preferences_errno.h"
 #include "preferences_value.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 
@@ -157,9 +156,9 @@ int ParseDefValue(const napi_env env, const napi_value jsVal, std::shared_ptr<Pr
     int32_t rc = JSUtils::Convert2NativeValue(env, jsVal, context->defValue.value_);
     if (rc == EXCEED_MAX_LENGTH) {
         PRE_CHECK_RETURN_ERR_SET(rc == napi_ok,
-            std::make_shared<ParamTypeError>("The type of value mast be less then 16 * 1024 * 1024 btyes."));
+            std::make_shared<ParamTypeError>("The type of value must be less then 16 * 1024 * 1024 btyes."));
     }
-    PRE_CHECK_RETURN_ERR_SET(rc == napi_ok, std::make_shared<ParamTypeError>("The type of value mast be ValueType."));
+    PRE_CHECK_RETURN_ERR_SET(rc == napi_ok, std::make_shared<ParamTypeError>("The type of value must be ValueType."));
     return OK;
 }
 
diff --git a/preferences/frameworks/js/napi/preferences/src/napi_preferences_helper.cpp b/preferences/frameworks/js/napi/preferences/src/napi_preferences_helper.cpp
index dffedc8d34ff38aecfa55910e5e67a21b0f1f469..a76f605590253204e53bbda18983250173855195 100644
--- a/preferences/frameworks/js/napi/preferences/src/napi_preferences_helper.cpp
+++ b/preferences/frameworks/js/napi/preferences/src/napi_preferences_helper.cpp
@@ -22,7 +22,6 @@
 #include "napi_preferences.h"
 #include "preferences_errno.h"
 #include "preferences.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 
diff --git a/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences.cpp b/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences.cpp
index 23949fdb1f9a439616f27f0e4e5b6f1c88807389..264e3d3f576d4b2ce0741ff39e8461ee40607401 100644
--- a/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences.cpp
+++ b/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences.cpp
@@ -27,7 +27,6 @@
 #include "preferences.h"
 #include "preferences_errno.h"
 #include "preferences_value.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 using namespace OHOS::PreferencesJsKit;
@@ -153,7 +152,7 @@ int ParseKey(napi_env env, const napi_value arg, std::shared_ptr<PreferencesAysn
 int ParseDefValue(const napi_env env, const napi_value jsVal, std::shared_ptr<PreferencesAysncContext> context)
 {
     int32_t rc = Utils::ConvertFromSendable(env, jsVal, context->defValue.value_);
-    PRE_CHECK_RETURN_ERR_SET(rc == napi_ok, std::make_shared<ParamTypeError>("The type of value mast be ValueType."));
+    PRE_CHECK_RETURN_ERR_SET(rc == napi_ok, std::make_shared<ParamTypeError>("The type of value must be ValueType."));
     return OK;
 }
 
diff --git a/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences_helper.cpp b/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences_helper.cpp
index eeecf01bb2411d4460ce841c0d1824c6dfd05fc5..b8197beda7e2c8042cc1386073dbee13bd8dea55 100644
--- a/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences_helper.cpp
+++ b/preferences/frameworks/js/napi/sendable_preferences/src/napi_preferences_helper.cpp
@@ -23,7 +23,6 @@
 #include "napi_preferences.h"
 #include "preferences.h"
 #include "preferences_errno.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 using namespace OHOS::PreferencesJsKit;
diff --git a/preferences/frameworks/js/napi/storage/src/napi_storage.cpp b/preferences/frameworks/js/napi/storage/src/napi_storage.cpp
index 35f475ecde768a7302878254dddf2adc740c6719..679ba6c2c848ccaaa378d4e3096db451c08a6e97 100644
--- a/preferences/frameworks/js/napi/storage/src/napi_storage.cpp
+++ b/preferences/frameworks/js/napi/storage/src/napi_storage.cpp
@@ -24,7 +24,6 @@
 #include "preferences.h"
 #include "preferences_errno.h"
 #include "preferences_value.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 using namespace OHOS::PreferencesJsKit;
diff --git a/preferences/frameworks/js/napi/storage/src/napi_storage_helper.cpp b/preferences/frameworks/js/napi/storage/src/napi_storage_helper.cpp
index 69a659fa2a6538eeae14befd13ef2f94f5fe182f..87d2290d32677b06171547a6b742405a93cc7729 100644
--- a/preferences/frameworks/js/napi/storage/src/napi_storage_helper.cpp
+++ b/preferences/frameworks/js/napi/storage/src/napi_storage_helper.cpp
@@ -23,7 +23,6 @@
 #include "napi_storage.h"
 #include "preferences.h"
 #include "preferences_errno.h"
-#include "securec.h"
 
 using namespace OHOS::NativePreferences;
 using namespace OHOS::PreferencesJsKit;
diff --git a/preferences/frameworks/native/include/concurrent_map.h b/preferences/frameworks/native/include/concurrent_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..b64100fbddca965a8445f822dceba500ad22e949
--- /dev/null
+++ b/preferences/frameworks/native/include/concurrent_map.h
@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_CONCURRENT_MAP_H
+#define OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_CONCURRENT_MAP_H
+#include <functional>
+#include <map>
+#include <shared_mutex>
+
+namespace OHOS {
+template<typename _Key, typename _Tp>
+class ConcurrentMap {
+    template<typename _First, typename... _Rest>
+    static _First First();
+
+public:
+    using map_type = typename std::map<_Key, _Tp>;
+    using filter_type = typename std::function<bool(map_type &)>;
+    using key_type = typename std::map<_Key, _Tp>::key_type;
+    using mapped_type = typename std::map<_Key, _Tp>::mapped_type;
+    using value_type = typename std::map<_Key, _Tp>::value_type;
+    using size_type = typename std::map<_Key, _Tp>::size_type;
+    using reference = typename std::map<_Key, _Tp>::reference;
+    using const_reference = typename std::map<_Key, _Tp>::const_reference;
+
+    ConcurrentMap() = default;
+    ~ConcurrentMap()
+    {
+        Clear();
+    }
+
+    ConcurrentMap(const ConcurrentMap &other)
+    {
+        operator=(std::move(other));
+    }
+
+    ConcurrentMap(std::map<_Key, _Tp> &&other) noexcept
+    {
+        operator=(std::move(other));
+    }
+
+    ConcurrentMap &operator=(std::map<_Key, _Tp> &&other) noexcept
+    {
+        if (&entries_ == &other) {
+            return *this;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        entries_ = std::move(other);
+        return *this;
+    }
+
+    ConcurrentMap &operator=(const ConcurrentMap &other) noexcept
+    {
+        if (this == &other) {
+            return *this;
+        }
+        auto tmp = other.Clone();
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        entries_ = std::move(tmp);
+        return *this;
+    }
+
+    ConcurrentMap(ConcurrentMap &&other) noexcept
+    {
+        operator=(std::move(other));
+    }
+
+    ConcurrentMap &operator=(ConcurrentMap &&other) noexcept
+    {
+        if (this == &other) {
+            return *this;
+        }
+        auto tmp = other.Steal();
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        entries_ = std::move(tmp);
+        return *this;
+    }
+
+    bool Emplace() noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.emplace();
+        return it.second;
+    }
+
+    template<typename... _Args>
+    typename std::enable_if<!std::is_convertible_v<decltype(First<_Args...>()), filter_type>, bool>::type
+    Emplace(_Args &&...args) noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.emplace(std::forward<_Args>(args)...);
+        return it.second;
+    }
+
+    template<typename _Filter, typename... _Args>
+    typename std::enable_if<std::is_convertible_v<_Filter, filter_type>, bool>::type
+    Emplace(const _Filter &filter, _Args &&...args) noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        if (!filter(entries_)) {
+            return false;
+        }
+        auto it = entries_.emplace(std::forward<_Args>(args)...);
+        return it.second;
+    }
+
+    std::pair<bool, mapped_type> Find(const key_type &key) const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it == entries_.end()) {
+            return std::pair { false, mapped_type() };
+        }
+
+        return std::pair { true, it->second };
+    }
+
+    bool ContainIf(const key_type &key, const std::function<bool(const mapped_type &value)> &action) const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it == entries_.end()) {
+            return false;
+        }
+        if (action) {
+            return action(it->second);
+        }
+        return true;
+    }
+
+    bool Contains(const key_type &key) const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        return (entries_.find(key) != entries_.end());
+    }
+
+    template <typename _Obj>
+    bool InsertOrAssign(const key_type &key, _Obj &&obj) noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.insert_or_assign(key, std::forward<_Obj>(obj));
+        return it.second;
+    }
+
+    bool Insert(const key_type &key, const mapped_type &value) noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.insert(value_type { key, value });
+        return it.second;
+    }
+
+    size_type Erase(const key_type &key) noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        return entries_.erase(key);
+    }
+
+    size_type EraseIf(const key_type &key,
+        const std::function<bool(const key_type &key, mapped_type &value)> &action) noexcept
+    {
+        if (action == nullptr) {
+            return 0;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it == entries_.end() || !action((*it).first, (*it).second)) {
+            return 0;
+        }
+        return entries_.erase(key);
+    }
+
+    void Clear() noexcept
+    {
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        return entries_.clear();
+    }
+
+    bool Empty() const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        return entries_.empty();
+    }
+
+    size_type Size() const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        return entries_.size();
+    }
+
+    // The action`s return true means meeting the erase condition
+    // The action`s return false means not meeting the erase condition
+    size_type EraseIf(const std::function<bool(const key_type &key, mapped_type &value)> &action) noexcept
+    {
+        if (action == nullptr) {
+            return 0;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+#if __cplusplus > 201703L
+        auto count = std::erase_if(entries_,
+            [&action](value_type &value) -> bool { return action(value.first, value.second); });
+#else
+        auto count = entries_.size();
+        for (auto it = entries_.begin(); it != entries_.end();) {
+            if (action((*it).first, (*it).second)) {
+                it = entries_.erase(it);
+            } else {
+                ++it;
+            }
+        }
+        count -= entries_.size();
+#endif
+        return count;
+    }
+
+    void ForEach(const std::function<bool(const key_type &, mapped_type &)> &action)
+    {
+        if (action == nullptr) {
+            return;
+        }
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        for (auto &[key, value] : entries_) {
+            if (action(key, value)) {
+                break;
+            }
+        }
+    }
+
+    void ForEachCopies(const std::function<bool(const key_type &, mapped_type &)> &action)
+    {
+        if (action == nullptr) {
+            return;
+        }
+        auto entries = Clone();
+        for (auto &[key, value] : entries) {
+            if (action(key, value)) {
+                break;
+            }
+        }
+    }
+
+    // The action's return value means that the element is keep in map or not; true means keeping, false means removing.
+    bool Compute(const key_type &key, const std::function<bool(const key_type &, mapped_type &)> &action)
+    {
+        if (action == nullptr) {
+            return false;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it == entries_.end()) {
+            auto result = entries_.emplace(key, mapped_type());
+            it = result.second ? result.first : entries_.end();
+        }
+        if (it == entries_.end()) {
+            return false;
+        }
+        if (!action(it->first, it->second)) {
+            entries_.erase(key);
+        }
+        return true;
+    }
+
+    // The action's return value means that the element is keep in map or not; true means keeping, false means removing.
+    bool ComputeIfPresent(const key_type &key, const std::function<bool(const key_type &, mapped_type &)> &action)
+    {
+        if (action == nullptr) {
+            return false;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it == entries_.end()) {
+            return false;
+        }
+        if (!action(key, it->second)) {
+            entries_.erase(key);
+        }
+        return true;
+    }
+
+    bool ComputeIfAbsent(const key_type &key, const std::function<mapped_type(const key_type &)> &action)
+    {
+        if (action == nullptr) {
+            return false;
+        }
+        std::unique_lock<decltype(mutex_)> lock(mutex_);
+        auto it = entries_.find(key);
+        if (it != entries_.end()) {
+            return false;
+        }
+        entries_.emplace(key, action(key));
+        return true;
+    }
+
+    void DoActionIfEmpty(const std::function<void(void)> &action)
+    {
+        if (action == nullptr) {
+            return;
+        }
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        if (entries_.empty()) {
+            action();
+        }
+        return;
+    }
+
+    void DoActionWhenClone(const std::function<void(const std::map<_Key, _Tp> &)> &action)
+    {
+        if (action == nullptr) {
+            return;
+        }
+        auto tmp = Clone();
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        action(tmp);
+        return;
+    }
+
+    std::map<_Key, _Tp> Clone() const noexcept
+    {
+        std::shared_lock<decltype(mutex_)> lock(mutex_);
+        return entries_;
+    }
+
+private:
+    std::map<_Key, _Tp> Steal() noexcept
+    {
+        std::lock_guard<decltype(mutex_)> lock(mutex_);
+        return std::move(entries_);
+    }
+
+private:
+    mutable std::shared_mutex mutex_;
+    std::map<_Key, _Tp> entries_;
+};
+} // namespace OHOS
+#endif // OHOS_DISTRIBUTED_DATA_FRAMEWORKS_COMMON_CONCURRENT_MAP_H
diff --git a/preferences/frameworks/native/include/preferences_base.h b/preferences/frameworks/native/include/preferences_base.h
index 3e2d7d7b1a2bcc33251b7f8b599a7c1b81b4d28b..236bfe3607a50b10ed427c9c2c5346b691ee1ece 100644
--- a/preferences/frameworks/native/include/preferences_base.h
+++ b/preferences/frameworks/native/include/preferences_base.h
@@ -25,6 +25,7 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <shared_mutex>
 
 #include "preferences.h"
 #include "preferences_observer.h"
@@ -99,6 +100,11 @@ public:
     std::string GetGroupId() const override;
 
     int CloseDb() override;
+
+    std::pair<int, PreferencesValue> GetValue(const std::string &key, const PreferencesValue &defValue) override;
+
+    std::pair<int, std::map<std::string, PreferencesValue>> GetAllData() override;
+
 protected:
     Uri MakeUri(const std::string &key = "");
     struct WeakPtrCompare {
@@ -109,6 +115,7 @@ protected:
     };
     using DataObserverMap = std::map<std::weak_ptr<PreferencesObserver>, std::set<std::string>, WeakPtrCompare>;
     std::mutex mutex_;
+    std::shared_mutex obseverMetux_;
     std::condition_variable cond_;
 
     std::vector<std::weak_ptr<PreferencesObserver>> localObservers_;
@@ -121,4 +128,4 @@ protected:
 };
 } // End of namespace NativePreferences
 } // End of namespace OHOS
-#endif // End of #ifndef PREFERENCES_H
+#endif // End of #ifndef PREFERENCES_H
\ No newline at end of file
diff --git a/preferences/frameworks/native/include/preferences_enhance_impl.h b/preferences/frameworks/native/include/preferences_enhance_impl.h
index 62905c12ffe0046cdfe3ac3d4680c8ec896410fe..819d8b957ccce5aad90e674d43296fe4b66141f3 100644
--- a/preferences/frameworks/native/include/preferences_enhance_impl.h
+++ b/preferences/frameworks/native/include/preferences_enhance_impl.h
@@ -53,13 +53,23 @@ public:
     int Clear() override;
 
     int CloseDb() override;
+
+    std::pair<int, PreferencesValue> GetValue(const std::string &key, const PreferencesValue &defValue) override;
+
+    std::pair<int, std::map<std::string, PreferencesValue>> GetAllData() override;
 private:
     explicit PreferencesEnhanceImpl(const Options &options);
     static void NotifyPreferencesObserver(std::shared_ptr<PreferencesEnhanceImpl> pref, const std::string &key,
         const PreferencesValue &value);
+    static void NotifyPreferencesObserverBatchKeys(std::shared_ptr<PreferencesEnhanceImpl> pref,
+        const std::map<std::string, PreferencesValue> &data);
+    std::pair<int, std::map<std::string, PreferencesValue>> GetAllInner();
+
     std::shared_mutex dbMutex_;
     std::shared_ptr<PreferencesDb> db_;
     std::shared_mutex mapSharedMutex_;
+    int64_t cachedDataVersion_ = 0;
+    std::map<std::string, PreferencesValue> largeCachedData_;
 };
 } // End of namespace NativePreferences
 } // End of namespace OHOS
diff --git a/preferences/frameworks/native/include/preferences_impl.h b/preferences/frameworks/native/include/preferences_impl.h
index 4f6dcbbf6c1c6bfa864b4b84994f167795af06b7..1fc3dd4a54bdd9ea11c6a03a63835b1b32115f7e 100644
--- a/preferences/frameworks/native/include/preferences_impl.h
+++ b/preferences/frameworks/native/include/preferences_impl.h
@@ -23,7 +23,9 @@
 #include <map>
 #include <string>
 #include <vector>
-
+#include <shared_mutex>
+#include "safe_block_queue.h"
+#include "concurrent_map.h"
 #include "preferences_base.h"
 
 namespace OHOS {
@@ -53,42 +55,25 @@ public:
     void Flush() override;
 
     int FlushSync() override;
+
+    std::pair<int, PreferencesValue> GetValue(const std::string &key, const PreferencesValue &defValue) override;
+
+    std::pair<int, std::map<std::string, PreferencesValue>> GetAllData() override;
 private:
     explicit PreferencesImpl(const Options &options);
-    class MemoryToDiskRequest {
-    public:
-        MemoryToDiskRequest(const std::map<std::string, PreferencesValue> &writeToDiskMap,
-            const std::list<std::string> &keysModified,
-            const std::vector<std::weak_ptr<PreferencesObserver>> preferencesObservers, int64_t memStataGeneration,
-            const DataObserverMap preferencesDataObservers);
-        ~MemoryToDiskRequest() {}
-        void SetDiskWriteResult(bool wasWritten, int result);
-
-        bool isSyncRequest_;
-        int64_t memoryStateGeneration_;
-        std::map<std::string, PreferencesValue> writeToDiskMap_;
-        std::condition_variable reqCond_;
-        std::list<std::string> keysModified_;
-        std::vector<std::weak_ptr<PreferencesObserver>> localObservers_;
-        DataObserverMap dataObserversMap_;
-
-        int writeToDiskResult_;
-        bool wasWritten_;
-    };
-
-    std::shared_ptr<MemoryToDiskRequest> commitToMemory();
-    void NotifyPreferencesObserver(const MemoryToDiskRequest &request);
+    
+    void NotifyPreferencesObserver(const std::list<std::string> &keysModified,
+        const std::map<std::string, PreferencesValue> &writeToDiskMap);
     bool StartLoadFromDisk();
 
     /* thread function */
     static void LoadFromDisk(std::shared_ptr<PreferencesImpl> pref);
     void AwaitLoadFile();
-    static void WriteToDiskFile(std::shared_ptr<PreferencesImpl> pref, std::shared_ptr<MemoryToDiskRequest> mcr);
-    bool CheckRequestValidForStateGeneration(std::shared_ptr<MemoryToDiskRequest> mcr);
-    bool ReadSettingXml(std::shared_ptr<PreferencesImpl> pref);
-    bool WriteSettingXml(std::shared_ptr<PreferencesImpl> pref, const std::map<std::string, PreferencesValue> &prefMap);
+    bool WriteSettingXml(const Options &options, const std::map<std::string, PreferencesValue> &writeToDiskMap);
+    static int WriteToDiskFile(std::shared_ptr<PreferencesImpl> pref);
+    static bool ReadSettingXml(std::shared_ptr<PreferencesImpl> pref);
 
-    bool loaded_;
+    std::atomic<bool> loaded_;
 
     /* Current memory state (always increasing) */
     int64_t currentMemoryStateGeneration_;
@@ -97,8 +82,10 @@ private:
 
     std::list<std::string> modifiedKeys_;
 
-    std::map<std::string, PreferencesValue> map_;
+    ConcurrentMap<std::string, PreferencesValue> valuesCache_;
+
+    std::shared_ptr<SafeBlockQueue<uint64_t>> queue_;
 };
 } // End of namespace NativePreferences
 } // End of namespace OHOS
-#endif // End of #ifndef PREFERENCES_IMPL_H
+#endif // End of #ifndef PREFERENCES_IMPL_H
\ No newline at end of file
diff --git a/preferences/frameworks/native/include/preferences_xml_utils.h b/preferences/frameworks/native/include/preferences_xml_utils.h
index 7e4c805c6800cc762cb93c1d13e295bd5db686ae..3988712419b463fcd9f57a9c09e63a20b40ce0bc 100644
--- a/preferences/frameworks/native/include/preferences_xml_utils.h
+++ b/preferences/frameworks/native/include/preferences_xml_utils.h
@@ -31,10 +31,10 @@ public:
 
 class PreferencesXmlUtils {
 public:
-    static bool ReadSettingXml(
-        const std::string &fileName, const std::string &dataGroupId, std::vector<Element> &settings);
-    static bool WriteSettingXml(
-        const std::string &fileName, const std::string &dataGroupId, const std::vector<Element> &settings);
+    static bool ReadSettingXml(const std::string &fileName, const std::string &bundleName,
+        const std::string &dataGroupId, std::vector<Element> &settings);
+    static bool WriteSettingXml(const std::string &fileName, const std::string &bundleName,
+        const std::string &dataGroupId, const std::vector<Element> &settings);
     static void LimitXmlPermission(const std::string &fileName);
 
 private:
diff --git a/preferences/frameworks/native/platform/include/preferences_anonymous.h b/preferences/frameworks/native/platform/include/preferences_anonymous.h
new file mode 100644
index 0000000000000000000000000000000000000000..3e79000dc614a49fc7445b2b55caa4d88508e03c
--- /dev/null
+++ b/preferences/frameworks/native/platform/include/preferences_anonymous.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_PREFERENCES_ANONYMOUS_H
+#define OHOS_PREFERENCES_ANONYMOUS_H
+
+#include <string>
+
+namespace OHOS {
+namespace NativePreferences {
+class Anonymous {
+public:
+    static std::string ToBeAnonymous(const std::string &data)
+    {
+        if (data.size() <= HEAD_SIZE) {
+            return DEFAULT_ANONYMOUS;
+        }
+        if (data.size() < MIN_SIZE) {
+            return (data.substr(0, HEAD_SIZE) + REPLACE_CHAIN);
+        }
+        return (data.substr(0, HEAD_SIZE) + REPLACE_CHAIN + data.substr(data.size() - END_SIZE, END_SIZE));
+    }
+
+private:
+    static constexpr size_t HEAD_SIZE = 3;
+    static constexpr size_t END_SIZE = 3;
+    static constexpr size_t MIN_SIZE = HEAD_SIZE + END_SIZE + 3;
+    static constexpr const char *REPLACE_CHAIN = "***";
+    static constexpr const char *DEFAULT_ANONYMOUS = "******";
+};
+} // namespace NativePreferences
+} // namespace OHOS
+#endif // OHOS_PREFERENCES_ANONYMOUS_H
+
diff --git a/preferences/frameworks/native/platform/include/preferences_db_adapter.h b/preferences/frameworks/native/platform/include/preferences_db_adapter.h
index 473fd9240b534222934e7ffe500e41dcd3ebe139..dc7a50dbf98a4981b86f1550ce473570ef4b5908 100644
--- a/preferences/frameworks/native/platform/include/preferences_db_adapter.h
+++ b/preferences/frameworks/native/platform/include/preferences_db_adapter.h
@@ -20,14 +20,16 @@
 #include <vector>
 #include <shared_mutex>
 #include <list>
-
 #include <string>
+#include "preferences_dfx_adapter.h"
+
 namespace OHOS {
 namespace NativePreferences {
 
 typedef struct GRD_DB GRD_DB;
 
 #define GRD_DB_OPEN_CREATE 0x01
+#define GRD_DB_OPEN_CHECK 0x04
 #define GRD_DB_CLOSE_IGNORE_ERROR 0x01
 
 typedef struct GRD_KVItem {
@@ -52,6 +54,36 @@ typedef struct GRD_FilterOption {
 
 typedef struct GRD_ResultSet GRD_ResultSet;
 
+typedef enum GRD_ConfigType {
+    GRD_CONFIG_USER_VERSION,
+    GRD_CONFIG_DATA_VERSION,
+    GRD_CONFIG_BOTTOM,
+} GRD_ConfigTypeE;
+
+typedef enum GRD_DbDataType {
+    GRD_DB_DATATYPE_INTEGER = 0,
+    GRD_DB_DATATYPE_FLOAT,
+    GRD_DB_DATATYPE_TEXT,
+    GRD_DB_DATATYPE_BLOB,
+    GRD_DB_DATATYPE_FLOATVECTOR,
+    GRD_DB_DATATYPE_NULL,
+} GRD_DbDataTypeE;
+
+typedef struct GRD_DbValueT {
+    GRD_DbDataTypeE type;
+    union {
+        int64_t longValue;
+        double doubleValue;
+        struct {
+            union {
+                const void *strAddr;
+                void *freeAddr;
+            };
+            uint32_t length;
+        };
+    } value;
+} GRD_DbValueT;
+
 typedef int32_t (*DBOpen)(const char *dbPath, const char *configStr, uint32_t flags, GRD_DB **db);
 typedef int32_t (*DBClose)(GRD_DB *db, uint32_t flags);
 typedef int32_t (*DBCreateCollection)(GRD_DB *db, const char *tableName, const char *optionStr, uint32_t flags);
@@ -70,6 +102,8 @@ typedef int32_t (*GetItemSize)(GRD_ResultSet *resultSet, uint32_t *keySize, uint
 typedef int32_t (*Fetch)(GRD_ResultSet *resultSet, GRD_KVItemT *key, GRD_KVItemT *value);
 typedef int32_t (*KVFreeItem)(GRD_KVItemT *item);
 typedef int32_t (*FreeResultSet)(GRD_ResultSet *resultSet);
+typedef int32_t (*DBRepair)(const char *dbFile, const char *configStr);
+typedef GRD_DbValueT (*DBGetConfig)(GRD_DB *db, GRD_ConfigTypeE type);
 
 struct GRD_APIInfo {
     DBOpen DbOpenApi = nullptr;
@@ -88,6 +122,8 @@ struct GRD_APIInfo {
     Fetch FetchApi = nullptr;
     KVFreeItem FreeItemApi = nullptr;
     FreeResultSet FreeResultSetApi = nullptr;
+    DBRepair DbRepairApi = nullptr;
+    DBGetConfig DbGetConfigApi = nullptr;
 };
 
 class PreferenceDbAdapter {
@@ -102,12 +138,11 @@ public:
     static std::atomic<bool> isInit_;
 };
 
-
 class PreferencesDb {
 public:
     PreferencesDb();
     ~PreferencesDb();
-    int Init(const std::string &dbPath);
+    int Init(const std::string &dbPath, const std::string &bundleName);
     int Put(const std::vector<uint8_t> &key, const std::vector<uint8_t> &value);
     int Delete(const std::vector<uint8_t> &key);
     int Get(const std::vector<uint8_t> &key, std::vector<uint8_t> &value);
@@ -115,13 +150,18 @@ public:
     int DropCollection();
     int CreateCollection();
     int GetAllInner(std::list<std::pair<std::vector<uint8_t>, std::vector<uint8_t>>> &data, GRD_ResultSet *resultSet);
-    int OpenDb();
+    int OpenDb(bool isNeedRebuild);
     int CloseDb();
+    int RepairDb();
+    int TryRepairAndRebuild(int openCode);
+    int GetKernelDataVersion(int64_t &dataVersion);
 private:
     GRD_KVItemT BlobToKvItem(const std::vector<uint8_t> &blob);
     std::vector<uint8_t> KvItemToBlob(GRD_KVItemT &item);
+    ReportParam GetReportParam(const std::string &info, uint32_t errCode);
     GRD_DB *db_ = nullptr;
     std::string dbPath_ = "";
+    std::string bundleName_ = "";
 };
 
 // grd errcode
@@ -129,10 +169,15 @@ private:
 #define GRD_NOT_SUPPORT (-1000)
 #define GRD_OVER_LIMIT (-2000)
 #define GRD_INVALID_ARGS (-3000)
+#define GRD_FAILED_FILE_OPERATION (-5000)
+#define GRD_INNER_ERR (-8000)
 #define GRD_FAILED_MEMORY_ALLOCATE (-13000)
 #define GRD_FAILED_MEMORY_RELEASE (-14000)
-#define GRD_PERMISSION_DENIED (-43000)
 #define GRD_UNDEFINED_TABLE (-23000)
+#define GRD_REBUILD_DATABASE (-38000)
+#define GRD_PERMISSION_DENIED (-43000)
+#define GRD_DATA_CORRUPTED (-45000)
+#define GRD_DB_BUSY (-46000)
 
 } // End of namespace NativePreferences
 } // End of namespace OHOS
diff --git a/preferences/frameworks/native/platform/include/preferences_dfx_adapter.h b/preferences/frameworks/native/platform/include/preferences_dfx_adapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..3dd7650ad7849bcbc53bcdaee873895bb8930ca3
--- /dev/null
+++ b/preferences/frameworks/native/platform/include/preferences_dfx_adapter.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef PREFERENCES_DFX_ADAPTER_H
+#define PREFERENCES_DFX_ADAPTER_H
+
+#include <string>
+
+#include "preferences_errno.h"
+namespace OHOS {
+namespace NativePreferences {
+
+static constexpr const char *NORMAL_DB = "XMLDB";
+static constexpr const char *ENHANCE_DB = "ENHANCEDB";
+static constexpr const char *EVENT_NAME_DB_CORRUPTED = "DATABASE_CORRUPTED";
+static constexpr const char *DISTRIBUTED_DATAMGR = "DISTDATAMGR";
+
+struct ReportParam {
+    std::string bundleName; // bundleName
+    std::string dbType;     // NORMAL_DB or ENHANCE_DB
+    std::string storeName; // filename
+    uint32_t errCode = E_OK;
+    int32_t errnoCode = 0; // errno
+    // additional info, "operation: reason", such as "read failed"
+    std::string appendix; // additional info
+};
+
+class PreferencesDfxManager {
+public:
+    static void ReportDbFault(const ReportParam &reportParam);
+    static std::string GetModuleName();
+};
+} // namespace NativePreferences
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/preferences/frameworks/native/platform/include/preferences_file_operation.h b/preferences/frameworks/native/platform/include/preferences_file_operation.h
index a125bf74beb954e399fbf1f521ac2d7cdfb69335..726968019aee263d8b096a0b84c09c2cbd5234df 100644
--- a/preferences/frameworks/native/platform/include/preferences_file_operation.h
+++ b/preferences/frameworks/native/platform/include/preferences_file_operation.h
@@ -62,7 +62,7 @@ namespace NativePreferences {
 static UNUSED_FUNCTION void *DBDlOpen()
 {
 #ifndef _WIN32
-    return dlopen("libgaussdb_rd_vector.z.so", RTLD_LAZY);
+    return dlopen("libarkdata_db_core.z.so", RTLD_LAZY);
 #else
     return nullptr;
 #endif
@@ -101,7 +101,10 @@ static UNUSED_FUNCTION bool Fsync(const std::string &filePath)
     _close(fd);
 #else
     int fd = open(filePath.c_str(), O_RDWR, S_IRUSR | S_IWUSR);
-    if (fd == -1 || fsync(fd) == -1) {
+    if (fd == -1) {
+        return false;
+    }
+    if (fsync(fd) == -1) {
         close(fd);
         return false;
     }
@@ -109,6 +112,15 @@ static UNUSED_FUNCTION bool Fsync(const std::string &filePath)
 #endif
     return true;
 }
+
+static UNUSED_FUNCTION std::string ExtractFileName(const std::string &path)
+{
+    auto pos = path.rfind('/');
+    if (pos == std::string::npos) {
+        return path;
+    }
+    return path.substr(pos + 1);
+}
 } // namespace NativePreferences
 } // namespace OHOS
-#endif // PREFERENCES_FILE_OPERATION_H
\ No newline at end of file
+#endif // PREFERENCES_FILE_OPERATION_H
diff --git a/preferences/frameworks/native/platform/src/preferences_db_adapter.cpp b/preferences/frameworks/native/platform/src/preferences_db_adapter.cpp
index 93d943c151bf10df9d42532e0f96580a17b0b471..d732f97aaeaa7eacbcfae54cf911e6f6cf1a171f 100644
--- a/preferences/frameworks/native/platform/src/preferences_db_adapter.cpp
+++ b/preferences/frameworks/native/platform/src/preferences_db_adapter.cpp
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 #include <map>
-
+#include <thread>
 #include "preferences_db_adapter.h"
 #include "log_print.h"
 #include "preferences_errno.h"
@@ -30,13 +30,18 @@ GRD_APIInfo PreferenceDbAdapter::api_;
 
 std::atomic<bool> PreferenceDbAdapter::isInit_ = false;
 
+#if !defined(WINDOWS_PLATFORM)
+static const std::chrono::milliseconds WAIT_REPAIRE_TIMEOUT(5);
+#endif
+
 const char * const TABLENAME = "preferences_data";
 const char * const TABLE_MODE = "{\"mode\" : \"kv\", \"indextype\" : \"hash\"}";
 const char * const CONFIG_STR =
-    "{\"pageSize\": 4, \"redoFlushByTrx\": 1, \"redoPubBufSize\": 256, \"maxConnNum\": 100, "
+    "{\"pageSize\": 4, \"redoFlushByTrx\": 2, \"redoPubBufSize\": 256, \"maxConnNum\": 100, "
     "\"bufferPoolSize\": 1024, \"crcCheckEnable\": 0, \"bufferPoolPolicy\" : \"BUF_PRIORITY_INDEX\", "
     "\"sharedModeEnable\" : 1, \"MetaInfoBak\": 1}";
 const int CREATE_COLLECTION_RETRY_TIMES = 2;
+const int DB_REPAIR_RETRY_TIMES = 3;
 
 void GRDDBApiInitEnhance(GRD_APIInfo &GRD_DBApiInfo)
 {
@@ -58,6 +63,8 @@ void GRDDBApiInitEnhance(GRD_APIInfo &GRD_DBApiInfo)
     GRD_DBApiInfo.FetchApi = (Fetch)dlsym(PreferenceDbAdapter::gLibrary_, "GRD_Fetch");
     GRD_DBApiInfo.FreeItemApi = (KVFreeItem)dlsym(PreferenceDbAdapter::gLibrary_, "GRD_KVFreeItem");
     GRD_DBApiInfo.FreeResultSetApi = (FreeResultSet)dlsym(PreferenceDbAdapter::gLibrary_, "GRD_FreeResultSet");
+    GRD_DBApiInfo.DbRepairApi = (DBRepair)dlsym(PreferenceDbAdapter::gLibrary_, "GRD_DBRepair");
+    GRD_DBApiInfo.DbGetConfigApi = (DBGetConfig)dlsym(PreferenceDbAdapter::gLibrary_, "GRD_GetConfig");
 #endif
 }
 
@@ -124,23 +131,41 @@ PreferencesDb::PreferencesDb()
 
 PreferencesDb::~PreferencesDb()
 {
-    if (db_ != nullptr) {
+    if (db_ != nullptr || PreferenceDbAdapter::GetApiInstance().DbCloseApi != nullptr) {
         PreferenceDbAdapter::GetApiInstance().DbCloseApi(db_, GRD_DB_CLOSE_IGNORE_ERROR);
         db_ = nullptr;
         LOG_DEBUG("destructor: calling close db.");
     } else {
-        LOG_DEBUG("destructor: db closed before.");
+        LOG_DEBUG("destructor: db closed before or dbClose api not loaded, db closed before ? %{public}d.",
+            db_ == nullptr);
     }
 }
 
+ReportParam PreferencesDb::GetReportParam(const std::string &info, uint32_t errCode)
+{
+    ReportParam reportParam = {
+        bundleName_,
+        ENHANCE_DB,
+        ExtractFileName(dbPath_),
+        errCode,
+        errno,
+        info};
+    return reportParam;
+}
+
 int PreferencesDb::CloseDb()
 {
     if (db_ != nullptr) {
-        int errCode = TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().DbCloseApi(db_,
-            GRD_DB_CLOSE_IGNORE_ERROR));
+        if (PreferenceDbAdapter::GetApiInstance().DbCloseApi == nullptr) {
+            LOG_ERROR("api load failed: DbCloseApi");
+            return E_ERROR;
+        }
+        int errCode = PreferenceDbAdapter::GetApiInstance().DbCloseApi(db_, GRD_DB_CLOSE_IGNORE_ERROR);
         if (errCode != E_OK) {
-            LOG_ERROR("close db failed, errcode=%{public}d", errCode);
-            return errCode;
+            LOG_ERROR("close db failed, errcode=%{public}d, file: %{public}s", errCode,
+                ExtractFileName(dbPath_).c_str());
+            PreferencesDfxManager::ReportDbFault(GetReportParam("close db failed", errCode));
+            return TransferGrdErrno(errCode);
         }
         LOG_INFO("db has been closed.");
         db_ = nullptr;
@@ -152,36 +177,116 @@ int PreferencesDb::CloseDb()
 
 int PreferencesDb::CreateCollection()
 {
-    int errCode = TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().DbCreateCollectionApi(db_, TABLENAME,
-        TABLE_MODE, 0));
-    if (errCode != E_OK) {
+    if (PreferenceDbAdapter::GetApiInstance().DbCreateCollectionApi == nullptr) {
+        LOG_ERROR("api load failed: DbCreateCollectionApi");
+        return E_ERROR;
+    }
+    int errCode = PreferenceDbAdapter::GetApiInstance().DbCreateCollectionApi(db_, TABLENAME,
+        TABLE_MODE, 0);
+    if (errCode != GRD_OK) {
         LOG_ERROR("rd create table failed:%{public}d", errCode);
+        PreferencesDfxManager::ReportDbFault(GetReportParam("create table failed", errCode));
+    }
+    return TransferGrdErrno(errCode);
+}
+
+int PreferencesDb::OpenDb(bool isNeedRebuild)
+{
+    if (PreferenceDbAdapter::GetApiInstance().DbOpenApi == nullptr) {
+        LOG_ERROR("api load failed: DbOpenApi");
+        return E_ERROR;
+    }
+    uint32_t flag = GRD_DB_OPEN_CREATE;
+    if (isNeedRebuild) {
+        flag |= GRD_DB_OPEN_CHECK;
+    }
+    int errCode = PreferenceDbAdapter::GetApiInstance().DbOpenApi(dbPath_.c_str(), CONFIG_STR, flag, &db_);
+    if (errCode != GRD_OK) {
+        // log outside
+        std::string errMsg = isNeedRebuild ? "open db failed with open_create | open_check" :
+                "open db failed with open_create";
+        LOG_ERROR("%{public}s, errCode: %{public}d, isRebuild:%{public}d", errMsg.c_str(), errCode, isNeedRebuild);
+        PreferencesDfxManager::ReportDbFault(GetReportParam(errMsg, errCode));
+    }
+    return errCode;
+}
+
+int PreferencesDb::RepairDb()
+{
+    if (PreferenceDbAdapter::GetApiInstance().DbRepairApi == nullptr) {
+        LOG_ERROR("api load failed: DbRepairApi");
+        return E_ERROR;
+    }
+    int errCode = PreferenceDbAdapter::GetApiInstance().DbRepairApi(dbPath_.c_str(), CONFIG_STR);
+    if (errCode != GRD_OK) {
+        std::string errMsg = "db repair failed";
+        LOG_ERROR("repair db failed, errCode: %{public}d", errCode);
+        PreferencesDfxManager::ReportDbFault(GetReportParam(errMsg, errCode));
     }
     return errCode;
 }
 
-int PreferencesDb::OpenDb()
+int PreferencesDb::TryRepairAndRebuild(int openCode)
 {
-    return TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().DbOpenApi(dbPath_.c_str(),
-        CONFIG_STR, GRD_DB_OPEN_CREATE, &db_));
+    LOG_ERROR("db corrupted, errCode: %{public}d, begin to rebuild, db: %{public}s", openCode,
+        ExtractFileName(dbPath_).c_str());
+    int retryTimes = DB_REPAIR_RETRY_TIMES;
+    int innerErr = GRD_OK;
+    do {
+        innerErr = RepairDb();
+        if (innerErr == GRD_OK) {
+            LOG_INFO("db repair success");
+            return innerErr;
+        } else if (innerErr == GRD_DB_BUSY) {
+            LOG_ERROR("db repair failed, busy, retry times : %{public}d, errCode: %{public}d",
+                (DB_REPAIR_RETRY_TIMES - retryTimes + 1), innerErr);
+#if !defined(WINDOWS_PLATFORM)
+            std::this_thread::sleep_for(WAIT_REPAIRE_TIMEOUT);
+#endif
+        } else {
+            // other error, break to rebuild
+            LOG_ERROR("db repair failed: %{public}d, begin to rebuild", innerErr);
+            break;
+        }
+        retryTimes--;
+    } while (retryTimes > 0);
+
+    innerErr = OpenDb(true);
+    if (innerErr == GRD_OK || innerErr == GRD_REBUILD_DATABASE) {
+        LOG_INFO("rebuild db success, errCode: %{public}d", innerErr);
+        return GRD_OK;
+    }
+    LOG_ERROR("rebuild db failed, errCode: %{public}d, file: %{public}s", innerErr, ExtractFileName(dbPath_).c_str());
+    return innerErr;
 }
 
-int PreferencesDb::Init(const std::string &dbPath)
+int PreferencesDb::Init(const std::string &dbPath, const std::string &bundleName)
 {
     if (db_ != nullptr) {
         LOG_DEBUG("Init: already init.");
         return E_OK;
     }
+    if (PreferenceDbAdapter::GetApiInstance().DbIndexPreloadApi == nullptr) {
+        LOG_ERROR("api load failed: DbIndexPreloadApi");
+        return E_ERROR;
+    }
     dbPath_ = dbPath + ".db";
-    int errCode = OpenDb();
-    if (errCode != E_OK) {
-        LOG_ERROR("rd open failed:%{public}d", errCode);
-        return errCode;
+    bundleName_ = bundleName;
+    int errCode = OpenDb(false);
+    if (errCode == GRD_DATA_CORRUPTED || errCode == GRD_FAILED_FILE_OPERATION || errCode == GRD_INNER_ERR) {
+        int innerErr = TryRepairAndRebuild(errCode);
+        if (innerErr != GRD_OK) {
+            // log inside
+            return TransferGrdErrno(innerErr);
+        }
+    } else if (errCode != GRD_OK) {
+        LOG_ERROR("db open failed, errCode: %{public}d", errCode);
+        return TransferGrdErrno(errCode);
     }
 
     errCode = CreateCollection();
     if (errCode != E_OK) {
-        LOG_ERROR("create collection failed when init, but ignored.");
+        LOG_ERROR("create collection failed when init: %{public}d, but ignored.", errCode);
         // ignore create collection error
     }
 
@@ -197,6 +302,9 @@ int PreferencesDb::Put(const std::vector<uint8_t> &key, const std::vector<uint8_
 {
     if (db_ == nullptr) {
         LOG_ERROR("Put failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbKvPutApi == nullptr) {
+        LOG_ERROR("api load failed: DbKvPutApi");
         return E_ERROR;
     }
 
@@ -208,27 +316,31 @@ int PreferencesDb::Put(const std::vector<uint8_t> &key, const std::vector<uint8_
     do {
         ret = PreferenceDbAdapter::GetApiInstance().DbKvPutApi(db_, TABLENAME, &innerKey, &innerVal);
         if (ret == GRD_UNDEFINED_TABLE) {
+            LOG_INFO("CreateCollection called when Put, file: %{public}s", ExtractFileName(dbPath_).c_str());
             (void)CreateCollection();
         } else {
-            ret = TransferGrdErrno(ret);
-            if (ret == E_OK) {
-                return ret;
+            if (ret == GRD_OK) {
+                return TransferGrdErrno(ret);
             } else {
                 LOG_ERROR("rd put failed:%{public}d", ret);
-                return ret;
+                PreferencesDfxManager::ReportDbFault(GetReportParam("rd put failed", ret));
+                return TransferGrdErrno(ret);
             }
         }
         retryTimes--;
     } while (retryTimes > 0);
 
     LOG_ERROR("rd put over retry times, errcode: :%{public}d", ret);
-    return ret;
+    return TransferGrdErrno(ret);
 }
 
 int PreferencesDb::Delete(const std::vector<uint8_t> &key)
 {
     if (db_ == nullptr) {
         LOG_ERROR("Delete failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbKvDelApi == nullptr) {
+        LOG_ERROR("api load failed: DbKvDelApi");
         return E_ERROR;
     }
 
@@ -239,27 +351,32 @@ int PreferencesDb::Delete(const std::vector<uint8_t> &key)
     do {
         ret = PreferenceDbAdapter::GetApiInstance().DbKvDelApi(db_, TABLENAME, &innerKey);
         if (ret == GRD_UNDEFINED_TABLE) {
+            LOG_INFO("CreateCollection called when Delete, file: %{public}s", ExtractFileName(dbPath_).c_str());
             (void)CreateCollection();
         } else {
-            ret = TransferGrdErrno(ret);
             if (ret == E_OK) {
-                return ret;
+                return TransferGrdErrno(ret);
             } else {
                 LOG_ERROR("rd delete failed:%{public}d", ret);
-                return ret;
+                PreferencesDfxManager::ReportDbFault(GetReportParam("rd delete failed", ret));
+                return TransferGrdErrno(ret);
             }
         }
         retryTimes--;
     } while (retryTimes > 0);
 
     LOG_ERROR("rd delete over retry times, errcode: :%{public}d", ret);
-    return ret;
+    return TransferGrdErrno(ret);
 }
 
 int PreferencesDb::Get(const std::vector<uint8_t> &key, std::vector<uint8_t> &value)
 {
     if (db_ == nullptr) {
         LOG_ERROR("Get failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbKvGetApi == nullptr ||
+        PreferenceDbAdapter::GetApiInstance().FreeItemApi == nullptr) {
+        LOG_ERROR("api load failed: DbKvGetApi or FreeItemApi");
         return E_ERROR;
     }
 
@@ -271,14 +388,14 @@ int PreferencesDb::Get(const std::vector<uint8_t> &key, std::vector<uint8_t> &va
     do {
         ret = PreferenceDbAdapter::GetApiInstance().DbKvGetApi(db_, TABLENAME, &innerKey, &innerVal);
         if (ret == GRD_UNDEFINED_TABLE) {
+            LOG_INFO("CreateCollection called when Get, file: %{public}s", ExtractFileName(dbPath_).c_str());
             (void)CreateCollection();
         } else {
-            ret = TransferGrdErrno(ret);
             if (ret == E_OK) {
                 break;
             } else {
                 LOG_ERROR("rd get failed:%{public}d", ret);
-                return ret;
+                return TransferGrdErrno(ret);
             }
         }
         retryTimes--;
@@ -286,46 +403,56 @@ int PreferencesDb::Get(const std::vector<uint8_t> &key, std::vector<uint8_t> &va
 
     if (retryTimes == 0) {
         LOG_ERROR("rd get over retry times, errcode: :%{public}d", ret);
-        return ret;
+        return TransferGrdErrno(ret);
     }
     value.resize(innerVal.dataLen);
     value = KvItemToBlob(innerVal);
     (void)PreferenceDbAdapter::GetApiInstance().FreeItemApi(&innerVal);
-    return E_OK;
+    return TransferGrdErrno(ret);
 }
 
 int PreferencesDb::GetAllInner(std::list<std::pair<std::vector<uint8_t>, std::vector<uint8_t>>> &data,
     GRD_ResultSet *resultSet)
 {
+    if (PreferenceDbAdapter::GetApiInstance().NextApi == nullptr ||
+        PreferenceDbAdapter::GetApiInstance().GetItemSizeApi == nullptr ||
+        PreferenceDbAdapter::GetApiInstance().FreeResultSetApi == nullptr ||
+        PreferenceDbAdapter::GetApiInstance().GetItemApi == nullptr) {
+        LOG_ERROR("api load failed: NextApi or GetItemSizeApi or FreeResultSetApi or GetItemApi");
+        return E_ERROR;
+    }
     int ret = E_OK;
     while (TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().NextApi(resultSet)) == E_OK) {
         std::pair<std::vector<uint8_t>, std::vector<uint8_t>> dataItem;
         uint32_t keySize = 0;
         uint32_t valueSize = 0;
-        ret = TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().GetItemSizeApi(resultSet, &keySize, &valueSize));
-        if (ret != E_OK) {
+        ret = PreferenceDbAdapter::GetApiInstance().GetItemSizeApi(resultSet, &keySize, &valueSize);
+        if (ret != GRD_OK) {
             LOG_ERROR("ger reulstSet kv size failed %{public}d", ret);
             PreferenceDbAdapter::GetApiInstance().FreeResultSetApi(resultSet);
-            return ret;
+            return TransferGrdErrno(ret);
         }
         dataItem.first.resize(keySize);
         dataItem.second.resize(valueSize);
-        ret = TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().GetItemApi(resultSet, dataItem.first.data(),
-            dataItem.second.data()));
+        ret = PreferenceDbAdapter::GetApiInstance().GetItemApi(resultSet, dataItem.first.data(),
+            dataItem.second.data());
         if (ret != E_OK) {
             LOG_ERROR("ger reulstSet failed %{public}d", ret);
             PreferenceDbAdapter::GetApiInstance().FreeResultSetApi(resultSet);
-            return ret;
+            return TransferGrdErrno(ret);
         }
         data.emplace_back(std::move(dataItem));
     }
-    return ret;
+    return TransferGrdErrno(ret);
 }
 
 int PreferencesDb::GetAll(std::list<std::pair<std::vector<uint8_t>, std::vector<uint8_t>>> &data)
 {
     if (db_ == nullptr) {
         LOG_ERROR("GetAll failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbKvFilterApi == nullptr) {
+        LOG_ERROR("api load failed: DbKvFilterApi");
         return E_ERROR;
     }
 
@@ -338,14 +465,14 @@ int PreferencesDb::GetAll(std::list<std::pair<std::vector<uint8_t>, std::vector<
     do {
         ret = PreferenceDbAdapter::GetApiInstance().DbKvFilterApi(db_, TABLENAME, &param, &resultSet);
         if (ret == GRD_UNDEFINED_TABLE) {
+            LOG_INFO("CreateCollection called when GetAll, file: %{public}s", ExtractFileName(dbPath_).c_str());
             (void)CreateCollection();
         } else {
-            ret = TransferGrdErrno(ret);
-            if (ret == E_OK) {
+            if (ret == GRD_OK) {
                 break;
             } else {
                 LOG_ERROR("rd kv filter failed:%{public}d", ret);
-                return ret;
+                return TransferGrdErrno(ret);
             }
         }
         retryTimes--;
@@ -353,7 +480,7 @@ int PreferencesDb::GetAll(std::list<std::pair<std::vector<uint8_t>, std::vector<
 
     if (retryTimes == 0) {
         LOG_ERROR("rd get over retry times, errcode: :%{public}d", ret);
-        return ret;
+        return TransferGrdErrno(ret);
     }
 
     return GetAllInner(data, resultSet);
@@ -363,14 +490,18 @@ int PreferencesDb::DropCollection()
 {
     if (db_ == nullptr) {
         LOG_ERROR("DropCollection failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbDropCollectionApi == nullptr) {
+        LOG_ERROR("api load failed: DbDropCollectionApi");
         return E_ERROR;
     }
 
-    int errCode = TransferGrdErrno(PreferenceDbAdapter::GetApiInstance().DbDropCollectionApi(db_, TABLENAME, 0));
+    int errCode = PreferenceDbAdapter::GetApiInstance().DbDropCollectionApi(db_, TABLENAME, 0);
     if (errCode != E_OK) {
         LOG_ERROR("rd drop collection failed:%{public}d", errCode);
+        PreferencesDfxManager::ReportDbFault(GetReportParam("rd drop collection failed", errCode));
     }
-    return errCode;
+    return TransferGrdErrno(errCode);
 }
 
 GRD_KVItemT PreferencesDb::BlobToKvItem(const std::vector<uint8_t> &blob)
@@ -386,5 +517,26 @@ std::vector<uint8_t> PreferencesDb::KvItemToBlob(GRD_KVItemT &item)
     return std::vector<uint8_t>(static_cast<uint8_t *>(item.data),
         static_cast<uint8_t *>(item.data) + item.dataLen);
 }
+
+int PreferencesDb::GetKernelDataVersion(int64_t &dataVersion)
+{
+    if (db_ == nullptr) {
+        LOG_ERROR("Get kernel data version failed, db has been closed.");
+        return E_ALREADY_CLOSED;
+    } else if (PreferenceDbAdapter::GetApiInstance().DbGetConfigApi == nullptr) {
+        LOG_ERROR("api load failed: DbGetConfigApi");
+        return E_ERROR;
+    }
+
+    GRD_DbValueT kernelDataVersion = PreferenceDbAdapter::GetApiInstance().DbGetConfigApi(db_,
+        GRD_ConfigTypeE::GRD_CONFIG_DATA_VERSION);
+    if (kernelDataVersion.type != GRD_DbDataTypeE::GRD_DB_DATATYPE_INTEGER) {
+        LOG_ERROR("get wrong data version type: %d", kernelDataVersion.type);
+        return E_ERROR;
+    }
+
+    dataVersion = kernelDataVersion.value.longValue;
+    return E_OK;
+}
 } // End of namespace NativePreferences
 } // End of namespace OHOS
\ No newline at end of file
diff --git a/preferences/frameworks/native/platform/src/preferences_dfx_adapter.cpp b/preferences/frameworks/native/platform/src/preferences_dfx_adapter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7b8883ebee21b07e7e77ca53cfda39565646565b
--- /dev/null
+++ b/preferences/frameworks/native/platform/src/preferences_dfx_adapter.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "preferences_dfx_adapter.h"
+
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <sstream>
+
+#include "log_print.h"
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+#include <thread>
+
+#include "accesstoken_kit.h"
+#include "hisysevent_c.h"
+#include "ipc_skeleton.h"
+#endif
+
+namespace OHOS {
+namespace NativePreferences {
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+std::string GetCurrentTime()
+{
+    auto now = std::chrono::system_clock::now();
+    auto now_ms = std::chrono::time_point_cast<std::chrono::microseconds>(now);
+    auto epoch = now_ms.time_since_epoch();
+    auto value = std::chrono::duration_cast<std::chrono::microseconds>(epoch);
+    auto timestamp = value.count();
+
+    std::time_t tt = std::chrono::system_clock::to_time_t(now);
+    std::tm *tm = std::localtime(&tt);
+    if (tm == nullptr) {
+        return "";
+    }
+
+    const int offset = 1000;
+    const int width = 3;
+    std::stringstream oss;
+    oss << std::put_time(tm, "%Y-%m-%d %H:%M:%S.") << std::setfill('0') << std::setw(width)
+        << ((timestamp / offset) % offset) << "." << std::setfill('0') << std::setw(width) << (timestamp % offset);
+    return oss.str();
+}
+
+std::string PreferencesDfxManager::GetModuleName()
+{
+    std::string moduleName = "";
+    auto tokenId = IPCSkeleton::GetCallingTokenID();
+    auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
+    if ((tokenType == Security::AccessToken::TOKEN_NATIVE) || (tokenType == Security::AccessToken::TOKEN_SHELL)) {
+        Security::AccessToken::NativeTokenInfo tokenInfo;
+        if (Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo) == 0) {
+            moduleName = tokenInfo.processName;
+        }
+    }
+    return moduleName;
+}
+
+void PreferencesDfxManager::ReportDbFault(const ReportParam &reportParam)
+{
+    std::thread thread([reportParam]() {
+        std::string nowTime = GetCurrentTime();
+        std::string moudleName = GetModuleName();
+        HiSysEventParam params[] = {
+            { .name = "BUNDLE_NAME",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(reportParam.bundleName.c_str()) },
+                .arraySize = 0 },
+            { .name = "MODULE_NAME",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(moudleName.c_str()) },
+                .arraySize = 0 },
+            { .name = "STORE_TYPE",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(reportParam.dbType.c_str()) },
+                .arraySize = 0 },
+            { .name = "STORE_NAME",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(reportParam.storeName.c_str()) },
+                .arraySize = 0 },
+            { .name = "SECURITY_LEVEL", .t = HISYSEVENT_UINT32, .v = { .ui32 = 0u }, .arraySize = 0 },
+            { .name = "PATH_AREA", .t = HISYSEVENT_UINT32, .v = { .ui32 = 0u }, .arraySize = 0 },
+            { .name = "ENCRYPT_STATUS", .t = HISYSEVENT_UINT32, .v = { .ui32 = 0u }, .arraySize = 0 },
+            { .name = "INTERGITY_CHECK", .t = HISYSEVENT_UINT32, .v = { .ui32 = 0u }, .arraySize = 0 },
+            { .name = "ERROR_CODE", .t = HISYSEVENT_UINT32, .v = { .ui32 = reportParam.errCode }, .arraySize = 0 },
+            { .name = "ERRNO", .t = HISYSEVENT_INT32, .v = { .i32 = reportParam.errnoCode }, .arraySize = 0 },
+            { .name = "APPENDIX",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(reportParam.appendix.c_str()) },
+                .arraySize = 0 },
+            { .name = "ERROR_TIME",
+                .t = HISYSEVENT_STRING,
+                .v = { .s = const_cast<char *>(nowTime.c_str()) },
+                .arraySize = 0 },
+        };
+        size_t len = sizeof(params) / sizeof(params[0]);
+        OH_HiSysEvent_Write(DISTRIBUTED_DATAMGR, EVENT_NAME_DB_CORRUPTED, HISYSEVENT_FAULT, params, len);
+    });
+    thread.detach();
+}
+#else
+std::string GetCurrentTime()
+{
+    return "";
+}
+
+std::string PreferencesDfxManager::GetModuleName()
+{
+    return "";
+}
+
+void PreferencesDfxManager::ReportDbFault(const ReportParam &reportParam)
+{
+}
+#endif
+} // End of namespace NativePreferences
+} // End of namespace OHOS
diff --git a/preferences/frameworks/native/platform/src/preferences_file_lock.cpp b/preferences/frameworks/native/platform/src/preferences_file_lock.cpp
index 054efa1165fce6eee5ede36dac0acf496db44121..dc4ae796d5cfac8573919d47e99a8f87fe81a68a 100644
--- a/preferences/frameworks/native/platform/src/preferences_file_lock.cpp
+++ b/preferences/frameworks/native/platform/src/preferences_file_lock.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "preferences_file_lock.h"
+#include "preferences_file_operation.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -27,16 +28,6 @@
 #include "visibility.h"
 namespace OHOS {
 namespace NativePreferences {
-
-static UNUSED_FUNCTION std::string ExtractFileName(const std::string &path)
-{
-    auto pos = path.rfind('/');
-    if (pos == std::string::npos) {
-        return path;
-    }
-    return path.substr(pos + 1);
-}
-
 std::map<std::string, std::shared_ptr<std::mutex>> PreferencesLockManager::inProcessMutexs_;
 std::mutex PreferencesLockManager::mapMutex_;
 
diff --git a/preferences/frameworks/native/src/preferences_base.cpp b/preferences/frameworks/native/src/preferences_base.cpp
index e1ab75aed4b54334a2caca6061ccb20c09e992da..4c07bc25445488f8594208dde21253fc63c028b8 100644
--- a/preferences/frameworks/native/src/preferences_base.cpp
+++ b/preferences/frameworks/native/src/preferences_base.cpp
@@ -161,7 +161,7 @@ int PreferencesBase::FlushSync()
 
 int PreferencesBase::RegisterObserver(std::shared_ptr<PreferencesObserver> preferencesObserver, RegisterMode mode)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> writeLock(obseverMetux_);
     if (mode == RegisterMode::LOCAL_CHANGE) {
         std::weak_ptr<PreferencesObserver> weakPreferencesObserver = preferencesObserver;
         localObservers_.push_back(weakPreferencesObserver);
@@ -178,13 +178,14 @@ int PreferencesBase::RegisterObserver(std::shared_ptr<PreferencesObserver> prefe
         }
         multiProcessObservers_.push_back(observer);
     }
+    LOG_INFO("The local observer subscribed succeeded.");
     return E_OK;
 }
 
 int PreferencesBase::UnRegisterDataObserver(std::shared_ptr<PreferencesObserver> preferencesObserver,
     const std::vector<std::string> &keys)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> writeLock(obseverMetux_);
     auto it = dataObserversMap_.find(preferencesObserver);
     if (it == dataObserversMap_.end()) {
         return E_OK;
@@ -218,10 +219,21 @@ int PreferencesBase::CloseDb()
     return E_OK;
 }
 
+std::pair<int, PreferencesValue> PreferencesBase::GetValue(const std::string &key, const PreferencesValue &defValue)
+{
+    return std::make_pair(E_OK, defValue);
+}
+
+std::pair<int, std::map<std::string, PreferencesValue>> PreferencesBase::GetAllData()
+{
+    std::map<std::string, PreferencesValue> map;
+    return std::make_pair(E_OK, map);
+}
+
 int PreferencesBase::RegisterDataObserver(std::shared_ptr<PreferencesObserver> preferencesObserver,
     const std::vector<std::string> &keys)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> writeLock(obseverMetux_);
     auto it = dataObserversMap_.find(preferencesObserver);
     if (it == dataObserversMap_.end()) {
         std::set<std::string> callKeys(keys.begin(), keys.end());
@@ -235,7 +247,7 @@ int PreferencesBase::RegisterDataObserver(std::shared_ptr<PreferencesObserver> p
 
 int PreferencesBase::UnRegisterObserver(std::shared_ptr<PreferencesObserver> preferencesObserver, RegisterMode mode)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::unique_lock<std::shared_mutex> writeLock(obseverMetux_);
     if (mode == RegisterMode::LOCAL_CHANGE) {
         for (auto it = localObservers_.begin(); it != localObservers_.end(); ++it) {
             std::weak_ptr<PreferencesObserver> weakPreferencesObserver = *it;
@@ -263,6 +275,7 @@ int PreferencesBase::UnRegisterObserver(std::shared_ptr<PreferencesObserver> pre
             break;
         }
     }
+    LOG_INFO("The observer unsubscribed succeeded.");
     return E_OK;
 }
 
diff --git a/preferences/frameworks/native/src/preferences_enhance_impl.cpp b/preferences/frameworks/native/src/preferences_enhance_impl.cpp
index 1fb05713bd13ccce9b46baa46ec045e504769286..d510e5519f7fc01a37a47ab431e49b1a3dab9924 100644
--- a/preferences/frameworks/native/src/preferences_enhance_impl.cpp
+++ b/preferences/frameworks/native/src/preferences_enhance_impl.cpp
@@ -24,6 +24,7 @@
 #include <thread>
 
 #include "executor_pool.h"
+#include "preferences_file_operation.h"
 #include "log_print.h"
 #include "preferences_observer_stub.h"
 #include "preferences_value.h"
@@ -32,6 +33,8 @@
 namespace OHOS {
 namespace NativePreferences {
 
+constexpr int32_t CACHED_THRESHOLDS = 512 * 1024; // we will cached big obj(len >= 512k)
+
 PreferencesEnhanceImpl::PreferencesEnhanceImpl(const Options &options): PreferencesBase(options)
 {
 }
@@ -46,7 +49,8 @@ int PreferencesEnhanceImpl::Init()
 {
     std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
     db_ = std::make_shared<PreferencesDb>();
-    return db_->Init(options_.filePath);
+    cachedDataVersion_ = 0;
+    return db_->Init(options_.filePath, options_.bundleName);
 }
 
 PreferencesValue PreferencesEnhanceImpl::Get(const std::string &key, const PreferencesValue &defValue)
@@ -54,12 +58,25 @@ PreferencesValue PreferencesEnhanceImpl::Get(const std::string &key, const Prefe
     if (CheckKey(key) != E_OK) {
         return defValue;
     }
-    std::shared_lock<std::shared_mutex> autoLock(dbMutex_);
+    // write lock here, get not support concurrence
+    std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
     if (db_ == nullptr) {
         LOG_ERROR("PreferencesEnhanceImpl:Get failed, db has been closed.");
         return defValue;
     }
 
+    int64_t kernelDataVersion = 0;
+    if (db_->GetKernelDataVersion(kernelDataVersion) != E_OK) {
+        LOG_ERROR("PreferencesEnhanceImpl:Get failed, get kernel data version failed.");
+        return defValue;
+    }
+    if (kernelDataVersion == cachedDataVersion_) {
+        auto it = largeCachedData_.find(key);
+        if (it != largeCachedData_.end()) {
+            return it->second;
+        }
+    }
+
     std::vector<uint8_t> oriKey(key.begin(), key.end());
     std::vector<uint8_t> oriValue;
     int errCode = db_->Get(oriKey, oriValue);
@@ -69,9 +86,13 @@ PreferencesValue PreferencesEnhanceImpl::Get(const std::string &key, const Prefe
     }
     auto item = PreferencesValueParcel::UnmarshallingPreferenceValue(oriValue);
     if (item.first != E_OK) {
-        LOG_ERROR("get key failed, errCode=%{public}d", errCode);
+        LOG_ERROR("get key failed, errCode=%{public}d", item.first);
         return defValue;
     }
+    if (oriValue.size() >= CACHED_THRESHOLDS) {
+        largeCachedData_.insert_or_assign(key, item.second);
+        cachedDataVersion_ = kernelDataVersion;
+    }
     return item.second;
 }
 
@@ -80,10 +101,22 @@ bool PreferencesEnhanceImpl::HasKey(const std::string &key)
     if (CheckKey(key) != E_OK) {
         return false;
     }
-    std::shared_lock<std::shared_mutex> autoLock(dbMutex_);
+    std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
     if (db_ == nullptr) {
         LOG_ERROR("PreferencesEnhanceImpl:HasKey failed, db has been closed.");
-        return E_ERROR;
+        return false;
+    }
+
+    int64_t kernelDataVersion = 0;
+    if (db_->GetKernelDataVersion(kernelDataVersion) != E_OK) {
+        LOG_ERROR("PreferencesEnhanceImpl:HasKey failed, get kernel data version failed.");
+        return false;
+    }
+    if (kernelDataVersion == cachedDataVersion_) {
+        auto it = largeCachedData_.find(key);
+        if (it != largeCachedData_.end()) {
+            return true;
+        }
     }
 
     std::vector<uint8_t> oriKey(key.begin(), key.end());
@@ -93,6 +126,15 @@ bool PreferencesEnhanceImpl::HasKey(const std::string &key)
         LOG_ERROR("get key failed, errCode=%{public}d", errCode);
         return false;
     }
+    if (oriValue.size() >= CACHED_THRESHOLDS) {
+        auto item = PreferencesValueParcel::UnmarshallingPreferenceValue(oriValue);
+        if (item.first != E_OK) {
+            LOG_WARN("haskey unmarshall failed, haskey return true, errCode=%{public}d", item.first);
+            return true;
+        }
+        largeCachedData_.insert_or_assign(key, item.second);
+        cachedDataVersion_ = kernelDataVersion;
+    }
     return true;
 }
 
@@ -127,6 +169,17 @@ int PreferencesEnhanceImpl::Put(const std::string &key, const PreferencesValue &
         return errCode;
     }
 
+    // update cached and version
+    if (oriValueLen >= CACHED_THRESHOLDS) {
+        largeCachedData_.insert_or_assign(key, value);
+        cachedDataVersion_ = cachedDataVersion_ == INT64_MAX ? 0 : cachedDataVersion_ + 1;
+    } else {
+        auto pos = largeCachedData_.find(key);
+        if (pos != largeCachedData_.end()) {
+            largeCachedData_.erase(pos);
+        }
+    }
+
     ExecutorPool::Task task = [pref = shared_from_this(), key, value] {
         PreferencesEnhanceImpl::NotifyPreferencesObserver(pref, key, value);
     };
@@ -153,6 +206,13 @@ int PreferencesEnhanceImpl::Delete(const std::string &key)
         return errCode;
     }
 
+    // update cached and version
+    auto it = largeCachedData_.find(key);
+    if (it != largeCachedData_.end()) {
+        largeCachedData_.erase(it);
+        cachedDataVersion_ = cachedDataVersion_ == INT64_MAX ? 0 : cachedDataVersion_ + 1;
+    }
+
     PreferencesValue value;
     ExecutorPool::Task task = [pref = shared_from_this(), key, value] {
         PreferencesEnhanceImpl::NotifyPreferencesObserver(pref, key, value);
@@ -161,12 +221,18 @@ int PreferencesEnhanceImpl::Delete(const std::string &key)
     return E_OK;
 }
 
-std::map<std::string, PreferencesValue> PreferencesEnhanceImpl::GetAll()
+std::pair<int, std::map<std::string, PreferencesValue>> PreferencesEnhanceImpl::GetAllInner()
 {
-    std::shared_lock<std::shared_mutex> autoLock(dbMutex_);
+    std::map<std::string, PreferencesValue> map;
     if (db_ == nullptr) {
         LOG_ERROR("PreferencesEnhanceImpl:GetAll failed, db has been closed.");
-        return {};
+        return std::make_pair(E_ALREADY_CLOSED, map);
+    }
+
+    int64_t kernelDataVersion = 0;
+    if (db_->GetKernelDataVersion(kernelDataVersion) != E_OK) {
+        LOG_ERROR("PreferencesEnhanceImpl:GetAll failed, get kernel data version failed.");
+        return std::make_pair(E_ERROR, map);
     }
 
     std::map<std::string, PreferencesValue> result;
@@ -174,7 +240,7 @@ std::map<std::string, PreferencesValue> PreferencesEnhanceImpl::GetAll()
     int errCode = db_->GetAll(data);
     if (errCode != E_OK) {
         LOG_ERROR("get all failed, errCode=%{public}d", errCode);
-        return {};
+        return std::make_pair(errCode, map);
     }
     for (auto it = data.begin(); it != data.end(); it++) {
         std::string key(it->first.begin(), it->first.end());
@@ -182,10 +248,21 @@ std::map<std::string, PreferencesValue> PreferencesEnhanceImpl::GetAll()
         result.insert({key, item.second});
         if (item.first != E_OK) {
             LOG_ERROR("get key failed, errCode=%{public}d", errCode);
-            return {};
+            return std::make_pair(item.first, map);
+        }
+        if (it->second.size() >= CACHED_THRESHOLDS) {
+            largeCachedData_.insert_or_assign(key, item.second);
         }
     }
-    return result;
+    cachedDataVersion_ = kernelDataVersion;
+    return std::make_pair(E_OK, result);
+}
+
+std::map<std::string, PreferencesValue> PreferencesEnhanceImpl::GetAll()
+{
+    std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
+    std::pair<int, std::map<std::string, PreferencesValue>> res = GetAllInner();
+    return res.second;
 }
 
 void PreferencesEnhanceImpl::NotifyPreferencesObserver(std::shared_ptr<PreferencesEnhanceImpl> pref,
@@ -194,6 +271,10 @@ void PreferencesEnhanceImpl::NotifyPreferencesObserver(std::shared_ptr<Preferenc
     std::shared_lock<std::shared_mutex> readLock(pref->mapSharedMutex_);
     LOG_DEBUG("notify observer size:%{public}zu", pref->dataObserversMap_.size());
     for (const auto &[weakPrt, keys] : pref->dataObserversMap_) {
+        auto itKey = keys.find(key);
+        if (itKey == keys.end()) {
+            continue;
+        }
         std::map<std::string, PreferencesValue> records = {{key, value}};
         if (std::shared_ptr<PreferencesObserver> sharedPtr = weakPrt.lock()) {
             LOG_DEBUG("dataChange observer call, resultSize:%{public}zu", records.size());
@@ -212,24 +293,52 @@ void PreferencesEnhanceImpl::NotifyPreferencesObserver(std::shared_ptr<Preferenc
     }
 }
 
+void PreferencesEnhanceImpl::NotifyPreferencesObserverBatchKeys(std::shared_ptr<PreferencesEnhanceImpl> pref,
+    const std::map<std::string, PreferencesValue> &data)
+{
+    for (const auto &[key, value] : data) {
+        NotifyPreferencesObserver(pref, key, value);
+    }
+}
+
 int PreferencesEnhanceImpl::Clear()
 {
     std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
+    LOG_INFO("Clear called, file: %{public}s", ExtractFileName(options_.filePath).c_str());
     if (db_ == nullptr) {
         LOG_ERROR("PreferencesEnhanceImpl:Clear failed, db has been closed.");
         return E_ERROR;
     }
 
+    std::pair<int, std::map<std::string, PreferencesValue>> res = GetAllInner();
+    if (res.first != E_OK) {
+        LOG_ERROR("get all failed when clear, errCode=%{public}d", res.first);
+        return res.first;
+    }
+
+    std::map<std::string, PreferencesValue> allData = res.second;
+
     int errCode = db_->DropCollection();
     if (errCode != E_OK) {
         LOG_ERROR("drop collection failed when clear, errCode=%{public}d", errCode);
         return errCode;
     }
+
+    if (!allData.empty()) {
+        ExecutorPool::Task task = [pref = shared_from_this(), allData] {
+            PreferencesEnhanceImpl::NotifyPreferencesObserverBatchKeys(pref, allData);
+        };
+        executorPool_.Execute(std::move(task));
+    }
+
     errCode = db_->CreateCollection();
     if (errCode != E_OK) {
         LOG_ERROR("create collection failed when clear, errCode=%{public}d", errCode);
+        return errCode;
     }
-    return errCode;
+    largeCachedData_.clear();
+    cachedDataVersion_ = cachedDataVersion_ == INT64_MAX ? 0 : cachedDataVersion_ + 1;
+    return E_OK;
 }
 
 int PreferencesEnhanceImpl::CloseDb()
@@ -244,9 +353,60 @@ int PreferencesEnhanceImpl::CloseDb()
         LOG_ERROR("PreferencesEnhanceImpl:CloseDb failed.");
         return errCode;
     }
+    largeCachedData_.clear();
     db_ = nullptr;
     return E_OK;
 }
 
+std::pair<int, PreferencesValue> PreferencesEnhanceImpl::GetValue(const std::string &key,
+    const PreferencesValue &defValue)
+{
+    int errCode = CheckKey(key);
+    if (errCode != E_OK) {
+        return std::make_pair(errCode, defValue);
+    }
+    // write lock here, get not support concurrence
+    std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
+    if (db_ == nullptr) {
+        LOG_ERROR("PreferencesEnhanceImpl:Get failed, db has been closed.");
+        return std::make_pair(E_ALREADY_CLOSED, defValue);
+    }
+
+    int64_t kernelDataVersion = 0;
+    if (db_->GetKernelDataVersion(kernelDataVersion) != E_OK) {
+        LOG_ERROR("PreferencesEnhanceImpl:Get failed, get kernel data version failed.");
+        return std::make_pair(E_ERROR, defValue);
+    }
+    if (kernelDataVersion == cachedDataVersion_) {
+        auto it = largeCachedData_.find(key);
+        if (it != largeCachedData_.end()) {
+            return std::make_pair(E_OK, it->second);
+        }
+    }
+
+    std::vector<uint8_t> oriKey(key.begin(), key.end());
+    std::vector<uint8_t> oriValue;
+    errCode = db_->Get(oriKey, oriValue);
+    if (errCode != E_OK) {
+        LOG_ERROR("get key failed, errCode=%{public}d", errCode);
+        return std::make_pair(errCode, defValue);
+    }
+    auto item = PreferencesValueParcel::UnmarshallingPreferenceValue(oriValue);
+    if (item.first != E_OK) {
+        LOG_ERROR("get key failed, errCode=%{public}d", item.first);
+        return std::make_pair(item.first, defValue);
+    }
+    if (oriValue.size() >= CACHED_THRESHOLDS) {
+        largeCachedData_.insert_or_assign(key, item.second);
+        cachedDataVersion_ = kernelDataVersion;
+    }
+    return std::make_pair(E_OK, item.second);
+}
+    
+std::pair<int, std::map<std::string, PreferencesValue>> PreferencesEnhanceImpl::GetAllData()
+{
+    std::unique_lock<std::shared_mutex> writeLock(dbMutex_);
+    return GetAllInner();
+}
 } // End of namespace NativePreferences
 } // End of namespace OHOS
diff --git a/preferences/frameworks/native/src/preferences_helper.cpp b/preferences/frameworks/native/src/preferences_helper.cpp
index 0a26ca476b68f3702873ba27b0f81e0dd2cd6c98..c59c60b846a9c8fd30aead7fab12eda5b1c36bec 100644
--- a/preferences/frameworks/native/src/preferences_helper.cpp
+++ b/preferences/frameworks/native/src/preferences_helper.cpp
@@ -26,12 +26,15 @@
 #include "preferences_errno.h"
 #include "preferences_file_lock.h"
 #include "preferences_file_operation.h"
+#include "preferences_dfx_adapter.h"
 #include "preferences_impl.h"
 #include "preferences_enhance_impl.h"
 namespace OHOS {
 namespace NativePreferences {
 std::map<std::string, std::pair<std::shared_ptr<Preferences>, bool>> PreferencesHelper::prefsCache_;
 std::mutex PreferencesHelper::prefsCacheMutex_;
+static constexpr const int DB_SUFFIX_NUM = 6;
+static constexpr const char *DB_SUFFIX[DB_SUFFIX_NUM] = { ".ctrl", ".ctrl.dwr", ".redo", ".undo", ".safe", ".map" };
 
 static bool IsFileExist(const std::string &path)
 {
@@ -39,42 +42,27 @@ static bool IsFileExist(const std::string &path)
     return (stat(path.c_str(), &buffer) == 0);
 }
 
+static int RemoveEnhanceDb(const std::string &filePath)
+{
+    if (std::remove(filePath.c_str()) != 0) {
+        LOG_ERROR("remove %{public}s failed.", ExtractFileName(filePath).c_str());
+        return E_DELETE_FILE_FAIL;
+    }
+    return E_OK;
+}
+
 static int RemoveEnhanceDbFileIfNeed(const std::string &filePath)
 {
     std::string dbFilePath = filePath + ".db";
-    if (IsFileExist(dbFilePath) && std::remove(dbFilePath.c_str()) != 0) {
+    if (IsFileExist(dbFilePath) && RemoveEnhanceDb(dbFilePath) != E_OK) {
         LOG_ERROR("remove dbFilePath failed.");
         return E_DELETE_FILE_FAIL;
     }
-    std::string tmpFilePath = dbFilePath + ".ctrl";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrlFile failed.");
-        return E_DELETE_FILE_FAIL;
-    }
-    tmpFilePath = dbFilePath + ".ctrl.dwr";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrl dwr File failed.");
-        return E_DELETE_FILE_FAIL;
-    }
-    tmpFilePath = dbFilePath + ".redo";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrlFile failed.");
-        return E_DELETE_FILE_FAIL;
-    }
-    tmpFilePath = dbFilePath + ".undo";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrlFile failed.");
-        return E_DELETE_FILE_FAIL;
-    }
-    tmpFilePath = dbFilePath + ".safe";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrlFile failed.");
-        return E_DELETE_FILE_FAIL;
-    }
-    tmpFilePath = dbFilePath + ".map";
-    if (IsFileExist(tmpFilePath) && std::remove(tmpFilePath.c_str()) != 0) {
-        LOG_ERROR("remove ctrlFile failed.");
-        return E_DELETE_FILE_FAIL;
+    for (int index = 0; index < DB_SUFFIX_NUM; index++) {
+        std::string tmpFilePath = dbFilePath + DB_SUFFIX[index];
+        if (IsFileExist(tmpFilePath) && RemoveEnhanceDb(tmpFilePath) != E_OK) {
+            return E_DELETE_FILE_FAIL;
+        }
     }
     LOG_DEBUG("db files has been removed.");
     return E_OK;
@@ -133,13 +121,18 @@ static bool IsUseEnhanceDb(const Options &options)
     if (IsFileExist(options.filePath)) {
         return false;
     }
-    PreferenceDbAdapter::ApiInit();
-    return (options.bundleName.find("uttest") != std::string::npos ||
+    bool bundleCheck = (options.bundleName.find("uttest") != std::string::npos ||
         options.bundleName.find("alipay") != std::string::npos ||
         options.bundleName.find("com.jd.") != std::string::npos ||
         options.bundleName.find("cmblife") != std::string::npos ||
         options.bundleName.find("os.mms") != std::string::npos ||
-        options.bundleName.find("meetimeservice") != std::string::npos) && PreferenceDbAdapter::IsEnhandceDbEnable();
+        options.bundleName.find("os.ouc") != std::string::npos ||
+        options.bundleName.find("meetimeservice") != std::string::npos);
+    if (!options.isEnhance && !bundleCheck) {
+        return false;
+    }
+    PreferenceDbAdapter::ApiInit();
+    return PreferenceDbAdapter::IsEnhandceDbEnable();
 }
 #endif
 
@@ -201,6 +194,7 @@ int PreferencesHelper::DeletePreferences(const std::string &path)
         if (it != prefsCache_.end()) {
             auto pref = it->second.first;
             if (pref != nullptr) {
+                LOG_INFO("Begin to Delete Preferences: %{public}s", ExtractFileName(path).c_str());
                 dataGroupId = pref->GetGroupId();
                 errCode = pref->CloseDb();
                 if (errCode != E_OK) {
@@ -210,9 +204,9 @@ int PreferencesHelper::DeletePreferences(const std::string &path)
             }
             pref = nullptr;
             prefsCache_.erase(it);
-            LOG_INFO("DeletePreferences: found preferences in cache, erase it.");
+            LOG_DEBUG("DeletePreferences: found preferences in cache, erase it.");
         } else {
-            LOG_INFO("DeletePreferences: cache not found, just delete files.");
+            LOG_DEBUG("DeletePreferences: cache not found, just delete files.");
         }
     }
 
@@ -250,7 +244,7 @@ int PreferencesHelper::RemovePreferencesFromCache(const std::string &path)
     std::lock_guard<std::mutex> lock(prefsCacheMutex_);
     std::map<std::string, std::pair<std::shared_ptr<Preferences>, bool>>::iterator it = prefsCache_.find(realPath);
     if (it == prefsCache_.end()) {
-        LOG_INFO("RemovePreferencesFromCache: preferences not in cache, just return");
+        LOG_DEBUG("RemovePreferencesFromCache: preferences not in cache, just return");
         return E_OK;
     }
 
diff --git a/preferences/frameworks/native/src/preferences_impl.cpp b/preferences/frameworks/native/src/preferences_impl.cpp
index 238fc0b332f2a767263bcf6cf109bc192f82519a..2230f36dcadaa601eb42634cb8748050d5972ec8 100644
--- a/preferences/frameworks/native/src/preferences_impl.cpp
+++ b/preferences/frameworks/native/src/preferences_impl.cpp
@@ -30,6 +30,8 @@
 #include "log_print.h"
 #include "preferences_observer_stub.h"
 #include "preferences_xml_utils.h"
+#include "preferences_file_operation.h"
+#include "preferences_anonymous.h"
 
 namespace OHOS {
 namespace NativePreferences {
@@ -37,6 +39,7 @@ namespace NativePreferences {
 using namespace std::chrono;
 
 constexpr int32_t WAIT_TIME = 2;
+constexpr int32_t TASK_EXEC_TIME = 100;
 
 template<typename T>
 std::string GetTypeName()
@@ -122,10 +125,12 @@ std::string GetTypeName<BigInt>()
     return "BigInt";
 }
 
-PreferencesImpl::PreferencesImpl(const Options &options) : PreferencesBase(options), loaded_(false)
+PreferencesImpl::PreferencesImpl(const Options &options) : PreferencesBase(options)
 {
+    loaded_.store(false);
     currentMemoryStateGeneration_ = 0;
     diskStateGeneration_ = 0;
+    queue_ = std::make_shared<SafeBlockQueue<uint64_t>>(1);
 }
 
 PreferencesImpl::~PreferencesImpl()
@@ -142,10 +147,7 @@ int PreferencesImpl::Init()
 
 bool PreferencesImpl::StartLoadFromDisk()
 {
-    {
-        std::lock_guard<std::mutex> lock(mutex_);
-        loaded_ = false;
-    }
+    loaded_.store(false);
 
     ExecutorPool::Task task = [pref = shared_from_this()] { PreferencesImpl::LoadFromDisk(pref); };
     return (executorPool_.Execute(std::move(task)) == ExecutorPool::INVALID_TASK_ID) ? false : true;
@@ -154,58 +156,33 @@ bool PreferencesImpl::StartLoadFromDisk()
 /* static */
 void PreferencesImpl::LoadFromDisk(std::shared_ptr<PreferencesImpl> pref)
 {
-    std::lock_guard<std::mutex> lock(pref->mutex_);
-    if (pref->loaded_) {
+    if (pref->loaded_.load()) {
         return;
     }
-    bool loadResult = pref->ReadSettingXml(pref);
-    if (!loadResult) {
-        auto time = static_cast<uint64_t>(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
-        LOG_ERROR("The settingXml load failed. times %{public}" PRIu64 ".", time);
+    std::lock_guard<std::mutex> lock(pref->mutex_);
+    if (!pref->loaded_.load()) {
+        bool loadResult = PreferencesImpl::ReadSettingXml(pref);
+        if (!loadResult) {
+            LOG_WARN("The settingXml %{public}s load failed.", ExtractFileName(pref->options_.filePath).c_str());
+        }
+        pref->loaded_.store(true);
+        pref->cond_.notify_all();
     }
-    pref->loaded_ = true;
-    pref->cond_.notify_all();
 }
 
 void PreferencesImpl::AwaitLoadFile()
 {
-    std::unique_lock<std::mutex> lock(mutex_);
-    if (!loaded_) {
-        cond_.wait_for(lock, std::chrono::seconds(WAIT_TIME), [this] { return loaded_; });
-    }
-
-    if (!loaded_) {
-        LOG_ERROR("The settingXml load timeout.");
-    }
-}
-
-void PreferencesImpl::WriteToDiskFile(std::shared_ptr<PreferencesImpl> pref, std::shared_ptr<MemoryToDiskRequest> mcr)
-{
-    std::unique_lock<std::mutex> lock(pref->mutex_);
-    if (!pref->CheckRequestValidForStateGeneration(mcr)) {
-        mcr->SetDiskWriteResult(true, E_OK);
+    if (loaded_.load()) {
         return;
     }
-
-    if (pref->WriteSettingXml(pref, mcr->writeToDiskMap_)) {
-        pref->diskStateGeneration_ = mcr->memoryStateGeneration_;
-        mcr->SetDiskWriteResult(true, E_OK);
-    } else {
-        mcr->SetDiskWriteResult(false, E_ERROR);
-    }
-}
-
-bool PreferencesImpl::CheckRequestValidForStateGeneration(std::shared_ptr<MemoryToDiskRequest> mcr)
-{
-    if (diskStateGeneration_ >= mcr->memoryStateGeneration_) {
-        LOG_DEBUG("DiskStateGeneration should be less than memoryStateGeneration.");
-        return false;
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (!loaded_.load()) {
+        cond_.wait_for(lock, std::chrono::seconds(WAIT_TIME), [this] { return loaded_.load(); });
     }
 
-    if (mcr->isSyncRequest_ || currentMemoryStateGeneration_ == mcr->memoryStateGeneration_) {
-        return true;
+    if (!loaded_.load()) {
+        LOG_ERROR("The settingXml %{public}s load timeout.", ExtractFileName(options_.filePath).c_str());
     }
-    return false;
 }
 
 PreferencesValue PreferencesImpl::Get(const std::string &key, const PreferencesValue &defValue)
@@ -215,10 +192,10 @@ PreferencesValue PreferencesImpl::Get(const std::string &key, const PreferencesV
     }
 
     AwaitLoadFile();
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto iter = map_.find(key);
-    if (iter != map_.end()) {
-        return iter->second;
+
+    auto it = valuesCache_.Find(key);
+    if (it.first) {
+        return it.second;
     }
     return defValue;
 }
@@ -226,8 +203,7 @@ PreferencesValue PreferencesImpl::Get(const std::string &key, const PreferencesV
 std::map<std::string, PreferencesValue> PreferencesImpl::GetAll()
 {
     AwaitLoadFile();
-    std::lock_guard<std::mutex> lock(mutex_);
-    return map_;
+    return valuesCache_.Clone();
 }
 
 template<typename T>
@@ -273,7 +249,7 @@ static void Convert2PrefValue(const Element &element, BigInt &value)
 template<typename T>
 bool GetPrefValue(const Element &element, T &value)
 {
-    LOG_WARN("unknown element type. the key is %{public}s", element.key_.c_str());
+    LOG_WARN("unknown element type. the key is %{public}s", Anonymous::ToBeAnonymous(element.key_).c_str());
     return false;
 }
 
@@ -318,13 +294,16 @@ void ReadXmlElement(const Element &element, std::map<std::string, PreferencesVal
 bool PreferencesImpl::ReadSettingXml(std::shared_ptr<PreferencesImpl> pref)
 {
     std::vector<Element> settings;
-    if (!PreferencesXmlUtils::ReadSettingXml(pref->options_.filePath, pref->options_.dataGroupId, settings)) {
+    if (!PreferencesXmlUtils::ReadSettingXml(pref->options_.filePath, pref->options_.bundleName,
+        pref->options_.dataGroupId, settings)) {
         return false;
     }
 
+    std::map<std::string, PreferencesValue> values;
     for (const auto &element : settings) {
-        ReadXmlElement(element, pref->map_);
+        ReadXmlElement(element, values);
     }
+    pref->valuesCache_ = std::move(values);
     return true;
 }
 
@@ -382,7 +361,7 @@ void Convert2Element(Element &elem, const BigInt &value)
 
 template<typename T> void GetElement(Element &elem, const T &value)
 {
-    LOG_WARN("unknown element type. the key is %{public}s", elem.key_.c_str());
+    LOG_WARN("unknown element type. the key is %{public}s", Anonymous::ToBeAnonymous(elem.key_).c_str());
 }
 
 template<typename T, typename First, typename... Types> void GetElement(Element &elem, const T &value)
@@ -405,10 +384,10 @@ void WriteXmlElement(Element &elem, const PreferencesValue &value)
 }
 
 bool PreferencesImpl::WriteSettingXml(
-    std::shared_ptr<PreferencesImpl> pref, const std::map<std::string, PreferencesValue> &prefMap)
+    const Options &options, const std::map<std::string, PreferencesValue> &writeToDiskMap)
 {
     std::vector<Element> settings;
-    for (auto it = prefMap.begin(); it != prefMap.end(); it++) {
+    for (auto it = writeToDiskMap.begin(); it != writeToDiskMap.end(); it++) {
         Element elem;
         elem.key_ = it->first;
         PreferencesValue value = it->second;
@@ -416,9 +395,10 @@ bool PreferencesImpl::WriteSettingXml(
         settings.push_back(elem);
     }
 
-    return PreferencesXmlUtils::WriteSettingXml(pref->options_.filePath, pref->options_.dataGroupId, settings);
+    return PreferencesXmlUtils::WriteSettingXml(options.filePath, options.bundleName, options.dataGroupId, settings);
 }
 
+
 bool PreferencesImpl::HasKey(const std::string &key)
 {
     if (CheckKey(key) != E_OK) {
@@ -426,9 +406,7 @@ bool PreferencesImpl::HasKey(const std::string &key)
     }
 
     AwaitLoadFile();
-
-    std::lock_guard<std::mutex> lock(mutex_);
-    return (map_.find(key) != map_.end());
+    return valuesCache_.Contains(key);
 }
 
 int PreferencesImpl::Put(const std::string &key, const PreferencesValue &value)
@@ -443,17 +421,14 @@ int PreferencesImpl::Put(const std::string &key, const PreferencesValue &value)
     }
     AwaitLoadFile();
 
-    std::lock_guard<std::mutex> lock(mutex_);
-
-    auto iter = map_.find(key);
-    if (iter != map_.end()) {
-        PreferencesValue &val = iter->second;
+    valuesCache_.Compute(key, [this, &value](auto &key, PreferencesValue &val) {
         if (val == value) {
-            return E_OK;
+            return true;
         }
-    }
-    map_.insert_or_assign(key, value);
-    modifiedKeys_.push_back(key);
+        val = value;
+        modifiedKeys_.push_back(key);
+        return true;
+    });
     return E_OK;
 }
 
@@ -464,90 +439,127 @@ int PreferencesImpl::Delete(const std::string &key)
         return errCode;
     }
     AwaitLoadFile();
-
-    std::lock_guard<std::mutex> lock(mutex_);
-
-    auto pos = map_.find(key);
-    if (pos != map_.end()) {
-        map_.erase(pos);
+    valuesCache_.EraseIf(key, [this](auto &key, PreferencesValue &val) {
         modifiedKeys_.push_back(key);
-    }
-
+        return true;
+    });
     return E_OK;
 }
 
 int PreferencesImpl::Clear()
 {
     AwaitLoadFile();
-    std::lock_guard<std::mutex> lock(mutex_);
+    valuesCache_.EraseIf([this](auto &key, PreferencesValue &val) {
+        modifiedKeys_.push_back(key);
+        return true;
+    });
+    return E_OK;
+}
 
-    if (!map_.empty()) {
-        for (auto &kv : map_) {
-            modifiedKeys_.push_back(kv.first);
+int PreferencesImpl::WriteToDiskFile(std::shared_ptr<PreferencesImpl> pref)
+{
+    std::list<std::string> keysModified;
+    std::map<std::string, PreferencesValue> writeToDiskMap;
+    pref->valuesCache_.DoActionWhenClone(
+        [pref, &writeToDiskMap, &keysModified](const std::map<std::string, PreferencesValue> &map) {
+        if (!pref->modifiedKeys_.empty()) {
+            keysModified = std::move(pref->modifiedKeys_);
         }
-        map_.clear();
+        writeToDiskMap = std::move(map);
+    });
+
+    // Cache has not changed, Not need to write persistent files.
+    if (keysModified.empty()) {
+        LOG_INFO("No data to update persistent file");
+        return E_OK;
     }
+    if (!pref->WriteSettingXml(pref->options_, writeToDiskMap)) {
+        return E_ERROR;
+    }
+    pref->NotifyPreferencesObserver(keysModified, writeToDiskMap);
     return E_OK;
 }
 
 void PreferencesImpl::Flush()
 {
-    std::shared_ptr<PreferencesImpl::MemoryToDiskRequest> request = commitToMemory();
-    request->isSyncRequest_ = false;
-    ExecutorPool::Task task = [pref = shared_from_this(), request] { PreferencesImpl::WriteToDiskFile(pref, request); };
-    executorPool_.Execute(std::move(task));
-
-    NotifyPreferencesObserver(*request);
+    auto success = queue_->PushNoWait(1);
+    if (success) {
+        std::weak_ptr<SafeBlockQueue<uint64_t>> queue = queue_;
+        ExecutorPool::Task task = [queue, self = weak_from_this()] {
+            auto realQueue = queue.lock();
+            auto realThis = self.lock();
+            if (realQueue == nullptr || realThis == nullptr) {
+                return ;
+            }
+            uint64_t value = 0;
+            std::lock_guard<std::mutex> lock(realThis->mutex_);
+            auto has = realQueue->PopNotWait(value);
+            if (has && value == 1) {
+                PreferencesImpl::WriteToDiskFile(realThis);
+            }
+        };
+        executorPool_.Schedule(std::chrono::milliseconds(TASK_EXEC_TIME), std::move(task));
+    }
 }
 
 int PreferencesImpl::FlushSync()
 {
-    std::shared_ptr<PreferencesImpl::MemoryToDiskRequest> request = commitToMemory();
-    request->isSyncRequest_ = true;
-    PreferencesImpl::WriteToDiskFile(shared_from_this(), request);
-    if (request->wasWritten_) {
-        LOG_DEBUG("Successfully written to disk file, memory state generation is %{public}" PRId64 "",
-            request->memoryStateGeneration_);
+    auto success = queue_->PushNoWait(1);
+    if (success) {
+        if (queue_ == nullptr) {
+            return E_ERROR;
+        }
+        uint64_t value = 0;
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto has = queue_->PopNotWait(value);
+        if (has && value == 1) {
+            return PreferencesImpl::WriteToDiskFile(shared_from_this());
+        }
     }
-    NotifyPreferencesObserver(*request);
-    return request->writeToDiskResult_;
+    return E_OK;
 }
 
-std::shared_ptr<PreferencesImpl::MemoryToDiskRequest> PreferencesImpl::commitToMemory()
+std::pair<int, PreferencesValue> PreferencesImpl::GetValue(const std::string &key, const PreferencesValue &defValue)
 {
+    int errCode = CheckKey(key);
+    if (errCode != E_OK) {
+        return std::make_pair(errCode, defValue);
+    }
+
+    AwaitLoadFile();
     std::lock_guard<std::mutex> lock(mutex_);
-    int64_t memoryStateGeneration = -1;
-    std::list<std::string> keysModified;
-    std::vector<std::weak_ptr<PreferencesObserver>> preferencesObservers;
-    std::map<std::string, PreferencesValue> writeToDiskMap;
-    writeToDiskMap = map_;
-    if (!modifiedKeys_.empty()) {
-        currentMemoryStateGeneration_++;
-        keysModified = modifiedKeys_;
-        modifiedKeys_.clear();
+    auto iter = valuesCache_.Find(key);
+    if (iter.first) {
+        return std::make_pair(E_OK, iter.second);
     }
-    memoryStateGeneration = currentMemoryStateGeneration_;
-    preferencesObservers = localObservers_;
-    return std::make_shared<MemoryToDiskRequest>(
-        writeToDiskMap, keysModified, preferencesObservers, memoryStateGeneration, dataObserversMap_);
+    return std::make_pair(E_ERROR, defValue);
+}
+    
+std::pair<int, std::map<std::string, PreferencesValue>> PreferencesImpl::GetAllData()
+{
+    AwaitLoadFile();
+    std::lock_guard<std::mutex> lock(mutex_);
+    return std::make_pair(E_OK, valuesCache_.Clone());
 }
 
-void PreferencesImpl::NotifyPreferencesObserver(const PreferencesImpl::MemoryToDiskRequest &request)
+void PreferencesImpl::NotifyPreferencesObserver(const std::list<std::string> &keysModified,
+    const std::map<std::string, PreferencesValue> &writeToDiskMap)
 {
-    if (request.keysModified_.empty()) {
+    if (keysModified.empty()) {
         return;
     }
-    LOG_DEBUG("notify observer size:%{public}zu", request.dataObserversMap_.size());
-    for (const auto &[weakPrt, keys] : request.dataObserversMap_) {
+    LOG_DEBUG("notify observer size:%{public}zu", dataObserversMap_.size());
+    std::shared_lock<std::shared_mutex> autoLock(obseverMetux_);
+    for (const auto &[weakPrt, keys] : dataObserversMap_) {
         std::map<std::string, PreferencesValue> records;
-        for (auto key = request.keysModified_.begin(); key != request.keysModified_.end(); ++key) {
+        for (auto key = keysModified.begin(); key != keysModified.end(); ++key) {
             auto itKey = keys.find(*key);
             if (itKey == keys.end()) {
                 continue;
             }
             PreferencesValue value;
-            auto dataIt = request.writeToDiskMap_.find(*key);
-            if (dataIt != request.writeToDiskMap_.end()) {
+            auto dataIt = writeToDiskMap.find(*key);
+            if (dataIt != writeToDiskMap.end()) {
                 value = dataIt->second;
             }
             records.insert({*key, value});
@@ -562,8 +574,8 @@ void PreferencesImpl::NotifyPreferencesObserver(const PreferencesImpl::MemoryToD
     }
 
     auto dataObsMgrClient = DataObsMgrClient::GetInstance();
-    for (auto key = request.keysModified_.begin(); key != request.keysModified_.end(); ++key) {
-        for (auto it = request.localObservers_.begin(); it != request.localObservers_.end(); ++it) {
+    for (auto key = keysModified.begin(); key != keysModified.end(); ++key) {
+        for (auto it = localObservers_.begin(); it != localObservers_.end(); ++it) {
             std::weak_ptr<PreferencesObserver> weakPreferencesObserver = *it;
             if (std::shared_ptr<PreferencesObserver> sharedPreferencesObserver = weakPreferencesObserver.lock()) {
                 sharedPreferencesObserver->OnChange(*key);
@@ -573,30 +585,10 @@ void PreferencesImpl::NotifyPreferencesObserver(const PreferencesImpl::MemoryToD
         if (dataObsMgrClient == nullptr) {
             continue;
         }
+        LOG_INFO("The %{public}s is changed, the observer needs to be triggered.",
+            Anonymous::ToBeAnonymous(*key).c_str());
         dataObsMgrClient->NotifyChange(MakeUri(*key));
     }
 }
-
-PreferencesImpl::MemoryToDiskRequest::MemoryToDiskRequest(
-    const std::map<std::string, PreferencesValue> &writeToDiskMap, const std::list<std::string> &keysModified,
-    const std::vector<std::weak_ptr<PreferencesObserver>> preferencesObservers, int64_t memStataGeneration,
-    const DataObserverMap preferencesDataObservers)
-{
-    writeToDiskMap_ = writeToDiskMap;
-    keysModified_ = keysModified;
-    localObservers_ = preferencesObservers;
-    memoryStateGeneration_ = memStataGeneration;
-    isSyncRequest_ = false;
-    wasWritten_ = false;
-    writeToDiskResult_ = E_ERROR;
-    dataObserversMap_ = preferencesDataObservers;
-}
-
-void PreferencesImpl::MemoryToDiskRequest::SetDiskWriteResult(bool wasWritten, int result)
-{
-    writeToDiskResult_ = result;
-    wasWritten_ = wasWritten;
-    reqCond_.notify_one();
-}
 } // End of namespace NativePreferences
 } // End of namespace OHOS
diff --git a/preferences/frameworks/native/src/preferences_value_parcel.cpp b/preferences/frameworks/native/src/preferences_value_parcel.cpp
index 435755a42f179c0e4509407dd4516fcfb1bb3dd0..faeac979d36b386fb61cdb8dfb3ef1250197d9a1 100644
--- a/preferences/frameworks/native/src/preferences_value_parcel.cpp
+++ b/preferences/frameworks/native/src/preferences_value_parcel.cpp
@@ -201,6 +201,9 @@ int PreferencesValueParcel::MarshallingStringValue(const PreferencesValue &value
         LOG_ERROR("memcpy failed when marshalling string value's str len, %{public}d", errCode);
         return -E_ERROR;
     }
+    if (strLen == 0) {
+        return E_OK;
+    }
     errCode = memcpy_s(startAddr + sizeof(uint8_t) + sizeof(size_t), strLen,
         stringValue.c_str(), strLen);
     if (errCode != E_OK) {
@@ -247,7 +250,9 @@ int PreferencesValueParcel::MarshallingStringArrayValue(const PreferencesValue &
             return -E_ERROR;
         }
         startAddr += sizeof(size_t);
-
+        if (strLen == 0) {
+            continue;
+        }
         errCode = memcpy_s(startAddr, strLen, strVec[i].c_str(), strLen);
         if (errCode != E_OK) {
             LOG_ERROR("memcpy failed when marshalling string array value's str data, %{public}d", errCode);
@@ -268,6 +273,9 @@ int PreferencesValueParcel::MarshallingVecUInt8AfterType(const PreferencesValue
         LOG_ERROR("memcpy failed when marshalling uint8 array value's vector num, %{public}d", errCode);
         return E_ERROR;
     }
+    if (vecNum == 0) {
+        return E_OK;
+    }
     startAddr += sizeof(size_t);
     errCode = memcpy_s(startAddr, vecNum * sizeof(uint8_t), vec.data(), vecNum * sizeof(uint8_t));
     if (errCode != E_OK) {
@@ -477,9 +485,13 @@ std::pair<int, PreferencesValue> PreferencesValueParcel::UnmarshallingStringValu
     const uint8_t *startAddr = data.data();
     std::string strValue;
     size_t strLen = *(reinterpret_cast<const size_t *>(startAddr + sizeof(uint8_t)));
-    strValue.resize(strLen);
-    strValue.assign(startAddr + sizeof(uint8_t) + sizeof(size_t), startAddr + sizeof(uint8_t) + sizeof(size_t) +
-        strLen);
+    if (strLen == 0) {
+        strValue = "";
+    } else {
+        strValue.resize(strLen);
+        strValue.assign(startAddr + sizeof(uint8_t) + sizeof(size_t), startAddr + sizeof(uint8_t) + sizeof(size_t) +
+            strLen);
+    }
 
     if (type == OBJECT_TYPE) {
         Object obj;
@@ -508,8 +520,12 @@ std::pair<int, PreferencesValue> PreferencesValueParcel::UnmarshallingStringArra
         size_t strLen = *(reinterpret_cast<const size_t *>(startAddr));
         startAddr += sizeof(size_t);
         std::string strValue;
-        strValue.resize(strLen);
-        strValue.assign(startAddr, startAddr + strLen);
+        if (strLen == 0) {
+            strValue = "";
+        } else {
+            strValue.resize(strLen);
+            strValue.assign(startAddr, startAddr + strLen);
+        }
         strVec[i] = strValue;
         startAddr += strLen;
     }
diff --git a/preferences/frameworks/native/src/preferences_xml_utils.cpp b/preferences/frameworks/native/src/preferences_xml_utils.cpp
index 468de99b27efebd5122ff642ede04e852f8b144b..0ff478cc4237dcad61e7da6385742bc3b90fac03 100644
--- a/preferences/frameworks/native/src/preferences_xml_utils.cpp
+++ b/preferences/frameworks/native/src/preferences_xml_utils.cpp
@@ -22,9 +22,11 @@
 
 #include "libxml/parser.h"
 #include "log_print.h"
+#include "preferences_dfx_adapter.h"
 #include "preferences_file_lock.h"
 #include "preferences_file_operation.h"
 #include "preferences_impl.h"
+
 namespace OHOS {
 namespace NativePreferences {
 static bool ParseNodeElement(const xmlNode *node, Element &element);
@@ -82,8 +84,9 @@ static bool RenameToBackupFile(const std::string &fileName)
     return RenameFile(fileName, STR_BACKUP);
 }
 
-static bool RenameToBrokenFile(const std::string &fileName)
+static bool RenameToBrokenFile(const std::string &fileName, const ReportParam &reportParam)
 {
+    PreferencesDfxManager::ReportDbFault(reportParam);
     return RenameFile(fileName, STR_BROKEN);
 }
 
@@ -92,7 +95,7 @@ static xmlDoc *ReadFile(const std::string &fileName)
     return xmlReadFile(fileName.c_str(), "UTF-8", XML_PARSE_NOBLANKS | XML_PARSE_HUGE);
 }
 
-static xmlDoc *XmlReadFile(const std::string &fileName, const std::string &dataGroupId)
+static xmlDoc *XmlReadFile(const std::string &fileName, const std::string &bundleName, const std::string &dataGroupId)
 {
     xmlDoc *doc = nullptr;
     PreferencesFileLock fileLock(MakeFilePath(fileName, STR_LOCK), dataGroupId);
@@ -103,8 +106,11 @@ static xmlDoc *XmlReadFile(const std::string &fileName, const std::string &dataG
         }
         xmlErrorPtr xmlErr = xmlGetLastError();
         std::string errMessage = (xmlErr != nullptr) ? xmlErr->message : "null";
-        LOG_ERROR("failed to read XML format file, error is %{public}s.", errMessage.c_str());
-        if (!RenameToBrokenFile(fileName)) {
+        LOG_ERROR("failed to read XML format file: %{public}s, error is %{public}s.",
+            ExtractFileName(fileName).c_str(), errMessage.c_str());
+        ReportParam reportParam = { bundleName, NORMAL_DB,
+            ExtractFileName(fileName), E_ERROR, errno, "operation: failed to read XML format file." };
+        if (!RenameToBrokenFile(fileName, reportParam)) {
             return doc;
         }
     }
@@ -115,15 +121,16 @@ static xmlDoc *XmlReadFile(const std::string &fileName, const std::string &dataG
 }
 
 /* static */
-bool PreferencesXmlUtils::ReadSettingXml(
-    const std::string &fileName, const std::string &dataGroupId, std::vector<Element> &settings)
+bool PreferencesXmlUtils::ReadSettingXml(const std::string &fileName, const std::string &bundleName,
+    const std::string &dataGroupId, std::vector<Element> &settings)
 {
     LOG_RECORD_FILE_NAME("Read setting xml start.");
     if (fileName.size() == 0) {
         LOG_ERROR("The length of the file name is 0.");
         return false;
     }
-    auto doc = std::shared_ptr<xmlDoc>(XmlReadFile(fileName, dataGroupId), [](xmlDoc *doc) { xmlFreeDoc(doc); });
+    auto doc =
+        std::shared_ptr<xmlDoc>(XmlReadFile(fileName, bundleName, dataGroupId), [](xmlDoc *doc) { xmlFreeDoc(doc); });
     if (doc == nullptr) {
         return false;
     }
@@ -276,9 +283,11 @@ static bool SaveFormatFileEnc(const std::string &fileName, xmlDoc *doc)
     return xmlSaveFormatFileEnc(fileName.c_str(), doc, "UTF-8", 1) > 0;
 }
 
-bool XmlSaveFormatFileEnc(const std::string &fileName, const std::string &dataGroupId, xmlDoc *doc)
+bool XmlSaveFormatFileEnc(
+    const std::string &fileName, const std::string &bundleName, const std::string &dataGroupId, xmlDoc *doc)
 {
     PreferencesFileLock fileLock(MakeFilePath(fileName, STR_LOCK), dataGroupId);
+
     if (IsFileExist(fileName) && !RenameToBackupFile(fileName)) {
         return false;
     }
@@ -286,9 +295,12 @@ bool XmlSaveFormatFileEnc(const std::string &fileName, const std::string &dataGr
     if (!SaveFormatFileEnc(fileName, doc)) {
         xmlErrorPtr xmlErr = xmlGetLastError();
         std::string errMessage = (xmlErr != nullptr) ? xmlErr->message : "null";
-        LOG_ERROR("failed to save XML format file, error is %{public}s.", errMessage.c_str());
+        LOG_ERROR("failed to save XML format file: %{public}s, error is %{public}s.",
+            ExtractFileName(fileName).c_str(), errMessage.c_str());
         if (IsFileExist(fileName)) {
-            RenameToBrokenFile(fileName);
+            ReportParam reportParam = { bundleName, NORMAL_DB,
+                ExtractFileName(fileName), E_ERROR, errno, "operation: failed to save XML format file." };
+            RenameToBrokenFile(fileName, reportParam);
         }
         RenameFromBackupFile(fileName);
         return false;
@@ -305,8 +317,8 @@ bool XmlSaveFormatFileEnc(const std::string &fileName, const std::string &dataGr
 }
 
 /* static */
-bool PreferencesXmlUtils::WriteSettingXml(
-    const std::string &fileName, const std::string &dataGroupId, const std::vector<Element> &settings)
+bool PreferencesXmlUtils::WriteSettingXml(const std::string &fileName, const std::string &bundleName,
+    const std::string &dataGroupId, const std::vector<Element> &settings)
 {
     LOG_RECORD_FILE_NAME("Write setting xml start.");
     if (fileName.size() == 0) {
@@ -346,7 +358,7 @@ bool PreferencesXmlUtils::WriteSettingXml(
     }
 
     /* 1: formatting spaces are added. */
-    bool result = XmlSaveFormatFileEnc(fileName, dataGroupId, doc.get());
+    bool result = XmlSaveFormatFileEnc(fileName, bundleName, dataGroupId, doc.get());
     LOG_RECORD_FILE_NAME("Write setting xml end.");
     return result;
 }
diff --git a/preferences/frameworks/ndk/include/convertor_error_code.h b/preferences/frameworks/ndk/include/convertor_error_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..18ebb0758fe24f7ec0bd263df569b8be5fb90dd5
--- /dev/null
+++ b/preferences/frameworks/ndk/include/convertor_error_code.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CONVERTOR_ERROR_CODE_H
+#define CONVERTOR_ERROR_CODE_H
+
+namespace OHOS::PreferencesNdk {
+
+class ConvertorErrorCode final {
+public:
+    static int NativeErrToNdk(int nativeErrCode);
+private:
+    ConvertorErrorCode() = default;
+    ~ConvertorErrorCode() = default;
+};
+
+}   // namespace OHOS::PreferencesNdk
+#endif // CONVERTOR_ERROR_CODE_H
\ No newline at end of file
diff --git a/preferences/frameworks/ndk/include/oh_preferences_impl.h b/preferences/frameworks/ndk/include/oh_preferences_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdc818ea150319a8fca3589bc475f10cccd892b1
--- /dev/null
+++ b/preferences/frameworks/ndk/include/oh_preferences_impl.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef PREFERENCES_STORE_IMPL_H
+#define PREFERENCES_STORE_IMPL_H
+
+#include <cstdint>
+#include <shared_mutex>
+#include "oh_preferences.h"
+#include "preferences_observer.h"
+#include "preferences.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+class NDKPreferencesObserver : public OHOS::NativePreferences::PreferencesObserver {
+public:
+    NDKPreferencesObserver(const OH_PreferencesDataObserver *observer, void *context);
+    ~NDKPreferencesObserver() noexcept override = default;
+
+    void OnChange(const std::string &key) override;
+    void OnChange(const std::map<std::string, OHOS::NativePreferences::PreferencesValue> &records) override;
+
+    bool operator==(const OH_PreferencesDataObserver *other);
+
+private:
+    const OH_PreferencesDataObserver *dataObserver_;
+    void *context_;
+};
+
+struct OH_Preferences {
+    int id;
+};
+
+class OH_PreferencesImpl : public OH_Preferences {
+public:
+    explicit OH_PreferencesImpl(std::shared_ptr<OHOS::NativePreferences::Preferences> preferences);
+    ~OH_PreferencesImpl()
+    {
+        preferences_ = nullptr;
+    }
+    std::shared_ptr<OHOS::NativePreferences::Preferences> GetNativePreferences()
+    {
+        return preferences_;
+    }
+
+    int RegisterDataObserver(
+        const OH_PreferencesDataObserver *observer, void *context, const std::vector<std::string> &keys = {});
+    int UnRegisterDataObserver(const OH_PreferencesDataObserver *observer, const std::vector<std::string> &keys = {});
+
+    void SetPreferencesStoreFilePath(const std::string &filePath);
+    std::string GetPreferencesStoreFilePath();
+
+private:
+    std::shared_ptr<OHOS::NativePreferences::Preferences> preferences_;
+    std::shared_mutex mutex_;
+    std::string filePath_ = "";
+    std::shared_mutex obsMutex_;
+    std::vector<std::shared_ptr<NDKPreferencesObserver>> dataObservers_;
+};
+
+struct OH_PreferencesOption {
+    std::string filePath;
+    std::string bundleName;
+    std::string dataGroupId;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif // PREFERENCES_STORE_IMPL_H
\ No newline at end of file
diff --git a/preferences/frameworks/ndk/include/oh_preferences_value_impl.h b/preferences/frameworks/ndk/include/oh_preferences_value_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..619472f4a109b99204d837b6a7876b07fd2a8909
--- /dev/null
+++ b/preferences/frameworks/ndk/include/oh_preferences_value_impl.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OH_PREFERENCES_VALUE_IMPL_H
+#define OH_PREFERENCES_VALUE_IMPL_H
+
+#include "oh_preferences_value.h"
+#include "preferences.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OH_PreferencesValue {
+    int id;
+};
+
+struct OH_PreferencesPair {
+    const char *key;
+    const OH_PreferencesValue *value;
+};
+
+
+class OH_PreferencesValueImpl : public OH_PreferencesValue {
+public:
+    OHOS::NativePreferences::PreferencesValue value_;
+    Preference_ValueType type_;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif // OH_PREFERENCES_VALUE_IMPL_H
diff --git a/preferences/frameworks/ndk/src/convertor_error_code.cpp b/preferences/frameworks/ndk/src/convertor_error_code.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6720af30e13cf9bf8b3bc6124f5a4ebebf12b67d
--- /dev/null
+++ b/preferences/frameworks/ndk/src/convertor_error_code.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <map>
+#include "convertor_error_code.h"
+#include "oh_preferences_err_code.h"
+#include "preferences_errno.h"
+
+namespace OHOS::PreferencesNdk {
+
+struct NdkErrCode {
+    int nativeCode;
+    int ndkCode;
+};
+
+const std::map<int, int> ERROR_CODE_MAP = {
+    { OHOS::NativePreferences::E_OK, OH_Preferences_ErrCode::PREFERENCES_OK },
+    { OHOS::NativePreferences::E_INVALID_ARGS, OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM },
+    { OHOS::NativePreferences::E_NOT_SUPPORTED, OH_Preferences_ErrCode::PREFERENCES_ERROR_NOT_SUPPORTED },
+    { OHOS::NativePreferences::E_DELETE_FILE_FAIL, OH_Preferences_ErrCode::PREFERENCES_ERROR_DELETE_FILE },
+    { OHOS::NativePreferences::E_GET_DATAOBSMGRCLIENT_FAIL,
+        OH_Preferences_ErrCode::PREFERENCES_ERROR_GET_DATAOBSMGRCLIENT }
+};
+
+int ConvertorErrorCode::NativeErrToNdk(int nativeCode)
+{
+    auto iter = ERROR_CODE_MAP.find(nativeCode);
+    if (iter != ERROR_CODE_MAP.end()) {
+        return iter->second;
+    }
+    return PREFERENCES_ERROR_STORAGE;
+}
+}
\ No newline at end of file
diff --git a/preferences/frameworks/ndk/src/oh_preferences.cpp b/preferences/frameworks/ndk/src/oh_preferences.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dd749bcee03f8b21de080fc97f7ccab1605bdf5
--- /dev/null
+++ b/preferences/frameworks/ndk/src/oh_preferences.cpp
@@ -0,0 +1,405 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "oh_preferences.h"
+
+#include "convertor_error_code.h"
+#include "log_print.h"
+
+#include "oh_preferences_err_code.h"
+#include "oh_preferences_impl.h"
+#include "oh_preferences_value_impl.h"
+#include "oh_preferences_value.h"
+#include "preferences_file_operation.h"
+#include "preferences_helper.h"
+
+using namespace OHOS::PreferencesNdk;
+
+OH_PreferencesImpl::OH_PreferencesImpl
+    (std::shared_ptr<OHOS::NativePreferences::Preferences> preferences) : preferences_(preferences)
+{
+}
+
+OH_Preferences *OH_Preferences_Open(OH_PreferencesOption *options, int *errCode)
+{
+    if (options == nullptr || options->filePath.empty()) {
+        LOG_ERROR("open store config error, options is null: %{public}d, filePath is null: %{public}d",
+            (options == nullptr), options->filePath.empty());
+        return nullptr;
+    }
+
+    OHOS::NativePreferences::Options nativeOptions(std::string(options->filePath), std::string(options->bundleName),
+        std::string(options->dataGroupId), true);
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> store =
+        OHOS::NativePreferences::PreferencesHelper::GetPreferences(nativeOptions, *errCode);
+    *errCode = ConvertorErrorCode::NativeErrToNdk(*errCode);
+
+    if (store == nullptr) {
+        LOG_ERROR("Get Preferences Store failed %{public}s",
+            OHOS::NativePreferences::ExtractFileName(nativeOptions.filePath).c_str());
+        return nullptr;
+    }
+    OH_PreferencesImpl *spStore = new(std::nothrow) OH_PreferencesImpl(store);
+    spStore->SetPreferencesStoreFilePath(std::string(options->filePath));
+
+    return spStore;
+}
+
+static OH_PreferencesImpl *GetPreferencesImpl(OH_Preferences *store)
+{
+    if (store == nullptr) {
+        LOG_ERROR("store invalid, wichi is null");
+        return nullptr;
+    }
+    return static_cast<OH_PreferencesImpl *>(store);
+}
+
+void OH_PreferencesImpl::SetPreferencesStoreFilePath(const std::string &filePath)
+{
+    std::unique_lock<std::shared_mutex> writeLock(mutex_);
+    filePath_ = filePath;
+}
+
+std::string OH_PreferencesImpl::GetPreferencesStoreFilePath()
+{
+    std::shared_lock<std::shared_mutex> readLock(mutex_);
+    return filePath_;
+}
+
+int OH_Preferences_Close(OH_Preferences *preference)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr) {
+        LOG_ERROR("preferences close failed, preferences is null");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    nativePreferences->FlushSync();
+
+    int errCode = OHOS::NativePreferences::PreferencesHelper::RemovePreferencesFromCache(
+        preferencesImpl->GetPreferencesStoreFilePath());
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("preference close store failed: %{public}d", errCode);
+        return ConvertorErrorCode::NativeErrToNdk(errCode);
+    }
+    delete preferencesImpl;
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
+
+int OH_Preferences_GetInt(OH_Preferences *preference, const char *key, int *value)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("get int failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    auto res = nativePreferences->GetValue(key, OHOS::NativePreferences::PreferencesValue());
+    if (res.second.IsInt()) {
+        *value = (int)(res.second);
+    } else {
+        LOG_ERROR("Get Int failed, value's type is not int");
+    }
+
+    return ConvertorErrorCode::NativeErrToNdk(res.first);
+}
+
+int OH_Preferences_GetString(OH_Preferences *preference, const char *key, char **value,
+    uint32_t *valueLen)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("get string failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    auto res = nativePreferences->GetValue(key, OHOS::NativePreferences::PreferencesValue());
+    if (res.second.IsString()) {
+        std::string str = (std::string)(res.second);
+        void *ptr = malloc(str.size() + 1); // free by caller
+        if (ptr == nullptr) {
+            LOG_ERROR("malloc failed when get string, errno: %{public}d", errno);
+            return OH_Preferences_ErrCode::PREFERENCES_ERROR_MALLOC;
+        }
+        *value = (char *)ptr;
+        for (size_t i = 0; i < str.size() + 1; i++) {
+            (*value)[i] = (char)str[i];
+        }
+        (*value)[str.size()] = '\0';
+        *valueLen = str.size() + 1;
+    } else {
+        LOG_ERROR("Get string failed, value's type is not string");
+    }
+
+    return ConvertorErrorCode::NativeErrToNdk(res.first);
+}
+
+void OH_Preferences_FreeString(char *string)
+{
+    if (string == nullptr) {
+        LOG_ERROR("free string failed, string is null");
+        return;
+    }
+    free(string);
+}
+
+int OH_Preferences_GetBool(OH_Preferences *preference, const char *key, bool *value)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("get bool failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    auto res = nativePreferences->GetValue(key, OHOS::NativePreferences::PreferencesValue());
+    if (res.second.IsBool()) {
+        *value = (bool)(res.second);
+    } else {
+        LOG_ERROR("Get bool failed, value's type is not bool");
+    }
+
+    return ConvertorErrorCode::NativeErrToNdk(res.first);
+}
+
+int OH_Preferences_SetInt(OH_Preferences *preference, const char *key, int value)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("set int failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    int errCode = nativePreferences->PutInt(key, value);
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("preference put int failed");
+    }
+    return ConvertorErrorCode::NativeErrToNdk(errCode);
+}
+
+int OH_Preferences_SetBool(OH_Preferences *preference, const char *key, bool value)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("set bool failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    int errCode = nativePreferences->PutBool(key, value);
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("preference put bool failed");
+    }
+    return ConvertorErrorCode::NativeErrToNdk(errCode);
+}
+
+int OH_Preferences_SetString(OH_Preferences *preference, const char *key, const char *value)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("set string failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    int errCode = nativePreferences->PutString(key, value);
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("preference put string failed");
+    }
+    return ConvertorErrorCode::NativeErrToNdk(errCode);
+}
+
+int OH_Preferences_Delete(OH_Preferences *preference, const char *key)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || key == nullptr) {
+        LOG_ERROR("delete failed, preference is null: %{public}d, key is null: %{public}d",
+            (preferencesImpl == nullptr), (key == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+
+    std::shared_ptr<OHOS::NativePreferences::Preferences> nativePreferences = preferencesImpl->GetNativePreferences();
+    if (nativePreferences == nullptr) {
+        LOG_ERROR("preference not open yet");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    int errCode = nativePreferences->Delete(key);
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("preference delete value failed");
+    }
+    return ConvertorErrorCode::NativeErrToNdk(errCode);
+}
+
+int OH_Preferences_RegisterDataObserver(OH_Preferences *preference, void *context,
+    const OH_PreferencesDataObserver *observer, const char *keys[], uint32_t keyCount)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || observer == nullptr) {
+        LOG_ERROR("register failed, invalid agrs, preference is null ? %{public}d, observer is null ? %{public}d",
+            (preferencesImpl == nullptr), (observer == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    if (keyCount == 0) {
+        return preferencesImpl->RegisterDataObserver(observer, context);
+    }
+    std::vector<std::string> keysVec;
+    for (uint32_t i = 0; i < keyCount; i++) {
+        keysVec.push_back(keys[i]);
+    }
+    
+    return preferencesImpl->RegisterDataObserver(observer, context, keysVec);
+}
+
+int OH_Preferences_UnregisterDataObserver(OH_Preferences *preference, void *context,
+    const OH_PreferencesDataObserver *observer, const char *keys[], uint32_t keyCount)
+{
+    auto preferencesImpl = GetPreferencesImpl(preference);
+    if (preferencesImpl == nullptr || observer == nullptr) {
+        LOG_ERROR("unregister failed, invalid agrs, preference is null ? %{public}d, observer is null ? %{public}d",
+            (preferencesImpl == nullptr), (observer == nullptr));
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    if (keyCount == 0) {
+        return preferencesImpl->UnRegisterDataObserver(observer);
+    }
+    std::vector<std::string> keysVec;
+    for (uint32_t i = 0; i < keyCount; i++) {
+        keysVec.push_back(keys[i]);
+    }
+    return preferencesImpl->UnRegisterDataObserver(observer, keysVec);
+}
+
+int OH_PreferencesImpl::RegisterDataObserver(
+    const OH_PreferencesDataObserver *observer, void *context, const std::vector<std::string> &keys)
+{
+    std::unique_lock<std::shared_mutex> writeLock(obsMutex_);
+
+    auto ndkObserver = std::make_shared<NDKPreferencesObserver>(observer, context);
+    int errCode = preferences_->RegisterDataObserver(ndkObserver, keys);
+    if (errCode != OHOS::NativePreferences::E_OK) {
+        LOG_ERROR("register failed");
+    } else {
+        dataObservers_.emplace_back(std::move(ndkObserver));
+    }
+    return ConvertorErrorCode::NativeErrToNdk(errCode);
+}
+
+NDKPreferencesObserver::NDKPreferencesObserver(const OH_PreferencesDataObserver *observer, void *context)
+    : dataObserver_(observer), context_(context) {}
+
+void NDKPreferencesObserver::OnChange(const std::map<std::string, OHOS::NativePreferences::PreferencesValue> &records)
+{
+    auto count = records.size();
+    if (count == 0) {
+        return;
+    }
+    OH_PreferencesPair *pairs = new OH_PreferencesPair[count];
+    if (pairs == nullptr) {
+        LOG_ERROR("malloc pairs failed when on change, count: %{public}u, errno:%{public}d", count, errno);
+        return;
+    }
+    int i = 0;
+    for (const auto &[key, value] : records) {
+        OH_PreferencesValueImpl *valueImpl = new OH_PreferencesValueImpl();
+        if (value.IsInt()) {
+            valueImpl->type_ = Preference_ValueType::TYPE_INT;
+            valueImpl->value_ = value;
+        } else if (value.IsBool()) {
+            valueImpl->type_ = Preference_ValueType::TYPE_BOOL;
+            valueImpl->value_ = value;
+        } else if (value.IsString()) {
+            valueImpl->type_ = Preference_ValueType::TYPE_STRING;
+            valueImpl->value_ = value;
+        } else {
+            valueImpl->type_ = Preference_ValueType::TYPE_NULL;
+        }
+        pairs[i++] = OH_PreferencesPair { key.c_str(), valueImpl };
+    }
+    (*dataObserver_)(context_, pairs, count);
+    for (size_t i = 0; i < count; i++) {
+        delete pairs[i].value;
+    }
+    delete []pairs;
+}
+
+void NDKPreferencesObserver::OnChange(const std::string &key)
+{
+}
+
+int OH_PreferencesImpl::UnRegisterDataObserver(const OH_PreferencesDataObserver *observer,
+    const std::vector<std::string> &keys)
+{
+    std::unique_lock<std::shared_mutex> writeLock(obsMutex_);
+    for (size_t i = 0; i < dataObservers_.size(); i++) {
+        if (!(*dataObservers_[i] == observer)) {
+            i++;
+            continue;
+        }
+        int errCode = preferences_->UnRegisterDataObserver(dataObservers_[i], keys);
+        if (errCode != OHOS::NativePreferences::E_OK) {
+            LOG_ERROR("un register observer failed");
+            return ConvertorErrorCode::NativeErrToNdk(errCode);
+        }
+    }
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
+
+bool NDKPreferencesObserver::operator==(const OH_PreferencesDataObserver *other)
+{
+    if (other == nullptr) {
+        return false;
+    }
+    return  &other == &dataObserver_;
+}
diff --git a/preferences/frameworks/ndk/src/oh_preferences_option.cpp b/preferences/frameworks/ndk/src/oh_preferences_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..999ed730313009e5fbb7b1e7f59adb2b57086643
--- /dev/null
+++ b/preferences/frameworks/ndk/src/oh_preferences_option.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "oh_preferences_option.h"
+
+#include "log_print.h"
+#include "oh_preferences_impl.h"
+#include "oh_preferences_err_code.h"
+
+using namespace OHOS::PreferencesNdk;
+
+OH_PreferencesOption* OH_PreferencesOption_Create(void)
+{
+    return new (std::nothrow) OH_PreferencesOption();
+}
+
+int OH_PreferencesOption_SetFilePath(OH_PreferencesOption *option, const char *filePath)
+{
+    option->filePath = std::string(filePath);
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
+
+int OH_PreferencesOption_SetBundleName(OH_PreferencesOption *option, const char *bundleName)
+{
+    option->bundleName = std::string(bundleName);
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
+
+int OH_PreferencesOption_SetDataGroupId(OH_PreferencesOption *option, const char *dataGroupId)
+{
+    option->dataGroupId = std::string(dataGroupId);
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
+
+int OH_PreferencesOption_Destroy(OH_PreferencesOption* option)
+{
+    delete option;
+    return OH_Preferences_ErrCode::PREFERENCES_OK;
+}
diff --git a/preferences/frameworks/ndk/src/oh_preferences_value.cpp b/preferences/frameworks/ndk/src/oh_preferences_value.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..44bcdaa049b0ecdd339786dba3fd728ea5b1c97c
--- /dev/null
+++ b/preferences/frameworks/ndk/src/oh_preferences_value.cpp
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "oh_preferences_value.h"
+
+#include "log_print.h"
+#include "oh_preferences_err_code.h"
+#include "oh_preferences_impl.h"
+#include "oh_preferences_value_impl.h"
+
+using namespace OHOS::PreferencesNdk;
+
+static OH_PreferencesValueImpl *GetSelf(const OH_PreferencesValue *value)
+{
+    if (value == nullptr) {
+        LOG_ERROR("preferences_value invalid, which is null");
+        return nullptr;
+    }
+    OH_PreferencesValue *prefValue = const_cast<OH_PreferencesValue *>(value);
+    OH_PreferencesValueImpl *self = static_cast<OH_PreferencesValueImpl *>(prefValue);
+    if (self->value_.IsInt()) {
+        self->type_ = Preference_ValueType::TYPE_INT;
+    } else if (self->value_.IsBool()) {
+        self->type_ = Preference_ValueType::TYPE_BOOL;
+    } else if (self->value_.IsString()) {
+        self->type_ = Preference_ValueType::TYPE_STRING;
+    } else {
+        return nullptr;
+    }
+    return self;
+}
+
+const char *OH_PreferencesPair_GetKey(const OH_PreferencesPair *pairs, uint32_t index)
+{
+    if (pairs == nullptr) {
+        return nullptr;
+    }
+    return pairs[index].key;
+}
+
+const OH_PreferencesValue *OH_PreferencesPair_GetPreferencesValue(const OH_PreferencesPair *pairs, uint32_t index)
+{
+    if (pairs == nullptr) {
+        return nullptr;
+    }
+    return pairs[index].value;
+}
+
+Preference_ValueType OH_PreferencesValue_GetValueType(const OH_PreferencesValue *object)
+{
+    auto self = GetSelf(object);
+    if (self == nullptr) {
+        LOG_ERROR("Preferences GetValueType failed, object is null");
+        return Preference_ValueType::TYPE_NULL;
+    }
+    return self->type_;
+}
+
+int OH_PreferencesValue_GetInt(const OH_PreferencesValue *object, int *value)
+{
+    auto self = GetSelf(object);
+    if (self == nullptr) {
+        LOG_ERROR("Preferences GetInt failed, object is null");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    if (self->type_ == Preference_ValueType::TYPE_INT) {
+        *value = std::get<int>(self->value_.value_);
+        return OH_Preferences_ErrCode::PREFERENCES_OK;
+    }
+    LOG_ERROR("Preferences GetInt failed, type: %{public}d", self->type_);
+    return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+}
+
+int OH_PreferencesValue_GetBool(const OH_PreferencesValue *object, bool *value)
+{
+    auto self = GetSelf(object);
+    if (self == nullptr) {
+        LOG_ERROR("Preferences GetBool failed, object is null");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    if (self->type_ == Preference_ValueType::TYPE_BOOL) {
+        *value = std::get<bool>(self->value_.value_);
+        return OH_Preferences_ErrCode::PREFERENCES_OK;
+    }
+    LOG_ERROR("Preferences GetBool failed, type: %{public}d", self->type_);
+    return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+}
+
+int OH_PreferencesValue_GetString(const OH_PreferencesValue *object, char **value, uint32_t *valueLen)
+{
+    auto self = GetSelf(object);
+    if (self == nullptr) {
+        LOG_ERROR("Preferences GetString failed, object is null");
+        return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+    }
+    if (self->type_ == Preference_ValueType::TYPE_STRING) {
+        std::string str = (std::string)(self->value_);
+        void *ptr = malloc(str.size() + 1); // free by caller
+        if (ptr == nullptr) {
+            LOG_ERROR("malloc failed when value get string, errno: %{public}d", errno);
+            return OH_Preferences_ErrCode::PREFERENCES_ERROR_MALLOC;
+        }
+        *value = (char *)ptr;
+        for (size_t i = 0; i < str.size() + 1; i++) {
+            (*value)[i] = (char)str[i];
+        }
+        (*value)[str.size()] = '\0';
+        *valueLen = str.size() + 1;
+        return OH_Preferences_ErrCode::PREFERENCES_OK;
+    }
+    LOG_ERROR("Preferences GetString failed, type: %{public}d", self->type_);
+    return OH_Preferences_ErrCode::PREFERENCES_ERROR_INVALID_PARAM;
+}
diff --git a/preferences/interfaces/inner_api/BUILD.gn b/preferences/interfaces/inner_api/BUILD.gn
index a8efac9b2d1dd9bc20da461fba096891b82f491c..0196fe083d8f0ba048da91e3fb563d3076ba10a3 100644
--- a/preferences/interfaces/inner_api/BUILD.gn
+++ b/preferences/interfaces/inner_api/BUILD.gn
@@ -43,6 +43,7 @@ config("adaptor_config") {
 }
 
 base_sources = [
+  "${preferences_native_path}/platform/src/preferences_dfx_adapter.cpp",
   "${preferences_native_path}/platform/src/preferences_file_lock.cpp",
   "${preferences_native_path}/platform/src/preferences_thread.cpp",
   "${preferences_native_path}/src/base64_helper.cpp",
@@ -100,8 +101,11 @@ if (is_ohos) {
     external_deps = [
       "ability_base:zuri",
       "ability_runtime:dataobs_manager",
+      "access_token:libaccesstoken_sdk",
+      "bounds_checking_function:libsec_shared",
       "c_utils:utils",
       "hilog:libhilog",
+      "hisysevent:libhisysevent",
       "hitrace:hitrace_meter",
       "ipc:ipc_core",
       "libxml2:libxml2",
@@ -137,7 +141,10 @@ if (is_ohos) {
     deps = [
       "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog_${buildos}",
     ]
-    external_deps = [ "libxml2:static_libxml2" ]
+    external_deps = [
+      "bounds_checking_function:libsec_shared",
+      "libxml2:static_libxml2",
+    ]
     public_configs = [ ":native_preferences_public_config" ]
 
     subsystem_name = "distributeddatamgr"
@@ -157,6 +164,7 @@ if (is_ohos) {
     deps = [
       "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog_android",
       "//commonlibrary/c_utils/base:utilsbase",
+      "//third_party/bounds_checking_function:libsec_static",
       "//third_party/libxml2:libxml2",
     ]
     public_configs = [ ":native_preferences_public_config" ]
@@ -176,6 +184,7 @@ if (is_ohos) {
     deps = [
       "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog_${target_os}",
       "//commonlibrary/c_utils/base:utilsbase",
+      "//third_party/bounds_checking_function:libsec_static",
       "//third_party/libxml2:libxml2",
     ]
     public_configs = [ ":native_preferences_public_config" ]
@@ -185,7 +194,6 @@ if (is_ohos) {
 }
 
 ohos_static_library("native_preferences_static") {
-  all_dependent_configs = [ ":native_preferences_public_config" ]
   sources = base_sources
   configs = [ ":native_preferences_config" ]
 
@@ -209,7 +217,10 @@ ohos_static_library("native_preferences_static") {
     deps = [
       "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog_${buildos}",
     ]
-    external_deps = [ "libxml2:static_libxml2" ]
+    external_deps = [
+      "bounds_checking_function:libsec_shared",
+      "libxml2:static_libxml2",
+    ]
   } else {
     if (is_ohos) {
       branch_protector_ret = "pac_ret"
@@ -229,8 +240,11 @@ ohos_static_library("native_preferences_static") {
     external_deps = [
       "ability_base:zuri",
       "ability_runtime:dataobs_manager",
+      "access_token:libaccesstoken_sdk",
+      "bounds_checking_function:libsec_shared",
       "c_utils:utils",
       "hilog:libhilog",
+      "hisysevent:libhisysevent",
       "hitrace:hitrace_meter",
       "ipc:ipc_core",
       "libxml2:libxml2",
diff --git a/preferences/interfaces/inner_api/include/preferences.h b/preferences/interfaces/inner_api/include/preferences.h
index a7ac1c9a0a18afe0d6c88630326dca22f199dda0..175750b044f2ec3152b2aa3ba3b694fcb19f29c7 100644
--- a/preferences/interfaces/inner_api/include/preferences.h
+++ b/preferences/interfaces/inner_api/include/preferences.h
@@ -44,10 +44,17 @@ public:
     {
     }
 
+    Options(const std::string &inputFilePath, const std::string &inputbundleName, const std::string &inputdataGroupId,
+        bool inputIsEnhance) : filePath(inputFilePath), bundleName(inputbundleName), dataGroupId(inputdataGroupId),
+        isEnhance(inputIsEnhance)
+    {
+    }
+
 public:
     std::string filePath{ "" };
     std::string bundleName{ "" };
     std::string dataGroupId{ "" };
+    bool isEnhance = false;
 };
 /**
  * The function class of the preference. Various operations on preferences instances are provided in this class.
@@ -386,7 +393,34 @@ public:
     {
         return E_OK;
     }
+    
+    /**
+     * @brief Obtains the value of a preferences.
+     *
+     * This function is used to get the value of the corresponding key in the preference.
+     *
+     * @param key Indicates the key of the preferences. It cannot be empty.
+     * @param defValue Indicates the default value of the preferences.
+     *
+     * @return Returns a pair, the first is 0 for success, others for failure.
+     */
+    virtual std::pair<int, PreferencesValue> GetValue(const std::string &key, const PreferencesValue &defValue)
+    {
+        return {E_OK, defValue};
+    }
+
+    /**
+     * @brief Obtains all the keys and values of a preferences.
+     *
+     * This function is used to get all keys and values in an object.
+     *
+     * @return Returns a pair, the first is 0 for success, others for failure.
+     */
+    virtual std::pair<int, std::map<std::string, PreferencesValue>> GetAllData()
+    {
+        return {E_OK, {}};
+    }
 };
 } // End of namespace NativePreferences
 } // End of namespace OHOS
-#endif // End of #ifndef PREFERENCES_H
+#endif // End of #ifndef PREFERENCES_H
\ No newline at end of file
diff --git a/preferences/interfaces/inner_api/include/preferences_errno.h b/preferences/interfaces/inner_api/include/preferences_errno.h
index 2a9051c43e35ac0216865811c447579521b9af4b..245bb79e8378f85eb4d13948ab6fb0e46211bd3e 100644
--- a/preferences/interfaces/inner_api/include/preferences_errno.h
+++ b/preferences/interfaces/inner_api/include/preferences_errno.h
@@ -149,6 +149,11 @@ static constexpr int E_GET_DATAOBSMGRCLIENT_FAIL = (E_BASE + 19);
 */
 constexpr int E_OBSERVER_RESERVE = (E_BASE + 20);
 
+/**
+* @brief The error code is used to indicate that database has been closed.
+*/
+constexpr int E_ALREADY_CLOSED = (E_BASE + 21);
+
 } // namespace NativePreferences
 } // namespace OHOS
 #endif // PREFERENCES_ERRNO_H
diff --git a/preferences/interfaces/ndk/BUILD.gn b/preferences/interfaces/ndk/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..776788d8aa293b7fc5a38756c0908fa33bde1109
--- /dev/null
+++ b/preferences/interfaces/ndk/BUILD.gn
@@ -0,0 +1,95 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/ohos.gni")
+import("//foundation/distributeddatamgr/preferences/preferences.gni")
+
+config("ndk_preferences_config") {
+  visibility = [ ":*" ]
+  include_dirs = [
+    "include",
+    "${preferences_base_path}/frameworks/common/include",
+    "${preferences_base_path}/frameworks/ndk/include",
+    "${preferences_native_path}/include",
+    "${preferences_native_path}/platform/include/",
+  ]
+}
+
+config("ndk_preferences_public_config") {
+  visibility = [ ":*" ]
+  include_dirs = [ "include" ]
+}
+
+if (is_ohos) {
+  base_sources = [
+    "${preferences_ndk_path}/src/convertor_error_code.cpp",
+    "${preferences_ndk_path}/src/oh_preferences.cpp",
+    "${preferences_ndk_path}/src/oh_preferences_option.cpp",
+    "${preferences_ndk_path}/src/oh_preferences_value.cpp",
+  ]
+  ohos_shared_library("ohpreferences") {
+    branch_protector_ret = "pac_ret"
+    sanitize = {
+      cfi = true
+      cfi_cross_dso = true
+      debug = false
+    }
+    cflags_cc = [
+      "-std=c++17",
+      "-stdlib=libc++",
+    ]
+    deps =
+        [ "${preferences_base_path}/interfaces/inner_api:native_preferences" ]
+
+    sources = base_sources
+
+    defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ]
+
+    configs = [ ":ndk_preferences_config" ]
+
+    external_deps = [
+      "bounds_checking_function:libsec_shared",
+      "c_utils:utils",
+      "hilog:libhilog",
+    ]
+    public_configs = [ ":ndk_preferences_public_config" ]
+    relative_install_dir = "ndk"
+    part_name = "preferences"
+    subsystem_name = "distributeddatamgr"
+    output_extension = "so"
+  }
+
+  ohos_static_library("ohpreferences_static") {
+    branch_protector_ret = "pac_ret"
+    sanitize = {
+      boundary_sanitize = true
+      ubsan = true
+      cfi = true
+      cfi_cross_dso = true
+      debug = false
+    }
+    deps =
+        [ "${preferences_base_path}/interfaces/inner_api:native_preferences" ]
+    sources = base_sources
+
+    configs = [ ":ndk_preferences_config" ]
+
+    external_deps = [
+      "bounds_checking_function:libsec_shared",
+      "c_utils:utils",
+      "hilog:libhilog",
+    ]
+    public_configs = [ ":ndk_preferences_public_config" ]
+    part_name = "preferences"
+    subsystem_name = "distributeddatamgr"
+  }
+}
diff --git a/preferences/interfaces/ndk/include/oh_preferences.h b/preferences/interfaces/ndk/include/oh_preferences.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea2d66ac8cd9c9600ffd03eea085fe2a9c700e08
--- /dev/null
+++ b/preferences/interfaces/ndk/include/oh_preferences.h
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup PREFERENCES
+ * @{
+ *
+ * @brief Provides APIs for processing data in the form of key-value (KV) pairs.
+ * You can use the APIs provided by the Preferences module to query, modify, and persist KV pairs.
+ * The key is of the string type, and the value can be a number, a string, a boolean value.
+ *
+ * @since 13
+ */
+
+/**
+ * @file oh_preferences.h
+ *
+ * @brief Defines the APIS and enums of Preference.
+ *
+ * @kit ArkData
+ * @library libohpreferences.so
+ * @syscap SystemCapability.DistributedDataManager.Preferences.Core
+ *
+ * @since 13
+ */
+
+#ifndef OH_PREFERENCES_H
+#define OH_PREFERENCES_H
+
+#include <cstdint>
+
+#include "oh_preferences_value.h"
+#include "oh_preferences_option.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Represents a Preferences instance.
+ *
+ * @since 13
+ */
+typedef struct OH_Preferences OH_Preferences;
+
+/**
+ * @brief Call to return the change in KV pairs.
+ *
+ * @param context Pointer to the context of data observer.
+ * @param pairs Pointer to the KV pairs to be observed.
+ * @param count Number of KV pairs to be observed.
+ * @see OH_PreferencesPair.
+ * @since 13
+ */
+typedef void (*OH_PreferencesDataObserver)(void *context, const OH_PreferencesPair *pairs, uint32_t count);
+
+/**
+ * @brief Opens a Preferences object.
+ *
+ * @param option Pointer to an {@Link OH_PreferencesOption} instance.
+ * @param errCode Pointer to the status code of the execution. For details, See {@link OH_Preferences_ErrCode}.
+ * @return Returns an pointer to the Preferences object in {@Link OH_Preferences} if the operation is successful,
+ * returns nullptr otherwise.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_NOT_SUPPORTED} indicates the capability is not supported.
+ *         {@link PREFERENCES_ERROR_DELETE_FILE} indicates delete file failed.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences OH_PreferencesOption.
+ * @since 13
+ */
+OH_Preferences *OH_Preferences_Open(OH_PreferencesOption *option, int *errCode);
+
+/**
+ * @brief Closes a Preferences object.
+ *
+ * @param preference Pointer to the {@Link OH_Preferences} instance to close.
+ * @param option Pointer to an {@Link OH_PreferencesOption} instance.
+ * @return Returns the status code of the execution. For details, see {@Link OH_Preferences_ErrCode}.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_Close(OH_Preferences *preference);
+
+/**
+ * @brief Obtains the integer value in a Preferences object based on the given key.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key of the value to obtain.
+ * @param value Pointer to the value obtained.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ *         {@link PREFERENCES_ERROR_KEY_NOT_FOUND} indicates key is not exist.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_GetInt(OH_Preferences *preference, const char *key, int *value);
+
+/**
+ * @brief Obtains the Boolean value in a Preferences object based on the given key.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key of the value to obtain.
+ * @param value Pointer to the Boolean value obtained.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ *         {@link PREFERENCES_ERROR_KEY_NOT_FOUND} indicates key is not exist.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_GetBool(OH_Preferences *preference, const char *key, bool *value);
+
+/**
+ * @brief Obtains the string value in a Preferences object based on the given key.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key of the value to obtain.
+ * @param value Double pointer to the value obtained in an char * array. Release {@Link OH_Preferences_FreeString} the
+ * memory by user when this parameter is no longer required.
+ * @param valueLen Pointer to the length of the string obtained.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ *         {@link PREFERENCES_ERROR_KEY_NOT_FOUND} indicates key is not exist.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_GetString(OH_Preferences *preference, const char *key, char **value, uint32_t *valueLen);
+
+/**
+ * @brief Free a string got by Preferences object.
+ *
+ * @param string Point to string need to free.
+ * @see OH_Preferences.
+ * @since 13
+ */
+void OH_Preferences_FreeString(char *string);
+
+/**
+ * @brief Sets an integer in a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key to set.
+ * @param value Value to set.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_SetInt(OH_Preferences *preference, const char *key, int value);
+
+/**
+ * @brief Sets a Boolean value in a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key to set.
+ * @param value Boolean value to set.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_SetBool(OH_Preferences *preference, const char *key, bool value);
+
+/**
+ * @brief Sets a string in a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key to set.
+ * @param value Point to string to set.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_SetString(OH_Preferences *preference, const char *key, const char *value);
+
+/**
+ * @brief Deletes a KV pair from a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param key Pointer to the key of the data to delete.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences.
+ * @since 13
+ */
+int OH_Preferences_Delete(OH_Preferences *preference, const char *key);
+
+/**
+ * @brief Registers a data observer for a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param context Pointer to the context of the data observer.
+ * @param observer Pointer to the {@Link OH_PreferencesDataObserver} to register.
+ * @param keys Pointer to the keys to observe.
+ * @param keyCount Number of keys to observe.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ *         {@link PREFERENCES_ERROR_GET_DATAOBSMGRCLIENT} indicates get dataObsMgrClient error.
+ * @see OH_Preferences OH_PreferencesDataObserver.
+ * @since 13
+ */
+int OH_Preferences_RegisterDataObserver(OH_Preferences *preference, void *context,
+    const OH_PreferencesDataObserver *observer, const char *keys[], uint32_t keyCount);
+
+/**
+ * @brief Unregisters a data observer for a Preferences object.
+ *
+ * @param preference Pointer to the target {@Link OH_Preferences} instance.
+ * @param context Pointer to the context of the data observer.
+ * @param observer Pointer to the {@Link OH_PreferencesDataObserver} to unregister.
+ * @param keys Pointer to the keys observed. If this parameter is null, this API unregisters the listening for all keys.
+ * @param keyCount Number of the keys.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_Preferences OH_PreferencesDataObserver.
+ * @since 13
+ */
+int OH_Preferences_UnregisterDataObserver(OH_Preferences *preference, void *context,
+    const OH_PreferencesDataObserver *observer, const char *keys[], uint32_t keyCount);
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif // OH_PREFERENCES_H
\ No newline at end of file
diff --git a/preferences/interfaces/ndk/include/oh_preferences_err_code.h b/preferences/interfaces/ndk/include/oh_preferences_err_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d72febd0c0011721b8d804b99c5fb4ba32b4385
--- /dev/null
+++ b/preferences/interfaces/ndk/include/oh_preferences_err_code.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup PREFERENCES
+ * @{
+ *
+ * @brief Provides APIs for processing data in the form of key-value (KV) pairs.
+ * You can use the APIs provided by the Preferences module to query, modify, and persist KV pairs.
+ * The key is of the string type, and the value can be a number, a string, a boolean value.
+ *
+ * @since 13
+ */
+
+/**
+ * @file preferences_err_code.h
+ *
+ * @brief Defines the status codes used in the Preferences module.
+ *
+ * @kit ArkData
+ * @library libohpreferences.so
+ * @syscap SystemCapability.DistributedDataManager.Preferences.Core
+ *
+ * @since 13
+ */
+
+
+#ifndef OH_PREFERENCES_ERR_CODE_H
+#define OH_PREFERENCES_ERR_CODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Enumerates the status codes.
+ *
+ * @since 13
+ */
+typedef enum OH_Preferences_ErrCode {
+    /** @error Operation successful. */
+    PREFERENCES_OK = 0,
+    /* @error Invalid args. */
+    PREFERENCES_ERROR_INVALID_PARAM = 401,
+    /* @error Capability not supported. */
+    PREFERENCES_ERROR_NOT_SUPPORTED = 801,
+    /* @error Base error code. */
+    PREFERENCES_ERROR_BASE = 15500000,
+    /* @error Failed to delete a file. */
+    PREFERENCES_ERROR_DELETE_FILE = 15500010,
+    /* @error Storage error. */
+    PREFERENCES_ERROR_STORAGE = 15500011,
+    /* @error Failed to malloc memory. */
+    PREFERENCES_ERROR_MALLOC = 15500012,
+    /* @error Key not found error. */
+    PREFERENCES_ERROR_KEY_NOT_FOUND = 15500013,
+    /* @error Failed to get DataObsMgrClient. */
+    PREFERENCES_ERROR_GET_DATAOBSMGRCLIENT = 15500019,
+} OH_Preferences_ErrCode;
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // OH_PREFERENCES_ERR_CODE_H
\ No newline at end of file
diff --git a/preferences/interfaces/ndk/include/oh_preferences_option.h b/preferences/interfaces/ndk/include/oh_preferences_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b2d1d953d4c57bc0c3979a8ed6980aa5ee4dc9e
--- /dev/null
+++ b/preferences/interfaces/ndk/include/oh_preferences_option.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup PREFERENCES
+ * @{
+ *
+ * @brief Provides APIs for processing data in the form of key-value (KV) pairs.
+ * You can use the APIs provided by the Preferences module to query, modify, and persist KV pairs.
+ * The key is of the string type, and the value can be a number, a string, a boolean value.
+ *
+ * @since 13
+ */
+
+/**
+ * @file oh_preferences_option.h
+ *
+ * @brief Defines the APIs and enums related to preferences option.
+ *
+ * @kit ArkData
+ * @library libohpreferences.so
+ * @syscap SystemCapability.DistributedDataManager.Preferences.Core
+ *
+ * @since 13
+ */
+
+#ifndef OH_PREFERENCES_OPTION_H
+#define OH_PREFERENCES_OPTION_H
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Represents an OH_PreferencesOption instance.
+ *
+ * @since 13
+ */
+typedef struct OH_PreferencesOption OH_PreferencesOption;
+
+/**
+ * @brief Creates an {@Link OH_PreferencesOption} instance.
+ *
+ * @return Returns a pointer to the {@Link OH_PreferencesOption} instance created if the operation is successful;
+ * returns nullptr otherwise while malloc memory failed.
+ * @see OH_PreferencesOption.
+ * @since 13
+ */
+OH_PreferencesOption *OH_PreferencesOption_Create(void);
+
+/**
+ * @brief Sets the file path in an {@Link OH_PreferencesOption} instance.
+ *
+ * @param option Pointer to the target {@Link OH_PreferencesOption} instance.
+ * @param filePath Pointer to the file path to set.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} success.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ * @see OH_PreferencesOption.
+ * @since 13
+ */
+int OH_PreferencesOption_SetFilePath(OH_PreferencesOption *option, const char *filePath);
+
+/**
+ * @brief Sets the bundle name in an {@Link OH_PreferencesOption} instance.
+ *
+ * @param option Pointer to the target {@Link OH_PreferencesOption} instance.
+ * @param bundleName Pointer to the bundle name to set.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} success.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ * @see OH_PreferencesOption.
+ * @since 13
+ */
+int OH_PreferencesOption_SetBundleName(OH_PreferencesOption *option, const char *bundleName);
+
+/**
+ * @brief Sets the data group ID in an {@Link OH_PreferencesOption} instance.
+ *
+ * @param option Represents a pointer to an {@link OH_PreferencesOption} instance.
+ * @param dataGroupId Represents preferences data group id param.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} success.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ * @see OH_PreferencesOption.
+ * @since 13
+ */
+int OH_PreferencesOption_SetDataGroupId(OH_PreferencesOption *option, const char *dataGroupId);
+
+/**
+ * @brief Destroys an {@Link OH_PreferencesOption} instance.
+ *
+ * @param option Pointer to the {@Link OH_PreferencesOption} instance to destroy.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ * @see OH_PreferencesOption.
+ * @since 13
+ */
+int OH_PreferencesOption_Destroy(OH_PreferencesOption *option);
+#ifdef __cplusplus
+};
+#endif
+#endif // OH_PREFERENCES_OPTION_H
\ No newline at end of file
diff --git a/preferences/interfaces/ndk/include/oh_preferences_value.h b/preferences/interfaces/ndk/include/oh_preferences_value.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fd358f32346d13f6772961d6e747bd231edea4a
--- /dev/null
+++ b/preferences/interfaces/ndk/include/oh_preferences_value.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup PREFERENCES
+ * @{
+ *
+ * @brief Provides APIs for processing data in the form of key-value (KV) pairs.
+ * You can use the APIs provided by the Preferences module to query, modify, and persist KV pairs.
+ * The key is of the string type, and the value can be a number, a string, a boolean value.
+ *
+ * @since 13
+ */
+
+/**
+ * @file oh_preferences_value.h
+ *
+ * @brief Defines the APIs and enums related to preferences values.
+ *
+ * @kit ArkData
+ * @library libohpreferences.so
+ * @syscap SystemCapability.DistributedDataManager.Preferences.Core
+ *
+ * @since 13
+ */
+
+#ifndef OH_PREFERENCES_VALUE_H
+#define OH_PREFERENCES_VALUE_H
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Enumerates the Preference value types.
+ *
+ * @since 13
+ */
+typedef enum Preference_ValueType {
+    /**
+     * @brief Null.
+     */
+    TYPE_NULL = 0,
+    /**
+     * @brief Int.
+     */
+    TYPE_INT,
+    /**
+     * @brief boolean.
+     */
+    TYPE_BOOL,
+    /**
+     * @brief String.
+     */
+    TYPE_STRING,
+    /**
+     * @brief end butt.
+     */
+    TYPE_BUTT
+} Preference_ValueType;
+
+/**
+ * @brief Represents a KV pair in a Preferences instance.
+ *
+ * @since 13
+ */
+typedef struct OH_PreferencesPair OH_PreferencesPair;
+
+/**
+ * @brief Represents the value in a KV pair of a Preferences instance.
+ *
+ * @since 13
+ */
+typedef struct OH_PreferencesValue OH_PreferencesValue;
+
+/**
+ * @brief Obtains a key from an {@Link OH_PreferencesPair} instance.
+ *
+ * @param pairs Pointer to the target {@Link OH_PreferencesPair} instance.
+ * @param index Represents a target index of the pairs
+ * @return Returns preferences pointer to the key that when input parameters valid,
+ * return nullptr otherwise while invalid args are passed in.
+ * @see OH_PreferencesPair.
+ * @since 13
+ */
+const char *OH_PreferencesPair_GetKey(const OH_PreferencesPair *pairs, uint32_t index);
+
+/**
+ * @brief Obtains a value from an {@Link OH_PreferencesPair} instance.
+ *
+ * @param pairs Pointer to the target {@Link OH_PreferencesPair} instance.
+ * @param index Index of the value to obtain.
+ * @return Returns a pointer to the {@Link OH_PreferencesValue} obtained if the operation is successful,
+ * returns nullptr otherwise while invalid args are passed in.
+ * @see OH_PreferencesValue.
+ * @since 13
+ */
+const OH_PreferencesValue *OH_PreferencesPair_GetPreferencesValue(const OH_PreferencesPair *pairs, uint32_t index);
+
+/**
+ * @brief Obtains the type of a preferences value.
+ *
+ * @param object Pointer to the target {@Link OH_PreferencesValue} instance.
+ * @return Returns the value type obtained.
+ *         {@link TYPE_NULL} indicates invalid args are passed in.
+ * @see OH_PreferencesValue.
+ * @since 13
+ */
+Preference_ValueType OH_PreferencesValue_GetValueType(const OH_PreferencesValue *object);
+
+/**
+ * @brief Obtains the int value of an {@Link OH_PreferencesValue} instance.
+ *
+ * @param object Pointer to the target {@Link OH_PreferencesValue} instance.
+ * @param value Pointer to the value obtained.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_PreferencesValue.
+ * @since 13
+ */
+int OH_PreferencesValue_GetInt(const OH_PreferencesValue *object, int *value);
+
+/**
+ * @brief Obtains the Boolean value of an {@Link OH_PreferencesValue} instance.
+ *
+ * @param object Pointer to the target {@Link OH_PreferencesValue} instance.
+ * @param value Pointer to the Boolean value obtained.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_PreferencesValue.
+ * @since 13
+ */
+int OH_PreferencesValue_GetBool(const OH_PreferencesValue *object, bool *value);
+
+/**
+ * @brief Obtains the string value of an {@Link OH_PreferencesValue} instance.
+ *
+ * @param object Pointer to target {@Link OH_PreferencesValue} instance.
+ * @param value Double pointer to the value obtained in an char * array. Release {@Link OH_Preferences_FreeString} the
+ * memory by user when this parameter is no longer required.
+ * @param valueLen Pointer to the string length.
+ * @return Returns the status code of the execution.
+ *         {@link PREFERENCES_OK} indicates the operation is successful.
+ *         {@link PREFERENCES_ERROR_INVALID_PARAM} indicates invalid args are passed in.
+ *         {@link PREFERENCES_ERROR_STORAGE} indicates an storage error.
+ *         {@link PREFERENCES_ERROR_MALLOC} indicates an malloc memory error.
+ * @see OH_PreferencesValue.
+ * @since 13
+ */
+int OH_PreferencesValue_GetString(const OH_PreferencesValue *object, char **value, uint32_t *valueLen);
+#ifdef __cplusplus
+};
+#endif
+#endif // OH_PREFERENCES_VALUE_H
\ No newline at end of file
diff --git a/preferences/preferences.gni b/preferences/preferences.gni
index 039eec52c4c8491727ee15accff71825191b0fdc..3183a48812288a73bcd4d9b5a147fca06d6238d7 100644
--- a/preferences/preferences.gni
+++ b/preferences/preferences.gni
@@ -20,3 +20,5 @@ preferences_cj_path = "${preferences_base_path}/frameworks/cj/src"
 preferences_native_path = "${preferences_base_path}/frameworks/native"
 
 preferences_innerapi_path = "${preferences_base_path}/interfaces/inner_api"
+
+preferences_ndk_path = "${preferences_base_path}/frameworks/ndk"
diff --git a/preferences/test/native/unittest/preferences_file_test.cpp b/preferences/test/native/unittest/preferences_file_test.cpp
index 39576849cb036a4504c2069c5698f8ae36e5d16a..fb03834c89c9361f24a15c1c21254af3bf15daa9 100644
--- a/preferences/test/native/unittest/preferences_file_test.cpp
+++ b/preferences/test/native/unittest/preferences_file_test.cpp
@@ -82,7 +82,7 @@ HWTEST_F(PreferencesFileTest, NativePreferencesFileTest_001, TestSize.Level1)
     elem.tag_ = std::string("int");
     elem.value_ = std::to_string(10);
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(backupFile, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(backupFile, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
diff --git a/preferences/test/native/unittest/preferences_xml_utils_test.cpp b/preferences/test/native/unittest/preferences_xml_utils_test.cpp
index 72e39bca11f5346dfc697c777bc45a3a58a3f3f6..7def6040f6f27248c9ece20ba3e59eeec1a0d2f6 100644
--- a/preferences/test/native/unittest/preferences_xml_utils_test.cpp
+++ b/preferences/test/native/unittest/preferences_xml_utils_test.cpp
@@ -61,14 +61,14 @@ void PreferencesXmlUtilsTest::TearDown(void)
 HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_001, TestSize.Level1)
 {
     std::vector<Element> settings = {};
-    bool ret = PreferencesXmlUtils::ReadSettingXml("", "", settings);
+    bool ret = PreferencesXmlUtils::ReadSettingXml("", "", "", settings);
     EXPECT_EQ(ret, false);
 
     std::string path = "/data/test/test_helper" + std::string(4096, 't');
-    ret = PreferencesXmlUtils::ReadSettingXml(path, "", settings);
+    ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
     EXPECT_EQ(ret, false);
 
-    ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", settings);
+    ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", "", settings);
     EXPECT_EQ(ret, false);
 }
 
@@ -107,10 +107,10 @@ HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_003, TestSize.Level1)
     elem.tag_ = "int";
     elem.value_ = "999";
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(file, "123456", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "123456", settings);
 
     std::vector<Element> settingsRes = {};
-    bool ret = PreferencesXmlUtils::ReadSettingXml(file, "123456", settingsRes);
+    bool ret = PreferencesXmlUtils::ReadSettingXml(file, "", "123456", settingsRes);
     EXPECT_EQ(ret, true);
     EXPECT_EQ(settingsRes.empty(), false);
     EXPECT_EQ(elem.key_, settingsRes.front().key_);
@@ -128,22 +128,22 @@ HWTEST_F(PreferencesXmlUtilsTest, ReadSettingXmlTest_003, TestSize.Level1)
 HWTEST_F(PreferencesXmlUtilsTest, UnnormalReadSettingXml_001, TestSize.Level1)
 {
     std::vector<Element> settings = {};
-    PreferencesXmlUtils::WriteSettingXml("", "", settings);
-    bool ret = PreferencesXmlUtils::ReadSettingXml("", "", settings);
+    PreferencesXmlUtils::WriteSettingXml("", "", "", settings);
+    bool ret = PreferencesXmlUtils::ReadSettingXml("", "", "", settings);
     EXPECT_EQ(ret, false);
 
     std::string path = "/data/test/test_helper" + std::string(4096, 't');
-    ret = PreferencesXmlUtils::ReadSettingXml(path, "", settings);
+    ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
     EXPECT_EQ(ret, false);
 
-    ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", settings);
+    ret = PreferencesXmlUtils::ReadSettingXml("data/test/test_helper", "", "", settings);
     EXPECT_EQ(ret, false);
 
     Element elem;
     settings.push_back(elem);
     path = "data/test/test_helper";
-    PreferencesXmlUtils::WriteSettingXml(path, "", settings);
-    ret = PreferencesXmlUtils::ReadSettingXml(path, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(path, "", "", settings);
+    ret = PreferencesXmlUtils::ReadSettingXml(path, "", "", settings);
     EXPECT_EQ(ret, false);
 }
 
@@ -163,7 +163,7 @@ HWTEST_F(PreferencesXmlUtilsTest, StringNodeElementTest_001, TestSize.Level1)
     elem.tag_ = std::string("string");
     elem.value_ = "test";
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -201,7 +201,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_001, TestSize.Level1)
     elem.children_.push_back(elemChild);
     settings.push_back(elem);
     std::vector<std::string> inputStringArray = { "test_child1", "test_child2" };
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -241,7 +241,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_002, TestSize.Level1)
     elem.children_.push_back(elemChild);
     settings.push_back(elem);
     std::vector<double> inputDoubleArray = { 1.0, 2.0 };
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -281,7 +281,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_003, TestSize.Level1)
     elem.children_.push_back(elemChild);
     settings.push_back(elem);
     std::vector<bool> inputBoolArray = { false, true };
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -311,7 +311,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_004, TestSize.Level1)
     elem.value_ = std::to_string(false);
     
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -343,7 +343,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_005, TestSize.Level1)
     elem.value_ = std::to_string(false);
 
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -375,7 +375,7 @@ HWTEST_F(PreferencesXmlUtilsTest, ArrayNodeElementTest_006, TestSize.Level1)
     elem.value_ = std::to_string(1);
     
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(file, "", settings);
+    PreferencesXmlUtils::WriteSettingXml(file, "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(file, errCode);
@@ -409,7 +409,7 @@ HWTEST_F(PreferencesXmlUtilsTest, RenameToBrokenFileTest_001, TestSize.Level1)
     elem.value_ = "2";
 
     settings.push_back(elem);
-    PreferencesXmlUtils::WriteSettingXml(MakeFilePath(fileName, STR_BACKUP), "", settings);
+    PreferencesXmlUtils::WriteSettingXml(MakeFilePath(fileName, STR_BACKUP), "", "", settings);
 
     int errCode = E_OK;
     std::shared_ptr<Preferences> pref = PreferencesHelper::GetPreferences(fileName, errCode);
diff --git a/relational_store/bundle.json b/relational_store/bundle.json
index 720e818a04b3e5e3b63073b025d9ed23ec38e3d0..76fc0b31c8808ccffcfb30177ce476e6ddda4b46 100644
--- a/relational_store/bundle.json
+++ b/relational_store/bundle.json
@@ -66,7 +66,8 @@
                 "kv_store",
                 "napi",
                 "samgr",
-                "hisysevent"
+                "hisysevent",
+                "bounds_checking_function"
             ],
             "third_party": [
                 "icu",
@@ -87,7 +88,8 @@
                 "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/rdb:napi_rdb",
                 "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/relationalstore:relationalstore",
                 "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/cloud_extension:cloudextension",
-                "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/common:commontype_napi"
+                "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/common:commontype_napi",
+                "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/sendablerelationalstore:sendablerelationalstore"
             ],
             "inner_kits": [
                 {
diff --git a/relational_store/frameworks/cj/include/relational_store_ffi.h b/relational_store/frameworks/cj/include/relational_store_ffi.h
index 1cfd3fb706e89c6825480a4935a27001f60f70d0..c517c8507785504429579a3629288216e5fb1c9a 100644
--- a/relational_store/frameworks/cj/include/relational_store_ffi.h
+++ b/relational_store/frameworks/cj/include/relational_store_ffi.h
@@ -19,6 +19,7 @@
 #include "relational_store_impl_rdbstore.h"
 #include "relational_store_impl_rdbpredicatesproxy.h"
 #include "relational_store_impl_resultsetproxy.h"
+#include "relational_store_utils.h"
 #include <cstdint>
 #include "napi_base_context.h"
 #include "rdb_store_config.h"
@@ -56,11 +57,11 @@ extern "C" {
 
     FFI_EXPORT CArrStr FfiOHOSRelationalStoreGetAllColumnNames(int64_t id);
 
-    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetColumnCount(int64_t id);
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetColumnCount(int64_t id, int32_t *errCode);
 
-    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetRowCount(int64_t id);
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetRowCount(int64_t id, int32_t *errCode);
 
-    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetRowIndex(int64_t id);
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetRowIndex(int64_t id, int32_t *errCode);
 
     FFI_EXPORT bool FfiOHOSRelationalStoreIsAtFirstRow(int64_t id, int32_t *errCode);
 
@@ -150,7 +151,7 @@ extern "C" {
         int32_t type);
 
     FFI_EXPORT int32_t FfiOHOSRelationalStoreSetDistributedTablesConfig(int64_t id, char** tables, int64_t tablesSize,
-        int32_t type, DistributedRdb::DistributedConfig &distributedConfig);
+        int32_t type, RetDistributedConfig distributedConfig);
 
     FFI_EXPORT char* FfiOHOSRelationalStoreObtainDistributedTableName(int64_t id, const char* device, char* table);
 
@@ -220,11 +221,34 @@ extern "C" {
     FFI_EXPORT int32_t FfiOHOSRelationalStoreOn(int64_t id, const char *event, bool interProcess, void (*callback)(),
         void (*callbackRef)());
 
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOnArrStr(int64_t id, int32_t subscribeType, int64_t callbackId);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOnChangeInfo(int64_t id, int32_t subscribeType, int64_t callbackId);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOnProgressDetails(int64_t id, int64_t callbackId);
+
     FFI_EXPORT int32_t FfiOHOSRelationalStoreOff(int64_t id, const char *event, bool interProcess, void (*callback)());
 
     FFI_EXPORT int32_t FfiOHOSRelationalStoreOffAll(int64_t id, const char *event, bool interProcess);
 
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOffArrStrChangeInfo(int64_t id, int32_t subscribeType, int64_t callbackId);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOffArrStrChangeInfoAll(int64_t id, int32_t subscribeType);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOffProgressDetails(int64_t id, int64_t callbackId);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreOffProgressDetailsAll(int64_t id);
+
     FFI_EXPORT int32_t FfiOHOSRelationalStoreEmit(int64_t id, const char *event);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreCloudSync(int64_t id, int32_t mode, CArrStr tables, int64_t callbackId);
+
+    FFI_EXPORT int32_t FfiOHOSRelationalStoreGetVersion(int64_t id, int32_t *errCode);
+
+    FFI_EXPORT void FfiOHOSRelationalStoreSetVersion(int64_t id, int32_t value, int32_t *errCode);
+
+    FFI_EXPORT ModifyTime FfiOHOSRelationalStoreGetModifyTime(int64_t id, char *cTable, char* cColumnName,
+        CArrPRIKeyType cPrimaryKeys, int32_t *errCode);
 }
 }
 }
diff --git a/relational_store/frameworks/cj/include/relational_store_impl_rdbstore.h b/relational_store/frameworks/cj/include/relational_store_impl_rdbstore.h
index 4464dc81bebd7f00804ce847f25eaee073c5701f..405f9711f2963d3d574dbfb788e45c3e6992b81a 100644
--- a/relational_store/frameworks/cj/include/relational_store_impl_rdbstore.h
+++ b/relational_store/frameworks/cj/include/relational_store_impl_rdbstore.h
@@ -30,24 +30,67 @@
 
 namespace OHOS {
 namespace Relational {
-    class RdbStoreObserverImpl : public OHOS::DistributedRdb::RdbStoreObserver {
+    class RdbStoreObserverImpl : public DistributedRdb::RdbStoreObserver {
     public:
+        enum FuncType : int32_t {
+            NoParam = 0,
+            ParamArrStr,
+            ParamChangeInfo
+        };
         RdbStoreObserverImpl(std::function<void()> *callback, const std::function<void()>& callbackRef);
+        RdbStoreObserverImpl(int64_t id, FuncType type, int32_t mode = DistributedRdb::REMOTE);
         ~RdbStoreObserverImpl() override = default;
-        void OnChange() override;
+        void OnChange() override
+        {
+            m_callbackRef();
+        };
         void OnChange(const std::vector<std::string> &devices) override
         {
-            return;
+            carrStrFunc(devices);
         };
         void OnChange(const DistributedRdb::Origin &origin, const PrimaryFields &fields,
-            ChangeInfo &&changeInfo) override
+            DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo) override
+        {
+            if (mode_ != DistributedRdb::CLOUD_DETAIL && mode_ != DistributedRdb::LOCAL_DETAIL) {
+                RdbStoreObserver::OnChange(origin, fields, std::move(changeInfo));
+                return;
+            }
+            changeInfoFunc(origin, fields, std::move(changeInfo));
+        };
+
+        int64_t GetCallBackId()
         {
-            OnChange(origin.id);
+            return callbackId;
         };
         std::function<void()> *GetCallBack();
     private:
         std::function<void()> *m_callback;
         std::function<void()> m_callbackRef;
+        int32_t mode_ = DistributedRdb::REMOTE;
+        int64_t callbackId;
+        FuncType funcType;
+        std::function<void()> func;
+        std::function<void(const std::vector<std::string> &devices)> carrStrFunc;
+        std::function<void(const DistributedRdb::Origin &origin, const PrimaryFields &fields,
+            DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo)> changeInfoFunc;
+    };
+
+    class SyncObserverImpl : public DistributedRdb::DetailProgressObserver {
+    public:
+        SyncObserverImpl(int64_t id);
+        ~SyncObserverImpl() override = default;
+        void ProgressNotification(const DistributedRdb::Details &details) override
+        {
+            func(details);
+        };
+
+        int64_t GetCallBackId()
+        {
+            return callbackId;
+        };
+    private:
+        int64_t callbackId;
+        std::function<void(const DistributedRdb::Details &details)> func;
     };
 
     class RdbStoreImpl : public OHOS::FFI::FFIData {
@@ -63,9 +106,9 @@ namespace Relational {
         std::shared_ptr<NativeRdb::ResultSet> RemoteQuery(char* device, RdbPredicatesImpl &predicates, char** column,
             int64_t columnSize);
         int Delete(RdbPredicatesImpl &predicates, int32_t *errCode);
-        void SetDistributedTables(char** tables, int64_t tablesSize);
-        void SetDistributedTables(char** tables, int64_t tablesSize, int32_t type);
-        void SetDistributedTables(char** tables, int64_t tablesSize, int32_t type,
+        int32_t SetDistributedTables(char** tables, int64_t tablesSize);
+        int32_t SetDistributedTables(char** tables, int64_t tablesSize, int32_t type);
+        int32_t SetDistributedTables(char** tables, int64_t tablesSize, int32_t type,
             DistributedRdb::DistributedConfig &distributedConfig);
         int32_t Commit();
         int32_t RollBack();
@@ -85,28 +128,41 @@ namespace Relational {
         void ExecuteSql(const char* sql, ValueType* bindArgs, int64_t bindArgsSize, int32_t *errCode);
         int32_t RegisterObserver(const char *event, bool interProcess, std::function<void()> *callback,
             const std::function<void()>& callbackRef);
-        int32_t RegisteredObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
-            std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
-        std::function<void()> *callback, const std::function<void()>& callbackRef);
+        int32_t RegisteredObserver(DistributedRdb::SubscribeOption option,
+            std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+            std::function<void()> *callback, const std::function<void()>& callbackRef);
+        int32_t RegisterObserverArrStr(int32_t subscribeType, int64_t callbackId);
+        int32_t RegisterObserverChangeInfo(int32_t subscribeType, int64_t callbackId);
+        int32_t RegisterObserverProgressDetails(int64_t callbackId);
         bool HasRegisteredObserver(std::function<void()> *callback,
             std::list<std::shared_ptr<RdbStoreObserverImpl>> &observers);
         int32_t UnRegisterObserver(const char *event, bool interProcess, std::function<void()> *callback);
         int32_t UnRegisterAllObserver(const char *event, bool interProcess);
-        int32_t UnRegisteredObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
-            std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
-        std::function<void()> *callback);
+        int32_t UnRegisteredObserver(DistributedRdb::SubscribeOption option,
+            std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+            std::function<void()> *callback);
         int32_t UnRegisteredAllObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
             std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers);
+        int32_t UnRegisterObserverArrStrChangeInfo(int32_t subscribeType, int64_t callbackId);
+        int32_t UnRegisterObserverArrStrChangeInfoAll(int32_t subscribeType);
+        int32_t UnRegisterObserverProgressDetails(int64_t callbackId);
+        int32_t UnRegisterObserverProgressDetailsAll();
+        int32_t CloudSync(int32_t mode, CArrStr tables, int64_t callbackId);
+        int32_t GetVersion(int32_t &errCode);
+        void SetVersion(int32_t value, int32_t &errCode);
+        ModifyTime GetModifyTime(char *cTable, char *cColumnName, CArrPRIKeyType &cPrimaryKeys, int32_t &errCode);
 
+    private:
+        friend class OHOS::FFI::RuntimeType;
+        friend class OHOS::FFI::TypeBase;
+        static OHOS::FFI::RuntimeType* GetClassType();
         std::vector<OHOS::NativeRdb::ValueObject> bindArgs;
         std::shared_ptr<OHOS::NativeRdb::RdbStore> rdbStore_;
         std::vector<uint8_t> newKey;
+        std::list<std::shared_ptr<RdbStoreObserverImpl>> observers_[DistributedRdb::SUBSCRIBE_MODE_MAX];
         std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> localObservers_;
         std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> localSharedObservers_;
-    private:
-        friend class OHOS::FFI::RuntimeType;
-        friend class OHOS::FFI::TypeBase;
-        static OHOS::FFI::RuntimeType* GetClassType();
+        std::list<std::shared_ptr<SyncObserverImpl>> syncObservers_;
     };
 
     int64_t GetRdbStore(OHOS::AbilityRuntime::Context* context, StoreConfig config,
diff --git a/relational_store/frameworks/cj/include/relational_store_utils.h b/relational_store/frameworks/cj/include/relational_store_utils.h
index f1c4324afbeebd1452bc4d0394eda176132e0047..6376030e022f1b8ab91eb93d84a1b2abf3dd631a 100644
--- a/relational_store/frameworks/cj/include/relational_store_utils.h
+++ b/relational_store/frameworks/cj/include/relational_store_utils.h
@@ -18,6 +18,8 @@
 
 #include "value_object.h"
 #include "securec.h"
+#include "rdb_store.h"
+#include "rdb_types.h"
 
 namespace OHOS {
 namespace Relational {
@@ -57,6 +59,10 @@ namespace Relational {
         char** head;
         int64_t size;
     };
+
+    CArrStr VectorToCArrStr(const std::vector<std::string> &devices);
+
+    std::vector<std::string> CArrStrToVector(CArrStr carr);
     
     struct ValueType {
         int64_t integer;
@@ -92,7 +98,91 @@ namespace Relational {
         int64_t size;
     };
 
-    ValueType ValueObjectToValueType(const NativeRdb::ValueObject& object);
+    ValueType ValueObjectToValueType(const NativeRdb::ValueObject &object);
+
+    struct RetPRIKeyType {
+        int64_t integer;
+        double dou;
+        char* string;
+        uint8_t tag;
+    };
+
+    std::variant<std::monostate, std::string, int64_t, double> RetPRIKeyTypeToVariant(RetPRIKeyType &value);
+
+    RetPRIKeyType VariantToRetPRIKeyType(const std::variant<std::monostate, std::string, int64_t, double> &value);
+
+    struct CArrPRIKeyType {
+        RetPRIKeyType* head;
+        int64_t size;
+    };
+
+    std::vector<NativeRdb::RdbStore::PRIKey> CArrPRIKeyTypeToPRIKeyArray(CArrPRIKeyType &cPrimaryKeys);
+
+    struct ModifyTime {
+        RetPRIKeyType* key;
+        uint64_t* value;
+        int64_t size;
+    };
+
+    ModifyTime MapToModifyTime(std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> &map, int32_t &errCode);
+
+    struct RetChangeInfo {
+        char* table;
+        int32_t type;
+        CArrPRIKeyType inserted;
+        CArrPRIKeyType updated;
+        CArrPRIKeyType deleted;
+    };
+
+    struct CArrRetChangeInfo {
+        RetChangeInfo* head;
+        int64_t size;
+    };
+
+    CArrPRIKeyType VectorToCArrPRIKeyType(std::vector<DistributedRdb::RdbStoreObserver::PrimaryKey> arr);
+
+    RetChangeInfo ToRetChangeInfo(const DistributedRdb::Origin &origin,
+        DistributedRdb::RdbStoreObserver::ChangeInfo::iterator info);
+
+    CArrRetChangeInfo ToCArrRetChangeInfo(const DistributedRdb::Origin &origin,
+        const DistributedRdb::RdbStoreObserver::PrimaryFields &fields,
+        DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo);
+
+    struct CStatistic {
+        uint32_t total;
+        uint32_t successful;
+        uint32_t failed;
+        uint32_t remained;
+    };
+
+    CStatistic ToStatistic(DistributedRdb::Statistic statistic);
+
+    struct CTableDetails {
+        CStatistic upload;
+        CStatistic download;
+    };
+
+    CTableDetails ToCTableDetails(DistributedRdb::TableDetail detail);
+
+    struct CDetails {
+        char** key;
+        CTableDetails* value;
+        int64_t size;
+    };
+
+    CDetails ToCDetails(DistributedRdb::TableDetails details);
+
+    struct CProgressDetails {
+        int32_t schedule;
+        int32_t code;
+        CDetails details;
+    };
+
+    CProgressDetails ToCProgressDetails(const  DistributedRdb::Details &details);
+
+    struct RetDistributedConfig {
+        bool autoSync;
+    };
 }
 }
 #endif
\ No newline at end of file
diff --git a/relational_store/frameworks/cj/src/relational_store_ffi.cpp b/relational_store/frameworks/cj/src/relational_store_ffi.cpp
index 58af1b9ca343642a2b2597fcfcd30128cb975999..21a6f0585bc5a34f61f63ec0489944495939a36c 100644
--- a/relational_store/frameworks/cj/src/relational_store_ffi.cpp
+++ b/relational_store/frameworks/cj/src/relational_store_ffi.cpp
@@ -425,8 +425,7 @@ extern "C" {
         if (nativeRdbStore == nullptr) {
             return -1;
         }
-        nativeRdbStore->SetDistributedTables(tables, tablesSize);
-        return 0;
+        return nativeRdbStore->SetDistributedTables(tables, tablesSize);
     }
 
     int32_t FfiOHOSRelationalStoreSetDistributedTablesType(int64_t id, char** tables, int64_t tablesSize, int32_t type)
@@ -435,19 +434,18 @@ extern "C" {
         if (nativeRdbStore == nullptr) {
             return -1;
         }
-        nativeRdbStore->SetDistributedTables(tables, tablesSize, type);
-        return 0;
+        return nativeRdbStore->SetDistributedTables(tables, tablesSize, type);
     }
 
     int32_t FfiOHOSRelationalStoreSetDistributedTablesConfig(int64_t id, char** tables, int64_t tablesSize,
-        int32_t type, DistributedRdb::DistributedConfig &distributedConfig)
+        int32_t type, RetDistributedConfig distributedConfig)
     {
         auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
         if (nativeRdbStore == nullptr) {
             return -1;
         }
-        nativeRdbStore->SetDistributedTables(tables, tablesSize, type, distributedConfig);
-        return 0;
+        DistributedRdb::DistributedConfig config{distributedConfig.autoSync};
+        return nativeRdbStore->SetDistributedTables(tables, tablesSize, type, config);
     }
 
     char* FfiOHOSRelationalStoreObtainDistributedTableName(int64_t id, const char* device, char* table)
@@ -557,28 +555,31 @@ extern "C" {
         return nativeResultSet->GetAllColumnNames();
     }
 
-    int32_t FfiOHOSRelationalStoreGetColumnCount(int64_t id)
+    int32_t FfiOHOSRelationalStoreGetColumnCount(int64_t id, int32_t *errCode)
     {
         auto nativeResultSet = FFIData::GetData<ResultSetImpl>(id);
         if (nativeResultSet == nullptr) {
+            *errCode = -1;
             return -1;
         }
         return nativeResultSet->GetColumnCount();
     }
 
-    int32_t FfiOHOSRelationalStoreGetRowCount(int64_t id)
+    int32_t FfiOHOSRelationalStoreGetRowCount(int64_t id, int32_t *errCode)
     {
         auto nativeResultSet = FFIData::GetData<ResultSetImpl>(id);
         if (nativeResultSet == nullptr) {
+            *errCode = -1;
             return -1;
         }
         return nativeResultSet->GetRowCount();
     }
 
-    int32_t FfiOHOSRelationalStoreGetRowIndex(int64_t id)
+    int32_t FfiOHOSRelationalStoreGetRowIndex(int64_t id, int32_t *errCode)
     {
         auto nativeResultSet = FFIData::GetData<ResultSetImpl>(id);
         if (nativeResultSet == nullptr) {
+            *errCode = -1;
             return -1;
         }
         return nativeResultSet->GetRowIndex();
@@ -873,6 +874,33 @@ extern "C" {
         return nativeRdbStore->RegisterObserver(event, interProcess, (std::function<void()>*)(callback), onChange);
     }
 
+    int32_t FfiOHOSRelationalStoreOnArrStr(int64_t id, int32_t subscribeType, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->RegisterObserverArrStr(subscribeType, callbackId);
+    }
+
+    int32_t FfiOHOSRelationalStoreOnChangeInfo(int64_t id, int32_t subscribeType, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->RegisterObserverChangeInfo(subscribeType, callbackId);
+    }
+
+    int32_t FfiOHOSRelationalStoreOnProgressDetails(int64_t id, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->RegisterObserverProgressDetails(callbackId);
+    }
+
     int32_t FfiOHOSRelationalStoreOff(int64_t id, const char *event, bool interProcess, void (*callback)())
     {
         auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
@@ -891,6 +919,42 @@ extern "C" {
         return nativeRdbStore->UnRegisterAllObserver(event, interProcess);
     }
 
+    int32_t FfiOHOSRelationalStoreOffArrStrChangeInfo(int64_t id, int32_t subscribeType, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->UnRegisterObserverArrStrChangeInfo(subscribeType, callbackId);
+    }
+
+    int32_t FfiOHOSRelationalStoreOffArrStrChangeInfoAll(int64_t id, int32_t subscribeType)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->UnRegisterObserverArrStrChangeInfoAll(subscribeType);
+    }
+
+    int32_t FfiOHOSRelationalStoreOffProgressDetails(int64_t id, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->UnRegisterObserverProgressDetails(callbackId);
+    }
+
+    int32_t FfiOHOSRelationalStoreOffProgressDetailsAll(int64_t id)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->UnRegisterObserverProgressDetailsAll();
+    }
+
     int32_t FfiOHOSRelationalStoreEmit(int64_t id, const char *event)
     {
         auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
@@ -899,6 +963,46 @@ extern "C" {
         }
         return nativeRdbStore->Emit(event);
     }
+
+    int32_t FfiOHOSRelationalStoreCloudSync(int64_t id, int32_t mode, CArrStr tables, int64_t callbackId)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            return -1;
+        }
+        return nativeRdbStore->CloudSync(mode, tables, callbackId);
+    }
+
+    int32_t FfiOHOSRelationalStoreGetVersion(int64_t id, int32_t *errCode)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            *errCode = -1;
+            return -1;
+        }
+        return nativeRdbStore->GetVersion(*errCode);
+    }
+
+    void FfiOHOSRelationalStoreSetVersion(int64_t id, int32_t value, int32_t *errCode)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            *errCode = -1;
+            return;
+        }
+        nativeRdbStore->SetVersion(value, *errCode);
+    }
+
+    ModifyTime FfiOHOSRelationalStoreGetModifyTime(int64_t id, char *cTable, char* cColumnName,
+        CArrPRIKeyType cPrimaryKeys, int32_t *errCode)
+    {
+        auto nativeRdbStore = FFIData::GetData<RdbStoreImpl>(id);
+        if (nativeRdbStore == nullptr) {
+            *errCode = -1;
+            return ModifyTime{0};
+        }
+        return nativeRdbStore->GetModifyTime(cTable, cColumnName, cPrimaryKeys, *errCode);
+    }
 }
 }
 }
diff --git a/relational_store/frameworks/cj/src/relational_store_impl_rdbstore.cpp b/relational_store/frameworks/cj/src/relational_store_impl_rdbstore.cpp
index 03040f647b8c3bd2b9e87072c2e92a72beca3a6b..b9da00a1f00373e9aa95cd1f41c51a66ce7d76d6 100644
--- a/relational_store/frameworks/cj/src/relational_store_impl_rdbstore.cpp
+++ b/relational_store/frameworks/cj/src/relational_store_impl_rdbstore.cpp
@@ -16,6 +16,7 @@
 #include "relational_store_utils.h"
 #include "rdb_open_callback.h"
 #include "rdb_store_config.h"
+#include "rdb_store.h"
 #include "rdb_helper.h"
 #include "abs_rdb_predicates.h"
 #include "logger.h"
@@ -42,6 +43,41 @@ using namespace OHOS::FFI;
 
 namespace OHOS {
 namespace Relational {
+    RdbStoreObserverImpl::RdbStoreObserverImpl(int64_t id, FuncType type, int32_t mode)
+    {
+        callbackId = id;
+        funcType = type;
+        mode_ = mode;
+        switch (type) {
+            case NoParam: {
+                auto cFunc = reinterpret_cast<void(*)()>(callbackId);
+                func = CJLambda::Create(cFunc);
+                break;
+            }
+            case ParamArrStr: {
+                auto cFunc = reinterpret_cast<void(*)(CArrStr arr)>(callbackId);
+                carrStrFunc = [ lambda = CJLambda::Create(cFunc)](const std::vector<std::string> &devices) ->
+                    void { lambda(VectorToCArrStr(devices)); };
+                break;
+            }
+            case ParamChangeInfo: {
+                auto cFunc = reinterpret_cast<void(*)(CArrRetChangeInfo arr)>(callbackId);
+                changeInfoFunc = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Origin &origin,
+                const PrimaryFields &fields, DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo) ->
+                    void { lambda(ToCArrRetChangeInfo(origin, fields, std::move(changeInfo))); };
+                break;
+            }
+        }
+    }
+
+    SyncObserverImpl::SyncObserverImpl(int64_t id)
+    {
+        callbackId = id;
+        auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
+        func = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
+            void { lambda(ToCProgressDetails(details)); };
+    }
+
     class DefaultOpenCallback : public NativeRdb::RdbOpenCallback {
     public:
         int OnCreate(NativeRdb::RdbStore &rdbStore) override
@@ -121,32 +157,33 @@ namespace Relational {
         return deletedRows;
     }
 
-    void RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize)
+    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize)
     {
         std::vector<std::string> tablesVector;
         for (int64_t i = 0; i < tablesSize; i++) {
             tablesVector.push_back(std::string(tables[i]));
         }
-        rdbStore_->SetDistributedTables(tablesVector);
+        return rdbStore_->SetDistributedTables(tablesVector, DistributedRdb::DISTRIBUTED_DEVICE,
+            DistributedRdb::DistributedConfig{false});
     }
 
-    void RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type)
+    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type)
     {
         std::vector<std::string> tablesVector;
         for (int64_t i = 0; i < tablesSize; i++) {
             tablesVector.push_back(std::string(tables[i]));
         }
-        rdbStore_->SetDistributedTables(tablesVector, type);
+        return rdbStore_->SetDistributedTables(tablesVector, type, DistributedRdb::DistributedConfig{false});
     }
 
-    void RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type,
+    int32_t RdbStoreImpl::SetDistributedTables(char** tables, int64_t tablesSize, int32_t type,
         DistributedRdb::DistributedConfig &distributedConfig)
     {
         std::vector<std::string> tablesVector;
         for (int64_t i = 0; i < tablesSize; i++) {
             tablesVector.push_back(std::string(tables[i]));
         }
-        rdbStore_->SetDistributedTables(tablesVector, type, distributedConfig);
+        return rdbStore_->SetDistributedTables(tablesVector, type, distributedConfig);
     }
 
     int32_t RdbStoreImpl::RollBack()
@@ -213,6 +250,9 @@ namespace Relational {
     {
         std::vector<NativeRdb::ValuesBucket> valuesVector;
         std::string tableNameStr = tableName;
+        if (tableNameStr.empty()) {
+            return RelationalStoreJsKit::E_PARAM_ERROR;
+        }
         for (int64_t i = 0; i < valuesSize; i++) {
             NativeRdb::ValuesBucket nativeValuesBucket = ConvertFromValueBucket(valuesBuckets[i]);
             valuesVector.push_back(nativeValuesBucket);
@@ -309,8 +349,7 @@ namespace Relational {
 
     int32_t RdbStoreImpl::RegisteredObserver(
         DistributedRdb::SubscribeOption option,
-        std::map<std::string,
-        std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+        std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
         std::function<void()> *callback, const std::function<void()>& callbackRef)
     {
         observers.try_emplace(option.event);
@@ -328,9 +367,55 @@ namespace Relational {
         return RelationalStoreJsKit::OK;
     }
 
-    void RdbStoreObserverImpl::RdbStoreObserverImpl::OnChange()
+    int32_t RdbStoreImpl::RegisterObserverArrStr(int32_t subscribeType, int64_t callbackId)
     {
-        m_callbackRef();
+        int32_t mode = subscribeType;
+        DistributedRdb::SubscribeOption option;
+        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+        option.event = "dataChange";
+        auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamArrStr, mode);
+        int32_t errCode = NativeRdb::E_OK;
+        if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+            errCode = rdbStore_->SubscribeObserver(option, observer);
+        } else {
+            errCode = rdbStore_->Subscribe(option, observer.get());
+        }
+        if (errCode == NativeRdb::E_OK) {
+            observers_[mode].push_back(observer);
+            LOGI("subscribe success");
+        }
+        return errCode;
+    }
+
+    int32_t RdbStoreImpl::RegisterObserverChangeInfo(int32_t subscribeType, int64_t callbackId)
+    {
+        int32_t mode = subscribeType;
+        DistributedRdb::SubscribeOption option;
+        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+        option.event = "dataChange";
+        auto observer = std::make_shared<RdbStoreObserverImpl>(callbackId, RdbStoreObserverImpl::ParamChangeInfo, mode);
+        int32_t errCode = NativeRdb::E_OK;
+        if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+            errCode = rdbStore_->SubscribeObserver(option, observer);
+        } else {
+            errCode = rdbStore_->Subscribe(option, observer.get());
+        }
+        if (errCode == NativeRdb::E_OK) {
+            observers_[mode].push_back(observer);
+            LOGI("subscribe success");
+        }
+        return errCode;
+    }
+
+    int32_t RdbStoreImpl::RegisterObserverProgressDetails(int64_t callbackId)
+    {
+        auto observer = std::make_shared<SyncObserverImpl>(callbackId);
+        int errCode = rdbStore_->RegisterAutoSyncCallback(observer);
+        if (errCode == NativeRdb::E_OK) {
+            syncObservers_.push_back(observer);
+            LOGI("progress subscribe success");
+        }
+        return errCode;
     }
 
     int32_t RdbStoreImpl::UnRegisterObserver(const char *event, bool interProcess, std::function<void()> *callback)
@@ -345,8 +430,9 @@ namespace Relational {
         return UnRegisteredObserver(option, localSharedObservers_, callback);
     }
 
-    int32_t RdbStoreImpl::UnRegisteredObserver(DistributedRdb::SubscribeOption option, std::map<std::string,
-        std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers, std::function<void()> *callback)
+    int32_t RdbStoreImpl::UnRegisteredObserver(DistributedRdb::SubscribeOption option,
+        std::map<std::string, std::list<std::shared_ptr<RdbStoreObserverImpl>>> &observers,
+        std::function<void()> *callback)
     {
         auto obs = observers.find(option.event);
         if (obs == observers.end()) {
@@ -402,6 +488,137 @@ namespace Relational {
         return RelationalStoreJsKit::OK;
     }
 
+    int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfo(int32_t subscribeType, int64_t callbackId)
+    {
+        int32_t mode = subscribeType;
+        DistributedRdb::SubscribeOption option;
+        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+        option.event = "dataChange";
+        for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
+            if (*it == nullptr) {
+                it = observers_[mode].erase(it);
+                continue;
+            }
+            if (((**it).GetCallBackId() != callbackId)) {
+                ++it;
+                continue;
+            }
+            int errCode = NativeRdb::E_OK;
+            if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+                errCode = rdbStore_->UnsubscribeObserver(option, *it);
+            } else {
+                errCode = rdbStore_->UnSubscribe(option, it->get());
+            }
+            if (errCode != NativeRdb::E_OK) {
+                return errCode;
+            }
+            it = observers_[mode].erase(it);
+        }
+        return NativeRdb::E_OK;
+    }
+    
+    int32_t RdbStoreImpl::UnRegisterObserverArrStrChangeInfoAll(int32_t subscribeType)
+    {
+        int32_t mode = subscribeType;
+        DistributedRdb::SubscribeOption option;
+        option.mode = static_cast<DistributedRdb::SubscribeMode>(mode);
+        option.event = "dataChange";
+        for (auto it = observers_[mode].begin(); it != observers_[mode].end();) {
+            if (*it == nullptr) {
+                it = observers_[mode].erase(it);
+                continue;
+            }
+            int errCode = NativeRdb::E_OK;
+            if (option.mode == DistributedRdb::SubscribeMode::LOCAL_DETAIL) {
+                errCode = rdbStore_->UnsubscribeObserver(option, *it);
+            } else {
+                errCode = rdbStore_->UnSubscribe(option, it->get());
+            }
+            if (errCode != NativeRdb::E_OK) {
+                return errCode;
+            }
+            it = observers_[mode].erase(it);
+        }
+        return NativeRdb::E_OK;
+    }
+
+    int32_t RdbStoreImpl::UnRegisterObserverProgressDetails(int64_t callbackId)
+    {
+        for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
+            if (*it == nullptr) {
+                it = syncObservers_.erase(it);
+                continue;
+            }
+            if (((**it).GetCallBackId() != callbackId)) {
+                ++it;
+                continue;
+            }
+
+            int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
+            if (errCode != NativeRdb::E_OK) {
+                return errCode;
+            }
+            it = syncObservers_.erase(it);
+        }
+        return NativeRdb::E_OK;
+    }
+
+    int32_t RdbStoreImpl::UnRegisterObserverProgressDetailsAll()
+    {
+        for (auto it = syncObservers_.begin(); it != syncObservers_.end();) {
+            if (*it == nullptr) {
+                it = syncObservers_.erase(it);
+                continue;
+            }
+            int32_t errCode = rdbStore_->UnregisterAutoSyncCallback(*it);
+            if (errCode != NativeRdb::E_OK) {
+                return errCode;
+            }
+            it = syncObservers_.erase(it);
+        }
+        return NativeRdb::E_OK;
+    }
+
+    int32_t RdbStoreImpl::CloudSync(int32_t mode, CArrStr tables, int64_t callbackId)
+    {
+        DistributedRdb::SyncOption option;
+        option.mode = static_cast<DistributedRdb::SyncMode>(mode);
+        option.isBlock = false;
+        std::vector<std::string> arr = CArrStrToVector(tables);
+        auto cFunc = reinterpret_cast<void(*)(CProgressDetails details)>(callbackId);
+        auto async = [ lambda = CJLambda::Create(cFunc)](const DistributedRdb::Details &details) ->
+            void { lambda(ToCProgressDetails(details)); };
+        int32_t errCode = rdbStore_->Sync(option, arr, async);
+        return errCode;
+    }
+
+    int32_t RdbStoreImpl::GetVersion(int32_t& errCode)
+    {
+        int32_t version = 0;
+        errCode = rdbStore_->GetVersion(version);
+        return version;
+    }
+
+    void RdbStoreImpl::SetVersion(int32_t value, int32_t &errCode)
+    {
+        errCode = rdbStore_->SetVersion(value);
+    }
+
+    ModifyTime RdbStoreImpl::GetModifyTime(char *cTables, char *cColumnName, CArrPRIKeyType &cPrimaryKeys,
+        int32_t& errCode)
+    {
+        std::string tableName = cTables;
+        std::string columnName = cColumnName;
+        std::vector<NativeRdb::RdbStore::PRIKey> keys = CArrPRIKeyTypeToPRIKeyArray(cPrimaryKeys);
+        std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> map =
+            rdbStore_->GetModifyTime(tableName, columnName, keys);
+        if (map.empty()) {
+            errCode = NativeRdb::E_ERROR;
+            return ModifyTime{0};
+        }
+        return MapToModifyTime(map, errCode);
+    }
+
     int32_t GetRealPath(AppDataMgrJsKit::JSUtils::RdbConfig &rdbConfig,
         const AppDataMgrJsKit::JSUtils::ContextParam &param,
         std::shared_ptr<OHOS::AppDataMgrJsKit::Context> abilitycontext)
diff --git a/relational_store/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp b/relational_store/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
index f44371798f6fec048049964b00dd88aa5747ddfd..35882fc0f4effb8c236b9098c0a2d738831b8035 100644
--- a/relational_store/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
+++ b/relational_store/frameworks/cj/src/relational_store_impl_resultsetproxy.cpp
@@ -118,6 +118,7 @@ namespace Relational {
         int errCode = resultSetValue->IsEnded(result);
         if (errCode != RelationalStoreJsKit::OK) {
             LOGE("IsEnded failed code:%{public}d", errCode);
+            result = true;
         }
         return result;
     }
@@ -183,6 +184,9 @@ namespace Relational {
     {
         NativeRdb::ValueObject::Asset asset;
         *rtnCode = resultSetValue->GetAsset(columnIndex, asset);
+        if (*rtnCode != RelationalStoreJsKit::OK) {
+            return Asset{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0};
+        }
         Asset result = {
             .name= MallocCString(asset.name),
             .uri= MallocCString(asset.uri),
diff --git a/relational_store/frameworks/cj/src/relational_store_utils.cpp b/relational_store/frameworks/cj/src/relational_store_utils.cpp
index 3077b922958a600baf318015916e63165b3b2cc7..a6e2795de0259ada5a4aeb0799655da47661c013 100644
--- a/relational_store/frameworks/cj/src/relational_store_utils.cpp
+++ b/relational_store/frameworks/cj/src/relational_store_utils.cpp
@@ -15,6 +15,7 @@
 
 #include "relational_store_utils.h"
 #include "native_log.h"
+#include "rdb_store.h"
 
 namespace OHOS {
 namespace Relational {
@@ -207,5 +208,190 @@ namespace Relational {
                 return ValueType {.tag = TYPE_NULL};
         }
     }
+
+    CArrStr VectorToCArrStr(const std::vector<std::string> &devices)
+    {
+        CArrStr cArrStr{0};
+        if (devices.size() == 0) {
+            return cArrStr;
+        }
+        cArrStr.head = static_cast<char**>(malloc(sizeof(char*) * devices.size()));
+        if (cArrStr.head == nullptr) {
+            return cArrStr;
+        }
+        for (size_t i = 0; i < devices.size(); i++) {
+            cArrStr.head[i] = MallocCString(devices[i]);
+        }
+        cArrStr.size = devices.size();
+        return cArrStr;
+    }
+
+    std::vector<std::string> CArrStrToVector(CArrStr carr)
+    {
+        std::vector<std::string> arr;
+        for (int i = 0; i < carr.size; i++) {
+            if (carr.head[i] != nullptr) {
+                arr.push_back(carr.head[i]);
+            } else {
+                arr.push_back(std::string());
+            }
+        }
+        return arr;
+    }
+
+    std::variant<std::monostate, std::string, int64_t, double> RetPRIKeyTypeToVariant(RetPRIKeyType &value)
+    {
+        switch (value.tag) {
+            case NativeRdb::ValueObject::TYPE_INT:
+                return std::variant<std::monostate, std::string, int64_t, double>(value.integer);
+            case NativeRdb::ValueObject::TYPE_DOUBLE:
+                return std::variant<std::monostate, std::string, int64_t, double>(value.dou);
+            case NativeRdb::ValueObject::TYPE_STRING:
+                return std::variant<std::monostate, std::string, int64_t, double>(value.string);
+            default:
+                return std::variant<std::monostate, std::string, int64_t, double>(0);
+        }
+    }
+
+    RetPRIKeyType VariantToRetPRIKeyType(const std::variant<std::monostate, std::string, int64_t, double> &value)
+    {
+        if (std::holds_alternative<int64_t>(value)) {
+            return RetPRIKeyType{ .integer = std::get<int64_t>(value), .dou = 0.0,
+                .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_INT };
+        } else if (std::holds_alternative<double>(value)) {
+            return RetPRIKeyType{ .integer = 0, .dou = std::get<double>(value),
+                .string = nullptr, .tag = NativeRdb::ValueObject::TYPE_DOUBLE };
+        } else if (std::holds_alternative<std::string>(value)) {
+            return RetPRIKeyType{ .integer = 0, .dou = 0.0,
+                .string = MallocCString(std::get<std::string>(value)), .tag = NativeRdb::ValueObject::TYPE_STRING };
+        } else {
+            return RetPRIKeyType{0};
+        }
+    }
+
+    std::vector<NativeRdb::RdbStore::PRIKey> CArrPRIKeyTypeToPRIKeyArray(CArrPRIKeyType &cPrimaryKeys)
+    {
+        std::vector<NativeRdb::RdbStore::PRIKey> res = std::vector<NativeRdb::RdbStore::PRIKey>();
+        for (int64_t i = 0; i < cPrimaryKeys.size; i++) {
+            res.push_back(RetPRIKeyTypeToVariant(cPrimaryKeys.head[i]));
+        }
+        return res;
+    }
+
+    ModifyTime MapToModifyTime(std::map<NativeRdb::RdbStore::PRIKey, NativeRdb::RdbStore::Date> &map, int32_t &errCode)
+    {
+        ModifyTime modifyTime{0};
+        modifyTime.size = map.size();
+        modifyTime.key = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * modifyTime.size));
+        modifyTime.value = static_cast<uint64_t*>(malloc(sizeof(uint64_t) * modifyTime.size));
+        if (modifyTime.key == nullptr || modifyTime.value == nullptr) {
+            free(modifyTime.key);
+            free(modifyTime.value);
+            errCode = -1;
+            return ModifyTime{0};
+        }
+        int64_t index = 0;
+        for (auto it = map.begin(); it != map.end(); ++it) {
+            modifyTime.key[index] = VariantToRetPRIKeyType(it->first);
+            modifyTime.value[index] = (it->second).date;
+            index++;
+        }
+        return modifyTime;
+    }
+
+    CArrPRIKeyType VectorToCArrPRIKeyType(std::vector<DistributedRdb::RdbStoreObserver::PrimaryKey> arr)
+    {
+        CArrPRIKeyType types{0};
+        if (arr.size() == 0) {
+            return types;
+        }
+        types.head = static_cast<RetPRIKeyType*>(malloc(sizeof(RetPRIKeyType) * arr.size()));
+        if (types.head == nullptr) {
+            return types;
+        }
+        for (size_t i = 0; i < arr.size(); i++) {
+            types.head[i] = VariantToRetPRIKeyType(arr[i]);
+        }
+        types.size = arr.size();
+        return types;
+    }
+
+    RetChangeInfo ToRetChangeInfo(const DistributedRdb::Origin &origin,
+        DistributedRdb::RdbStoreObserver::ChangeInfo::iterator info)
+    {
+        RetChangeInfo retInfo{0};
+        retInfo.table = MallocCString(info->first);
+        retInfo.type = origin.dataType;
+        retInfo.inserted = VectorToCArrPRIKeyType(info->
+            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_INSERT]);
+        retInfo.updated = VectorToCArrPRIKeyType(info->
+            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_UPDATE]);
+        retInfo.deleted = VectorToCArrPRIKeyType(info->
+            second[DistributedRdb::RdbStoreObserver::ChangeType::CHG_TYPE_DELETE]);
+        return retInfo;
+    }
+
+    CArrRetChangeInfo ToCArrRetChangeInfo(const DistributedRdb::Origin &origin,
+        const DistributedRdb::RdbStoreObserver::PrimaryFields &fields,
+        DistributedRdb::RdbStoreObserver::ChangeInfo &&changeInfo)
+    {
+        CArrRetChangeInfo infos{0};
+        if (changeInfo.size() == 0) {
+            return infos;
+        }
+        infos.head = static_cast<RetChangeInfo*>(malloc(sizeof(RetChangeInfo) * changeInfo.size()));
+        if (infos.head == nullptr) {
+            return CArrRetChangeInfo{0};
+        }
+        int64_t index = 0;
+        for (auto it = changeInfo.begin(); it != changeInfo.end(); ++it) {
+            infos.head[index] = ToRetChangeInfo(origin, it);
+            index++;
+        }
+        infos.size = changeInfo.size();
+        return infos;
+    }
+
+    CStatistic ToStatistic(DistributedRdb::Statistic statistic)
+    {
+        return CStatistic{ .total = statistic.total, .successful = statistic.success,
+            .failed = statistic.failed, .remained = statistic.untreated };
+    }
+
+    CTableDetails ToCTableDetails(DistributedRdb::TableDetail detail)
+    {
+        return CTableDetails{ .upload = ToStatistic(detail.upload), .download = ToStatistic(detail.download) };
+    }
+
+    CDetails ToCDetails(DistributedRdb::TableDetails details)
+    {
+        if (details.size() == 0) {
+            return CDetails{0};
+        }
+        char** key = static_cast<char**>(malloc(sizeof(char*) * details.size()));
+        CTableDetails* value = static_cast<CTableDetails*>(malloc(sizeof(CTableDetails) * details.size()));
+        if (key == nullptr || value == nullptr) {
+            free(key);
+            free(value);
+            return CDetails{0};
+        }
+        int64_t index = 0;
+        for (auto it = details.begin(); it != details.end(); ++it) {
+            key[index] = MallocCString(it->first);
+            value[index] = ToCTableDetails(it->second);
+            index++;
+        }
+        return CDetails{ .key = key, .value = value, .size = details.size() };
+    }
+
+    CProgressDetails ToCProgressDetails(const  DistributedRdb::Details &details)
+    {
+        if (details.empty()) {
+            return CProgressDetails{0};
+        }
+        DistributedRdb::ProgressDetail detail = details.begin() ->second;
+        return CProgressDetails{ .schedule = detail.progress, .code = detail.code,
+            .details = ToCDetails(detail.details) };
+    }
 }
 }
\ No newline at end of file
diff --git a/relational_store/frameworks/common/include/logger.h b/relational_store/frameworks/common/include/logger.h
index 9249998049f632209edffc1a2c8a99cd26665faa..821f0e6e95104cc10996eda08f59eff84879e32a 100644
--- a/relational_store/frameworks/common/include/logger.h
+++ b/relational_store/frameworks/common/include/logger.h
@@ -32,6 +32,13 @@ static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
     return { LOG_CORE, 0xD001656, "RdbNdk" };
 }
 } // namespace RdbNdk
+
+namespace SendableRdb {
+static inline OHOS::HiviewDFX::HiLogLabel LogLabel()
+{
+    return { LOG_CORE, 0xD001650, "SRdb" };
+}
+} // namespace Rdb
 } // namespace OHOS
 
 #define LOG_DEBUG(fmt, ...)                                                    \
diff --git a/relational_store/frameworks/js/napi/cloud_data/BUILD.gn b/relational_store/frameworks/js/napi/cloud_data/BUILD.gn
index 757b7d3efa82699cdc4a2810f1a4d9aee4fccc6e..163d59a9202a724f1f563ba29a9ff80085eccc67 100644
--- a/relational_store/frameworks/js/napi/cloud_data/BUILD.gn
+++ b/relational_store/frameworks/js/napi/cloud_data/BUILD.gn
@@ -22,15 +22,6 @@ ohos_copy("relational_store_declaration") {
 }
 
 ohos_shared_library("clouddata") {
-  branch_protector_ret = "pac_ret"
-  sanitize = {
-    ubsan = true
-    boundary_sanitize = true
-    cfi = true
-    cfi_cross_dso = true
-    debug = false
-  }
-
   sources = [
     "${cloud_data_napi_path}/src/entry_point.cpp",
     "${cloud_data_napi_path}/src/js_client.cpp",
diff --git a/relational_store/frameworks/js/napi/cloud_data/src/js_config.cpp b/relational_store/frameworks/js/napi/cloud_data/src/js_config.cpp
index f1f8498b3f760f4237025edf7815bc2ee83e859c..c9b8174f4761cf12a0ca6a757ac52c7487d942b2 100644
--- a/relational_store/frameworks/js/napi/cloud_data/src/js_config.cpp
+++ b/relational_store/frameworks/js/napi/cloud_data/src/js_config.cpp
@@ -413,7 +413,7 @@ napi_value JsConfig::SetGlobalCloudStrategy(napi_env env, napi_callback_info inf
                                ? napi_ok: napi_generic_failure;
             return;
         }
-        LOG_DEBUG("SetGlobalCloudStrategy execute");
+        LOG_DEBUG("SetGlobalCloudStrategy execute.");
 
         auto res = proxy->SetGlobalCloudStrategy(ctxt->strategy, ctxt->param);
         ctxt->status =
diff --git a/relational_store/frameworks/js/napi/cloud_data/src/napi_queue.cpp b/relational_store/frameworks/js/napi/cloud_data/src/napi_queue.cpp
index 803d9109bbbf9f48180baa3ecf09ebe52dce7f1e..0d031116a1075653a011e790043e0d64c72bc302 100644
--- a/relational_store/frameworks/js/napi/cloud_data/src/napi_queue.cpp
+++ b/relational_store/frameworks/js/napi/cloud_data/src/napi_queue.cpp
@@ -60,9 +60,9 @@ void ContextBase::GetCbInfo(napi_env envi, napi_callback_info info, NapiCbInfoPa
             status = napi_create_reference(env, argv[index], 1, &callbackRef);
             ASSERT_STATUS(this, "ref callback failed!");
             argc = index;
-            LOG_DEBUG("async callback, no promise");
+            LOG_DEBUG("async callback, no promise.");
         } else {
-            LOG_DEBUG("no callback, async pormose");
+            LOG_DEBUG("no callback, async pormose.");
         }
     }
 
@@ -88,7 +88,7 @@ napi_value NapiQueue::AsyncWork(napi_env env, std::shared_ptr<ContextBase> ctxt,
     napi_value promise = nullptr;
     if (aCtx->ctx->callbackRef == nullptr) {
         napi_create_promise(env, &aCtx->deferred, &promise);
-        LOG_DEBUG("create deferred promise");
+        LOG_DEBUG("create deferred promise.");
     } else {
         napi_get_undefined(env, &promise);
     }
@@ -156,17 +156,17 @@ void NapiQueue::GenerateOutput(AsyncContext &ctx, napi_value output)
     }
     if (ctx.deferred != nullptr) {
         if (ctx.ctx->status == napi_ok) {
-            LOG_DEBUG("deferred promise resolved");
+            LOG_DEBUG("deferred promise resolved.");
             napi_resolve_deferred(ctx.env, ctx.deferred, result[RESULT_DATA]);
         } else {
-            LOG_DEBUG("deferred promise rejected");
+            LOG_DEBUG("deferred promise rejected.");
             napi_reject_deferred(ctx.env, ctx.deferred, result[RESULT_ERROR]);
         }
     } else {
         napi_value callback = nullptr;
         napi_get_reference_value(ctx.env, ctx.ctx->callbackRef, &callback);
         napi_value callbackResult = nullptr;
-        LOG_DEBUG("call callback function");
+        LOG_DEBUG("call callback function.");
         napi_call_function(ctx.env, nullptr, callback, RESULT_ALL, result, &callbackResult);
     }
 }
diff --git a/relational_store/frameworks/js/napi/cloud_extension/BUILD.gn b/relational_store/frameworks/js/napi/cloud_extension/BUILD.gn
index b4c46257b14406f45e88f080a01b36ebe19f67f6..93e7217a1497a9fa53ad3a8b753dd89b29cfbf8f 100644
--- a/relational_store/frameworks/js/napi/cloud_extension/BUILD.gn
+++ b/relational_store/frameworks/js/napi/cloud_extension/BUILD.gn
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import("//arkcompiler/ets_frontend/es2panda/es2abc_config.gni")
+import("//build/config/components/ets_frontend/es2abc_config.gni")
 import("//build/ohos.gni")
 import("//foundation/arkui/ace_engine/ace_config.gni")
 
diff --git a/relational_store/frameworks/js/napi/common/include/js_ability.h b/relational_store/frameworks/js/napi/common/include/js_ability.h
index d7ac08013cfce1ba50ddfda2ef3669ced11b45e2..86ce41de3589abdf00d2686a549616aa6ac6cd26 100644
--- a/relational_store/frameworks/js/napi/common/include/js_ability.h
+++ b/relational_store/frameworks/js/napi/common/include/js_ability.h
@@ -63,6 +63,7 @@ public:
     static std::shared_ptr<Context> GetContext(napi_env env, napi_value object);
     static std::shared_ptr<Context> GetStageModeContext(napi_env env, napi_value value);
     static std::shared_ptr<Context> GetCurrentAbility(napi_env env, napi_value value);
+    static int32_t GetHapVersion(napi_env env, napi_value value);
 };
 } // namespace AppDataMgrJsKit
 } // namespace OHOS
diff --git a/relational_store/frameworks/js/napi/common/include/js_sendable_utils.h b/relational_store/frameworks/js/napi/common/include/js_sendable_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a97c209e184d7926faa3926736b8e6c4f57bebf
--- /dev/null
+++ b/relational_store/frameworks/js/napi/common/include/js_sendable_utils.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DISTRIBUTEDDATAMGR_APPDATAMGR_JS_SENDABLE_UTILS_H
+#define DISTRIBUTEDDATAMGR_APPDATAMGR_JS_SENDABLE_UTILS_H
+
+#include <cstdint>
+
+#include "js_utils.h"
+#include "napi/native_common.h"
+#include "napi/native_node_api.h"
+
+namespace OHOS {
+namespace AppDataMgrJsKit {
+namespace JSUtils {
+#define DECLARE_SENDABLE_PROPERTY(env, key, value) \
+    napi_property_descriptor(DECLARE_NAPI_DEFAULT_PROPERTY((key), Convert2Sendable((env), (value))))
+
+int32_t Convert2Sendable(napi_env env, std::string value, napi_value &output);
+int32_t Convert2Sendable(napi_env env, bool value, napi_value &output);
+int32_t Convert2Sendable(napi_env env, double value, napi_value &output);
+
+napi_value Convert2Sendable(napi_env env, const std::string &value);
+napi_value Convert2Sendable(napi_env env, const std::vector<uint8_t> &value);
+napi_value Convert2Sendable(napi_env env, const std::vector<float> &value);
+napi_value Convert2Sendable(napi_env env, int32_t value);
+napi_value Convert2Sendable(napi_env env, uint32_t value);
+napi_value Convert2Sendable(napi_env env, int64_t value);
+napi_value Convert2Sendable(napi_env env, double value);
+napi_value Convert2Sendable(napi_env env, bool value);
+napi_value Convert2Sendable(napi_env env, const std::monostate &value);
+
+template<typename T>
+napi_value Convert2Sendable(napi_env env, const T &value);
+
+template<typename T>
+napi_value Convert2Sendable(napi_env env, const std::vector<T> &value);
+
+template<typename... Types>
+napi_value Convert2Sendable(napi_env env, const std::variant<Types...> &value);
+
+template<typename T>
+napi_value GetSendableValue(napi_env env, const T &value)
+{
+    return nullptr;
+}
+
+template<typename T, typename First, typename... Types>
+napi_value GetSendableValue(napi_env env, const T &value)
+{
+    auto *val = std::get_if<First>(&value);
+    if (val != nullptr) {
+        return Convert2Sendable(env, *val);
+    }
+    return GetSendableValue<T, Types...>(env, value);
+}
+
+napi_value ToSendableObject(napi_env env, napi_value jsValue);
+napi_value ToSendableArray(napi_env env, napi_value jsValue);
+napi_value ToSendableTypedArray(napi_env env, napi_value jsValue);
+napi_value Convert2Sendable(napi_env env, napi_value jsValue);
+} // namespace JSUtils
+
+template<typename T>
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::vector<T> &value)
+{
+    napi_value jsValue;
+    napi_status status = napi_create_sendable_array_with_length(env, value.size(), &jsValue);
+    if (status != napi_ok) {
+        return nullptr;
+    }
+
+    for (size_t i = 0; i < value.size(); ++i) {
+        napi_set_element(env, jsValue, i, Convert2Sendable(env, value[i]));
+    }
+    return jsValue;
+}
+
+template<typename... Types>
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::variant<Types...> &value)
+{
+    return GetSendableValue<decltype(value), Types...>(env, value);
+}
+} // namespace AppDataMgrJsKit
+} // namespace OHOS
+#endif // DISTRIBUTEDDATAMGR_APPDATAMGR_JS_SENDABLE_UTILS_H
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/common/include/js_utils.h b/relational_store/frameworks/js/napi/common/include/js_utils.h
index 7c67b4323d87527087770a0233111b32fa6a125e..920cfd17bc960e4e5a46ea34b8b7fa970960a14f 100644
--- a/relational_store/frameworks/js/napi/common/include/js_utils.h
+++ b/relational_store/frameworks/js/napi/common/include/js_utils.h
@@ -35,7 +35,16 @@
 namespace OHOS {
 namespace AppDataMgrJsKit {
 namespace JSUtils {
-
+#define DECLARE_JS_PROPERTY(env, key, value) \
+    napi_property_descriptor(DECLARE_NAPI_DEFAULT_PROPERTY((key), Convert2JSValue((env), (value))))
+
+#define ASSERT(condition, message, retVal)                       \
+    do {                                                         \
+        if (!(condition)) {                                      \
+            LOG_ERROR("test (" #condition ") failed: " message); \
+            return retVal;                                       \
+        }                                                        \
+    } while (0)
 static constexpr int OK = 0;
 static constexpr int ERR = -1;
 static constexpr uint32_t ASYNC_RST_SIZE = 2;
@@ -48,9 +57,8 @@ struct JsFeatureSpace {
     bool isComponent;
 };
 
-int32_t Convert2ValueExt(napi_env env, napi_value jsValue, uint32_t &output);
-int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int32_t &output);
-int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int64_t &output);
+void SetHapVersion(int32_t hapversion);
+int32_t GetHapVersion();
 
 int32_t Convert2Value(napi_env env, napi_value jsValue, napi_value &output);
 int32_t Convert2Value(napi_env env, napi_value jsValue, bool &output);
@@ -73,6 +81,10 @@ int32_t Convert2Value(napi_env env, napi_value jsValue, T &output);
 template<typename T>
 int32_t Convert2ValueExt(napi_env env, napi_value jsValue, T &output);
 
+int32_t Convert2ValueExt(napi_env env, napi_value jsValue, uint32_t &output);
+int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int32_t &output);
+int32_t Convert2ValueExt(napi_env env, napi_value jsValue, int64_t &output);
+
 template<typename T>
 int32_t Convert2Value(napi_env env, napi_value jsValue, std::vector<T> &value);
 
@@ -94,7 +106,6 @@ int32_t Convert2JSValue(napi_env env, std::string value, napi_value &output);
 int32_t Convert2JSValue(napi_env env, bool value, napi_value &output);
 int32_t Convert2JSValue(napi_env env, double value, napi_value &output);
 
-napi_value Convert2JSValue(napi_env env, const std::vector<std::string> &value);
 napi_value Convert2JSValue(napi_env env, const std::string &value);
 napi_value Convert2JSValue(napi_env env, const std::vector<uint8_t> &value);
 napi_value Convert2JSValue(napi_env env, const std::vector<float> &value);
@@ -199,6 +210,11 @@ inline int32_t SetNamedProperty(napi_env env, napi_value in, const std::string &
 {
     return napi_set_named_property(env, in, prop.c_str(), Convert2JSValue(env, value));
 };
+
+napi_value ToJsObject(napi_env env, napi_value sendableValue);
+napi_value ToJsArray(napi_env env, napi_value sendableValue);
+napi_value ToJsTypedArray(napi_env env, napi_value sendableValue);
+napi_value Convert2JSValue(napi_env env, napi_value sendableValue);
 } // namespace JSUtils
 
 template<typename T>
diff --git a/relational_store/frameworks/js/napi/common/mock/include/js_ability.h b/relational_store/frameworks/js/napi/common/mock/include/js_ability.h
index 9678deeb16b7169616d397d653682280c9d8d939..e557ffd4bb85e4a0db4fea1376be95bda84bd623 100644
--- a/relational_store/frameworks/js/napi/common/mock/include/js_ability.h
+++ b/relational_store/frameworks/js/napi/common/mock/include/js_ability.h
@@ -65,6 +65,7 @@ public:
     static std::shared_ptr<Context> GetContext(napi_env env, napi_value object);
     static std::shared_ptr<Context> GetStageModeContext(napi_env env, napi_value value);
     static std::shared_ptr<Context> GetCurrentAbility(napi_env env, napi_value value);
+    static int32_t GetHapVersion(napi_env env, napi_value value);
 };
 } // namespace AppDataMgrJsKit
 } // namespace OHOS
diff --git a/relational_store/frameworks/js/napi/common/mock/src/js_ability.cpp b/relational_store/frameworks/js/napi/common/mock/src/js_ability.cpp
index 762b463bf0fb1e9f4108fc93dbc13c201b9309cd..29f63a2ef50fe8aaa3ed9f2a10cb02964d376499 100644
--- a/relational_store/frameworks/js/napi/common/mock/src/js_ability.cpp
+++ b/relational_store/frameworks/js/napi/common/mock/src/js_ability.cpp
@@ -14,6 +14,7 @@
  */
 #define LOG_TAG "JSAbility"
 #include "js_ability.h"
+#include "js_utils.h"
 
 #include <cstdlib>
 
@@ -144,5 +145,10 @@ int Context::GetSystemDatabaseDir(const std::string &dataGroupId, std::string &d
     databaseDir = databaseDir_;
     return 0;
 }
+
+int32_t JSAbility::GetHapVersion(napi_env env, napi_value value)
+{
+    return JSUtils::GetHapVersion();
+}
 } // namespace AppDataMgrJsKit
 } // namespace OHOS
diff --git a/relational_store/frameworks/js/napi/common/src/js_ability.cpp b/relational_store/frameworks/js/napi/common/src/js_ability.cpp
index 66e5439b1a7c8f7048931aab931a0fe58f6f9393..d3092338110d0806d2625da02ff10477289e55fc 100644
--- a/relational_store/frameworks/js/napi/common/src/js_ability.cpp
+++ b/relational_store/frameworks/js/napi/common/src/js_ability.cpp
@@ -14,10 +14,13 @@
  */
 #define LOG_TAG "JSAbility"
 #include "js_ability.h"
+#include "js_utils.h"
 
 #include "extension_context.h"
 #include "logger.h"
 
+#define API_VERSION_MOD 100
+
 namespace OHOS {
 namespace AppDataMgrJsKit {
 using namespace OHOS::Rdb;
@@ -164,5 +167,19 @@ std::shared_ptr<Context> JSAbility::GetCurrentAbility(napi_env env, napi_value v
     }
     return std::make_shared<Context>(abilityContext);
 }
+
+int32_t JSAbility::GetHapVersion(napi_env env, napi_value value)
+{
+    auto stageContext = AbilityRuntime::GetStageModeContext(env, value);
+    if (stageContext == nullptr) {
+        return napi_invalid_arg;
+    }
+    auto appInfo = stageContext->GetApplicationInfo();
+    if (appInfo != nullptr) {
+        return appInfo->apiTargetVersion % API_VERSION_MOD;
+    }
+    LOG_WARN("GetApplicationInfo failed.");
+    return napi_invalid_arg;
+}
 } // namespace AppDataMgrJsKit
 } // namespace OHOS
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/common/src/js_sendable_utils.cpp b/relational_store/frameworks/js/napi/common/src/js_sendable_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..197372720f9e24e493827659858ab431e1b054a0
--- /dev/null
+++ b/relational_store/frameworks/js/napi/common/src/js_sendable_utils.cpp
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "JSSendableUtils"
+#include "js_sendable_utils.h"
+
+#include <cstring>
+
+#include "js_native_api.h"
+#include "js_utils.h"
+#include "logger.h"
+#include "securec.h"
+using namespace OHOS::Rdb;
+namespace OHOS {
+namespace AppDataMgrJsKit {
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::string &value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::vector<uint8_t> &value)
+{
+    napi_value jsValue = nullptr;
+    void *native = nullptr;
+    napi_value buffer = nullptr;
+    napi_status status = napi_create_sendable_arraybuffer(env, value.size(), &native, &buffer);
+    if (status != napi_ok) {
+        LOG_ERROR("napi_create_sendable_arraybuffer failed %{public}d", status);
+        return nullptr;
+    }
+    if (value.size() != 0) {
+        std::copy(value.begin(), value.end(), static_cast<uint8_t *>(native));
+    }
+    status = napi_create_sendable_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &jsValue);
+    if (status != napi_ok) {
+        LOG_ERROR("napi_create_sendable_typedarray failed %{public}d", status);
+        return nullptr;
+    }
+    return jsValue;
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, int32_t value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, uint32_t value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, int64_t value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, double value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, bool value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::vector<float> &value)
+{
+    napi_value jsValue = nullptr;
+    float *native = nullptr;
+    napi_value buffer = nullptr;
+    napi_status status = napi_create_sendable_arraybuffer(env, value.size() * sizeof(float), (void **)&native, &buffer);
+    if (status != napi_ok) {
+        LOG_ERROR("napi_create_sendable_arraybuffer failed %{public}d", status);
+        return nullptr;
+    }
+    if (value.size() != 0) {
+        std::copy(value.begin(), value.end(), static_cast<float *>(native));
+    }
+    status = napi_create_sendable_typedarray(env, napi_float32_array, value.size(), buffer, 0, &jsValue);
+    if (status != napi_ok) {
+        LOG_ERROR("napi_create_sendable_typedarray failed %{public}d", status);
+        return nullptr;
+    }
+    return jsValue;
+}
+
+int32_t JSUtils::Convert2Sendable(napi_env env, std::string value, napi_value &output)
+{
+    return Convert2JSValue(env, value, output);
+}
+
+int32_t JSUtils::Convert2Sendable(napi_env env, bool value, napi_value &output)
+{
+    return Convert2JSValue(env, value, output);
+}
+
+int32_t JSUtils::Convert2Sendable(napi_env env, double value, napi_value &output)
+{
+    return Convert2JSValue(env, value, output);
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, const std::monostate &value)
+{
+    return Convert2JSValue(env, value);
+}
+
+napi_value JSUtils::ToSendableObject(napi_env env, napi_value jsValue)
+{
+    LOG_DEBUG("jsObject -> sendableObject");
+    napi_value keys = nullptr;
+    napi_status status = napi_get_all_property_names(env, jsValue, napi_key_own_only,
+        static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, &keys);
+    ASSERT(status == napi_ok, "napi_get_all_property_names failed", nullptr);
+    uint32_t length = 0;
+    status = napi_get_array_length(env, keys, &length);
+    ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr);
+    std::vector<napi_property_descriptor> descriptors;
+    // keysHold guarantees that the string address is valid before create the sendable object.
+    std::vector<std::string> keysHold(length, "");
+    for (uint32_t i = 0; i < length; ++i) {
+        napi_value key = nullptr;
+        status = napi_get_element(env, keys, i, &key);
+        ASSERT(status == napi_ok, "napi_get_element failed", nullptr);
+        JSUtils::Convert2Value(env, key, keysHold[i]);
+        napi_value value = nullptr;
+        status = napi_get_named_property(env, jsValue, keysHold[i].c_str(), &value);
+        ASSERT(status == napi_ok, "napi_get_named_property failed", nullptr);
+        descriptors.emplace_back(DECLARE_SENDABLE_PROPERTY(env, keysHold[i].c_str(), value));
+    }
+    napi_value sendableObject = nullptr;
+    status = napi_create_sendable_object_with_properties(env, descriptors.size(), descriptors.data(), &sendableObject);
+    ASSERT(status == napi_ok, "napi_create_sendable_object_with_properties failed", nullptr);
+    return sendableObject;
+}
+
+napi_value JSUtils::ToSendableArray(napi_env env, napi_value jsValue)
+{
+    LOG_DEBUG("jsArray -> sendableArray");
+    uint32_t arrLen = 0;
+    napi_status status = napi_get_array_length(env, jsValue, &arrLen);
+    ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr);
+    napi_value sendableArray = nullptr;
+    status = napi_create_sendable_array_with_length(env, arrLen, &sendableArray);
+    ASSERT(status == napi_ok, "napi_create_sendable_array_with_length failed", nullptr);
+    for (size_t i = 0; i < arrLen; ++i) {
+        napi_value element;
+        status = napi_get_element(env, jsValue, i, &element);
+        ASSERT(status == napi_ok, "napi_get_element failed", nullptr);
+        status = napi_set_element(env, sendableArray, i, Convert2Sendable(env, element));
+        ASSERT(status == napi_ok, "napi_set_element failed", nullptr);
+    }
+    return sendableArray;
+}
+
+napi_value JSUtils::ToSendableTypedArray(napi_env env, napi_value jsValue)
+{
+    LOG_DEBUG("jsTypedArryay -> sendableTypedArryay");
+    napi_typedarray_type type;
+    size_t length = 0;
+    void *tmp = nullptr;
+    napi_status status = napi_get_typedarray_info(env, jsValue, &type, &length, &tmp, nullptr, nullptr);
+    ASSERT(status == napi_ok, "napi_get_typedarray_info failed", nullptr);
+
+    if (type != napi_uint8_array && type != napi_float32_array) {
+        LOG_ERROR("type is invalid %{public}d", type);
+        return nullptr;
+    }
+    napi_value sendableTypedArryay = nullptr;
+    void *native = nullptr;
+    napi_value buffer = nullptr;
+    status = napi_create_sendable_arraybuffer(env, length, (void **)&native, &buffer);
+    ASSERT(status == napi_ok, "napi_create_sendable_arraybuffer failed", nullptr);
+    if (length > 0) {
+        errno_t result = memcpy_s(native, length, tmp, length);
+        if (result != EOK) {
+            LOG_ERROR("memcpy_s failed, result is %{public}d", result);
+            return nullptr;
+        }
+    }
+    auto size = (type == napi_uint8_array) ? length : length / sizeof(float);
+    status = napi_create_sendable_typedarray(env, type, size, buffer, 0, &sendableTypedArryay);
+    ASSERT(status == napi_ok, "napi_create_sendable_typedarray failed", nullptr);
+    return sendableTypedArryay;
+}
+
+napi_value JSUtils::Convert2Sendable(napi_env env, napi_value jsValue)
+{
+    bool result = false;
+    napi_status status = napi_is_sendable(env, jsValue, &result);
+    ASSERT(status == napi_ok, "napi_is_sendable failed", nullptr);
+    if (result) {
+        return jsValue;
+    }
+    status = napi_is_array(env, jsValue, &result);
+    ASSERT(status == napi_ok, "napi_is_array failed", nullptr);
+    if (result) {
+        return ToSendableArray(env, jsValue);
+    }
+    status = napi_is_typedarray(env, jsValue, &result);
+    ASSERT(status == napi_ok, "napi_is_typedarray failed", nullptr);
+    if (result) {
+        return ToSendableTypedArray(env, jsValue);
+    }
+    return ToSendableObject(env, jsValue);
+}
+} // namespace AppDataMgrJsKit
+} // namespace OHOS
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/common/src/js_utils.cpp b/relational_store/frameworks/js/napi/common/src/js_utils.cpp
index decdf380af0d58f7283f5345da08e41d9a01dc98..02e054b67ce3efbc3a679b2940128873ad988b69 100644
--- a/relational_store/frameworks/js/napi/common/src/js_utils.cpp
+++ b/relational_store/frameworks/js/napi/common/src/js_utils.cpp
@@ -13,22 +13,30 @@
  * limitations under the License.
  */
 #define LOG_TAG "JSUtils"
+
 #include "js_utils.h"
+
+#include <cstring>
+
 #include "js_native_api_types.h"
 #include "logger.h"
-#include <cstring>
+#include "securec.h"
 using namespace OHOS::Rdb;
 
-#define CHECK_RETURN_RET(assertion, message, revt)                       \
-    do {                                                                 \
-        if (!(assertion)) {                                              \
-            LOG_WARN("assertion (" #assertion ") failed: " message);     \
-            return revt;                                                 \
-        }                                                                \
+#define CHECK_RETURN_RET(assertion, message, revt)                   \
+    do {                                                             \
+        if (!(assertion)) {                                          \
+            LOG_WARN("assertion (" #assertion ") failed: " message); \
+            return revt;                                             \
+        }                                                            \
     } while (0)
 
 namespace OHOS {
 namespace AppDataMgrJsKit {
+namespace JSUtils {
+    static int32_t g_hapVersion = -1;  // the current apiVersion of hap
+}
+
 static constexpr JSUtils::JsFeatureSpace FEATURE_NAME_SPACES[] = {
     { "ohos.data.cloudData", "ZGF0YS5jbG91ZERhdGE=", true },
     { "ohos.data.dataAbility", "ZGF0YS5kYXRhQWJpbGl0eQ==", true },
@@ -39,6 +47,16 @@ static constexpr JSUtils::JsFeatureSpace FEATURE_NAME_SPACES[] = {
     { "ohos.data.relationalStore", "ZGF0YS5yZWxhdGlvbmFsU3RvcmU=", true },
 };
 
+void JSUtils::SetHapVersion(int32_t hapversion)
+{
+    g_hapVersion = hapversion;
+}
+
+int32_t JSUtils::GetHapVersion()
+{
+    return g_hapVersion;
+}
+
 const std::optional<JSUtils::JsFeatureSpace> JSUtils::GetJsFeatureSpace(const std::string &name)
 {
     auto jsFeature = JsFeatureSpace{ name.data(), nullptr, false };
@@ -47,15 +65,15 @@ const std::optional<JSUtils::JsFeatureSpace> JSUtils::GetJsFeatureSpace(const st
         [](const JsFeatureSpace &JsFeatureSpace1, const JsFeatureSpace &JsFeatureSpace2) {
             return strcmp(JsFeatureSpace1.spaceName, JsFeatureSpace2.spaceName) < 0;
         });
-    if (iter < FEATURE_NAME_SPACES + sizeof(FEATURE_NAME_SPACES) / sizeof(FEATURE_NAME_SPACES[0])
-        && strcmp(iter->spaceName, name.data()) == 0) {
+    if (iter < FEATURE_NAME_SPACES + sizeof(FEATURE_NAME_SPACES) / sizeof(FEATURE_NAME_SPACES[0]) &&
+        strcmp(iter->spaceName, name.data()) == 0) {
         return *iter;
     }
     return std::nullopt;
 }
 
 std::pair<napi_status, napi_value> JSUtils::GetInnerValue(
-    napi_env env, napi_value in, const std::string& prop, bool optional)
+    napi_env env, napi_value in, const std::string &prop, bool optional)
 {
     bool hasProp = false;
     napi_status status = napi_has_named_property(env, in, prop.c_str(), &hasProp);
@@ -202,8 +220,9 @@ int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::vector<flo
         return napi_invalid_arg;
     }
 
-    output = (tmp != nullptr ? std::vector<float>(static_cast<float*>(tmp),
-        static_cast<float*>(tmp) + length / sizeof(float)) : std::vector<float>());
+    output = (tmp != nullptr
+                  ? std::vector<float>(static_cast<float *>(tmp), static_cast<float *>(tmp) + length / sizeof(float))
+                  : std::vector<float>());
     return status;
 }
 
@@ -257,8 +276,8 @@ int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::vector<uin
         return napi_invalid_arg;
     }
 
-    output = (tmp != nullptr ? std::vector<uint8_t>(static_cast<uint8_t*>(tmp),
-        static_cast<uint8_t*>(tmp) + length) : std::vector<uint8_t>());
+    output = (tmp != nullptr ? std::vector<uint8_t>(static_cast<uint8_t *>(tmp), static_cast<uint8_t *>(tmp) + length)
+                             : std::vector<uint8_t>());
     return status;
 }
 
@@ -272,7 +291,7 @@ int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::monostate
         value = std::monostate();
         return napi_ok;
     }
-    LOG_DEBUG("jsValue is not null");
+    LOG_DEBUG("jsValue is not null.");
     return napi_invalid_arg;
 }
 
@@ -334,20 +353,6 @@ int32_t JSUtils::Convert2Value(napi_env env, napi_value jsValue, std::map<std::s
     return napi_ok;
 }
 
-napi_value JSUtils::Convert2JSValue(napi_env env, const std::vector<std::string> &value)
-{
-    napi_value jsValue = nullptr;
-    napi_status status = napi_create_array_with_length(env, value.size(), &jsValue);
-    if (status != napi_ok) {
-        return nullptr;
-    }
-
-    for (size_t i = 0; i < value.size(); ++i) {
-        napi_set_element(env, jsValue, i, Convert2JSValue(env, value[i]));
-    }
-    return jsValue;
-}
-
 napi_value JSUtils::Convert2JSValue(napi_env env, const std::string &value)
 {
     napi_value jsValue = nullptr;
@@ -475,7 +480,7 @@ int32_t JSUtils::Convert2JSValue(napi_env env, std::string value, napi_value &ou
 {
     std::string tempStr = std::string(value);
     if (napi_create_string_utf8(env, tempStr.c_str(), tempStr.size(), &output) != napi_ok) {
-        LOG_ERROR("Convert2JSValue create JS string failed");
+        LOG_ERROR("Convert2JSValue create JS string failed.");
         return ERR;
     }
     return napi_ok;
@@ -484,7 +489,7 @@ int32_t JSUtils::Convert2JSValue(napi_env env, std::string value, napi_value &ou
 int32_t JSUtils::Convert2JSValue(napi_env env, bool value, napi_value &output)
 {
     if (napi_get_boolean(env, value, &output) != napi_ok) {
-        LOG_ERROR("Convert2JSValue create JS bool failed");
+        LOG_ERROR("Convert2JSValue create JS bool failed.");
         return ERR;
     }
     return napi_ok;
@@ -493,7 +498,7 @@ int32_t JSUtils::Convert2JSValue(napi_env env, bool value, napi_value &output)
 int32_t JSUtils::Convert2JSValue(napi_env env, double value, napi_value &output)
 {
     if (napi_create_double(env, value, &output) != napi_ok) {
-        LOG_ERROR("Convert2JSValue create JS double failed");
+        LOG_ERROR("Convert2JSValue create JS double failed.");
         return ERR;
     }
     return napi_ok;
@@ -601,5 +606,112 @@ bool JSUtils::Equal(napi_env env, napi_ref ref, napi_value value)
     napi_strict_equals(env, value, callback, &isEquals);
     return isEquals;
 }
+
+napi_value JSUtils::ToJsObject(napi_env env, napi_value sendableValue)
+{
+    LOG_DEBUG("sendableObject -> jsObject");
+    napi_value keys = nullptr;
+    napi_status status = napi_get_all_property_names(env, sendableValue, napi_key_own_only,
+        static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, &keys);
+    ASSERT(status == napi_ok, "napi_get_all_property_names failed", nullptr);
+    uint32_t length = 0;
+    status = napi_get_array_length(env, keys, &length);
+    ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr);
+    std::vector<napi_property_descriptor> descriptors;
+    // keysHold guarantees that the string address is valid before create the sendable object.
+    std::vector<std::string> keysHold(length, "");
+    for (uint32_t i = 0; i < length; ++i) {
+        napi_value key = nullptr;
+        status = napi_get_element(env, keys, i, &key);
+        ASSERT(status == napi_ok, "napi_get_element failed", nullptr);
+        JSUtils::Convert2Value(env, key, keysHold[i]);
+        napi_value value = nullptr;
+        status = napi_get_named_property(env, sendableValue, keysHold[i].c_str(), &value);
+        ASSERT(status == napi_ok, "napi_get_named_property failed", nullptr);
+        descriptors.emplace_back(DECLARE_JS_PROPERTY(env, keysHold[i].c_str(), value));
+    }
+    napi_value jsObject = nullptr;
+    status = napi_create_object_with_properties(env, &jsObject, descriptors.size(), descriptors.data());
+    ASSERT(status == napi_ok, "napi_create_object_with_properties failed", nullptr);
+    return jsObject;
+}
+
+napi_value JSUtils::ToJsArray(napi_env env, napi_value sendableValue)
+{
+    LOG_DEBUG("sendableArray -> jsArray");
+    uint32_t arrLen = 0;
+    napi_status status = napi_get_array_length(env, sendableValue, &arrLen);
+    ASSERT(status == napi_ok, "napi_get_array_length failed", nullptr);
+    napi_value jsArray = nullptr;
+    status = napi_create_array_with_length(env, arrLen, &jsArray);
+    ASSERT(status == napi_ok, "napi_create_array_with_length failed", nullptr);
+    for (size_t i = 0; i < arrLen; ++i) {
+        napi_value element;
+        status = napi_get_element(env, sendableValue, i, &element);
+        ASSERT(status == napi_ok, "napi_get_element failed", nullptr);
+        status = napi_set_element(env, jsArray, i, Convert2JSValue(env, element));
+        ASSERT(status == napi_ok, "napi_set_element failed", nullptr);
+    }
+    return jsArray;
+}
+
+napi_value JSUtils::ToJsTypedArray(napi_env env, napi_value sendableValue)
+{
+    LOG_DEBUG("sendableTypedArray -> jsTypedArray");
+    napi_typedarray_type type;
+    size_t length = 0;
+    void *tmp = nullptr;
+    napi_status status = napi_get_typedarray_info(env, sendableValue, &type, &length, &tmp, nullptr, nullptr);
+    ASSERT(status == napi_ok, "napi_get_typedarray_info failed", nullptr);
+
+    if (type != napi_uint8_array && type != napi_float32_array) {
+        LOG_ERROR("type is invalid %{public}d", type);
+        return nullptr;
+    }
+    napi_value jsTypedArray = nullptr;
+    void *native = nullptr;
+    napi_value buffer = nullptr;
+    status = napi_create_arraybuffer(env, length, (void **)&native, &buffer);
+    ASSERT(status == napi_ok, "napi_create_arraybuffer failed", nullptr);
+    if (length > 0) {
+        errno_t result = memcpy_s(native, length, tmp, length);
+        if (result != EOK) {
+            LOG_ERROR("memcpy_s failed, result is %{public}d", result);
+            return nullptr;
+        }
+    }
+    auto size = (type == napi_uint8_array) ? length : length / sizeof(float);
+    status = napi_create_typedarray(env, type, size, buffer, 0, &jsTypedArray);
+    ASSERT(status == napi_ok, "napi_create_typedarray failed", nullptr);
+    return jsTypedArray;
+}
+
+napi_value JSUtils::Convert2JSValue(napi_env env, napi_value sendableValue)
+{
+    napi_valuetype type = napi_undefined;
+    napi_status status = napi_typeof(env, sendableValue, &type);
+    ASSERT(status == napi_ok, "napi_typeof failed", nullptr);
+    if (type != napi_object) {
+        return sendableValue;
+    }
+    bool result = false;
+    status = napi_is_sendable(env, sendableValue, &result);
+    ASSERT(status == napi_ok, "napi_is_sendable failed", nullptr);
+    if (!result) {
+        return sendableValue;
+    }
+
+    status = napi_is_array(env, sendableValue, &result);
+    ASSERT(status == napi_ok, "napi_is_array failed", nullptr);
+    if (result) {
+        return ToJsArray(env, sendableValue);
+    }
+    status = napi_is_typedarray(env, sendableValue, &result);
+    ASSERT(status == napi_ok, "napi_is_typedarray failed", nullptr);
+    if (result) {
+        return ToJsTypedArray(env, sendableValue);
+    }
+    return ToJsObject(env, sendableValue);
+}
 } // namespace AppDataMgrJsKit
 } // namespace OHOS
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/common/src/js_uv_queue.cpp b/relational_store/frameworks/js/napi/common/src/js_uv_queue.cpp
index 1f10fe48c085893bbd0fdf355cb569d8349eb100..36b6b9899dd676a5690a703e6f7608d3fd6e42b1 100644
--- a/relational_store/frameworks/js/napi/common/src/js_uv_queue.cpp
+++ b/relational_store/frameworks/js/napi/common/src/js_uv_queue.cpp
@@ -31,7 +31,7 @@ UvQueue::UvQueue(napi_env env) : env_(env)
 
 UvQueue::~UvQueue()
 {
-    LOG_DEBUG("no memory leak for queue-callback");
+    LOG_DEBUG("no memory leak for queue-callback.");
     env_ = nullptr;
     handler_ = nullptr;
 }
@@ -39,18 +39,18 @@ UvQueue::~UvQueue()
 void UvQueue::AsyncCall(UvCallback callback, Args args, Result result)
 {
     if (loop_ == nullptr || callback.IsNull()) {
-        LOG_ERROR("loop_ or callback is nullptr");
+        LOG_ERROR("loop_ or callback is nullptr.");
         return;
     }
     uv_work_t *work = new (std::nothrow) uv_work_t;
     if (work == nullptr) {
-        LOG_ERROR("no memory for uv_work_t");
+        LOG_ERROR("no memory for uv_work_t.");
         return;
     }
     auto entry = new (std::nothrow) UvEntry();
     if (entry == nullptr) {
         delete work;
-        LOG_ERROR("no memory for UvEntry");
+        LOG_ERROR("no memory for UvEntry.");
         return;
     }
     entry->env_ = env_;
@@ -75,12 +75,12 @@ void UvQueue::AsyncCallInOrder(UvCallback callback, Args args, Result result)
         AsyncCall(std::move(callback), std::move(args), std::move(result));
     }
     if (callback.IsNull()) {
-        LOG_ERROR("handler_ or callback is nullptr");
+        LOG_ERROR("handler_ or callback is nullptr.");
         return;
     }
     auto entry = std::make_shared<UvEntry>();
     if (entry == nullptr) {
-        LOG_ERROR("no memory for UvEntry");
+        LOG_ERROR("no memory for UvEntry.");
         return;
     }
     entry->env_ = env_;
@@ -95,18 +95,18 @@ void UvQueue::AsyncCallInOrder(UvCallback callback, Args args, Result result)
 void UvQueue::AsyncPromise(UvPromise promise, UvQueue::Args args)
 {
     if (loop_ == nullptr || promise.IsNull()) {
-        LOG_ERROR("loop_ or promise is nullptr");
+        LOG_ERROR("loop_ or promise is nullptr.");
         return;
     }
     uv_work_t *work = new (std::nothrow) uv_work_t;
     if (work == nullptr) {
-        LOG_ERROR("no memory for uv_work_t");
+        LOG_ERROR("no memory for uv_work_t.");
         return;
     }
     auto entry = new (std::nothrow) UvEntry();
     if (entry == nullptr) {
         delete work;
-        LOG_ERROR("no memory for UvEntry");
+        LOG_ERROR("no memory for UvEntry.");
         return;
     }
     entry->env_ = env_;
@@ -124,18 +124,18 @@ void UvQueue::AsyncPromise(UvPromise promise, UvQueue::Args args)
 void UvQueue::Execute(UvQueue::Task task)
 {
     if (loop_ == nullptr || !task) {
-        LOG_ERROR("loop_ or task is nullptr");
+        LOG_ERROR("loop_ or task is nullptr.");
         return;
     }
     uv_work_t *work = new (std::nothrow) uv_work_t;
     if (work == nullptr) {
-        LOG_ERROR("no memory for uv_work_t");
+        LOG_ERROR("no memory for uv_work_t.");
         return;
     }
     auto entry = new (std::nothrow) Task();
     if (entry == nullptr) {
         delete work;
-        LOG_ERROR("no memory for Task");
+        LOG_ERROR("no memory for Task.");
         return;
     }
     *entry = task;
@@ -210,11 +210,6 @@ void UvQueue::DoUvPromise(uv_work_t *work, int status)
     });
 
     Scope scope(entry->env_);
-    napi_value method = entry->GetCallback();
-    if (method == nullptr) {
-        LOG_ERROR("the callback is invalid, maybe is cleared!");
-        return;
-    }
     napi_value argv[ARG_BUTT] = { nullptr };
     auto argc = entry->GetArgv(argv, ARG_BUTT);
     if (argv[ARG_ERROR] != nullptr || argc != ARG_BUTT) {
diff --git a/relational_store/frameworks/js/napi/dataability/BUILD.gn b/relational_store/frameworks/js/napi/dataability/BUILD.gn
index a958a4013723d6be173a822d634f3297110d0664..7d79cc09cc1ce6735852fa37655fe99138cf614b 100644
--- a/relational_store/frameworks/js/napi/dataability/BUILD.gn
+++ b/relational_store/frameworks/js/napi/dataability/BUILD.gn
@@ -22,15 +22,6 @@ ohos_copy("relational_store_declaration") {
 }
 
 ohos_shared_library("dataability") {
-  branch_protector_ret = "pac_ret"
-  sanitize = {
-    boundary_sanitize = true
-    ubsan = true
-    cfi = true
-    cfi_cross_dso = true
-    debug = false
-  }
-
   include_dirs = [
     "include",
     "${relational_store_common_path}/include",
diff --git a/relational_store/frameworks/js/napi/dataability/src/napi_data_ability_predicates.cpp b/relational_store/frameworks/js/napi/dataability/src/napi_data_ability_predicates.cpp
index cb06cc59bb80913976bfe50ef1376f316415ea0b..ccebc3192880fce8de28ec8a770d4d8122fde5bc 100644
--- a/relational_store/frameworks/js/napi/dataability/src/napi_data_ability_predicates.cpp
+++ b/relational_store/frameworks/js/napi/dataability/src/napi_data_ability_predicates.cpp
@@ -95,7 +95,7 @@ napi_value DataAbilityPredicatesProxy::New(napi_env env, napi_callback_info info
     if (is_constructor) {
         auto *proxy = new (std::nothrow) DataAbilityPredicatesProxy();
         if (proxy == nullptr) {
-            LOG_ERROR("DataAbilityPredicatesProxy::New new failed, proxy is nullptr");
+            LOG_ERROR("DataAbilityPredicatesProxy::New new failed, proxy is nullptr.");
             return nullptr;
         }
         napi_status status = napi_wrap(env, thiz, proxy, DataAbilityPredicatesProxy::Destructor, nullptr, nullptr);
diff --git a/relational_store/frameworks/js/napi/rdb/BUILD.gn b/relational_store/frameworks/js/napi/rdb/BUILD.gn
index 12f822416c374ab1bc7b7a5f5ac5edd15c96182e..146a40616b193facf245d2a80ac8b18fb2b6bed8 100644
--- a/relational_store/frameworks/js/napi/rdb/BUILD.gn
+++ b/relational_store/frameworks/js/napi/rdb/BUILD.gn
@@ -63,18 +63,9 @@ ohos_shared_library("napi_rdb") {
       "//foundation/arkui/napi:ace_napi",
       "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb",
     ]
-  } else {
-    if (is_ohos) {
-      branch_protector_ret = "pac_ret"
-      sanitize = {
-        boundary_sanitize = true
-        ubsan = true
-        cfi = true
-        cfi_cross_dso = true
-        debug = false
-      }
-    }
 
+    external_deps = [ "bounds_checking_function:libsec_static" ]
+  } else {
     include_dirs = [
       "include",
       "${datashare_path}/common/include/",
@@ -99,6 +90,7 @@ ohos_shared_library("napi_rdb") {
       "ability_runtime:abilitykit_native",
       "ability_runtime:extensionkit_native",
       "ability_runtime:napi_base_context",
+      "bounds_checking_function:libsec_shared",
       "c_utils:utils",
       "common_event_service:cesfwk_innerkits",
       "hilog:libhilog",
@@ -144,17 +136,6 @@ ohos_shared_library("rdb") {
       "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb",
     ]
   } else {
-    if (is_ohos) {
-      branch_protector_ret = "pac_ret"
-      sanitize = {
-        boundary_sanitize = true
-        ubsan = true
-        cfi = true
-        cfi_cross_dso = true
-        debug = false
-      }
-    }
-
     include_dirs = [
       "include",
       "${datashare_path}/common/include/",
diff --git a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_predicates.cpp b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_predicates.cpp
index 4145a1e13a2a6f29335cdc464ad3b52ddcc82d05..2cea752904d360a36773fa164435b9876c519327 100644
--- a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_predicates.cpp
+++ b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_predicates.cpp
@@ -673,6 +673,9 @@ napi_value RdbPredicatesProxy::In(napi_env env, napi_callback_info info)
     auto predicatesProxy = ParseFieldAndValueArray(env, info, thiz, field, values, "ValueType");
     RDB_CHECK_RETURN_NULLPTR(predicatesProxy != nullptr && predicatesProxy->predicates_ != nullptr,
         "RdbPredicatesProxy predicatesProxy or predicates_ is nullptr");
+    if (values.empty()) {
+        return thiz;
+    }
     predicatesProxy->predicates_->In(field, values);
     return thiz;
 }
@@ -685,6 +688,9 @@ napi_value RdbPredicatesProxy::NotIn(napi_env env, napi_callback_info info)
     auto predicatesProxy = ParseFieldAndValueArray(env, info, thiz, field, values, "ValueType");
     RDB_CHECK_RETURN_NULLPTR(predicatesProxy != nullptr && predicatesProxy->predicates_ != nullptr,
         "RdbPredicatesProxy predicatesProxy or predicates_ is nullptr");
+    if (values.empty()) {
+        return thiz;
+    }
     predicatesProxy->predicates_->NotIn(field, values);
     return thiz;
 }
diff --git a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store.cpp b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store.cpp
index 937bf8c9fe8430951e7f104ac3e20efb0c574fd5..3595c3f371565cd2cf6faf13d29995353b77af56 100644
--- a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store.cpp
+++ b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store.cpp
@@ -101,7 +101,7 @@ RdbStoreProxy::RdbStoreProxy()
 
 RdbStoreProxy::~RdbStoreProxy()
 {
-    LOG_DEBUG("RdbStoreProxy destructor");
+    LOG_DEBUG("RdbStoreProxy destructor.");
 }
 
 void RdbStoreProxy::Init(napi_env env, napi_value exports)
@@ -234,7 +234,7 @@ int ParserThis(const napi_env &env, const napi_value &self, std::shared_ptr<RdbS
     RDB_CHECK_RETURN_CALL_RESULT(obj, context->SetError(paramError));
     context->apiversion = obj->apiversion;
     context->boundObj = obj;
-    LOG_DEBUG("ParserThis RdbStoreProxy is v%{public}d", obj->apiversion);
+    LOG_DEBUG("ParserThis RdbStoreProxy is v%{public}d.", obj->apiversion);
     return OK;
 }
 
@@ -244,7 +244,7 @@ int ParseTableName(const napi_env env, const napi_value arg, std::shared_ptr<Rdb
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("table", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->tableName.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseTableName end");
+    LOG_DEBUG("ParseTableName end.");
     return OK;
 }
 
@@ -254,7 +254,7 @@ int ParseDevice(const napi_env env, const napi_value arg, std::shared_ptr<RdbSto
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("device", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->device.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseDevice end");
+    LOG_DEBUG("ParseDevice end.");
     return OK;
 }
 
@@ -275,7 +275,7 @@ int ParseTablesName(const napi_env env, const napi_value arg, std::shared_ptr<Rd
             context->tablesName.push_back(table);
         }
     }
-    LOG_DEBUG("ParseTablesName end");
+    LOG_DEBUG("ParseTablesName end.");
     return OK;
 }
 
@@ -285,13 +285,13 @@ int ParseSyncModeArg(const napi_env env, const napi_value arg, std::shared_ptr<R
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("mode", "a SyncMode.");
     RDB_CHECK_RETURN_CALL_RESULT(context->enumArg == 0 || context->enumArg == 1, context->SetError(paramError));
 
-    LOG_DEBUG("ParseSyncModeArg end");
+    LOG_DEBUG("ParseSyncModeArg end.");
     return OK;
 }
 
 bool CheckGlobalProperty(const napi_env env, const napi_value arg, const std::string &propertyName)
 {
-    LOG_DEBUG("CheckGlobalProperty start: %{public}s", propertyName.c_str());
+    LOG_DEBUG("CheckGlobalProperty start: %{public}s.", propertyName.c_str());
     napi_value global = nullptr;
     napi_status status = napi_get_global(env, &global);
     if (status != napi_ok) {
@@ -309,17 +309,17 @@ bool CheckGlobalProperty(const napi_env env, const napi_value arg, const std::st
 
 int ParsePredicates(const napi_env env, const napi_value arg, std::shared_ptr<RdbStoreContext> context)
 {
-    LOG_DEBUG("ParsePredicates start");
+    LOG_DEBUG("ParsePredicates start.");
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("predicates", "an RdbPredicates.");
     if (CheckGlobalProperty(env, arg, "RdbPredicatesConstructor")
         || CheckGlobalProperty(env, arg, "RdbPredicatesConstructorV9")) {
-        LOG_DEBUG("Parse RDB Predicates");
+        LOG_DEBUG("Parse RDB Predicates.");
         napi_unwrap(env, arg, reinterpret_cast<void **>(&context->predicatesProxy));
         RDB_CHECK_RETURN_CALL_RESULT(context->predicatesProxy != nullptr &&
             context->predicatesProxy->GetPredicates() != nullptr, context->SetError(paramError));
         context->tableName = context->predicatesProxy->GetPredicates()->GetTableName();
         context->rdbPredicates = context->predicatesProxy->GetPredicates();
-        LOG_DEBUG("ParsePredicates end");
+        LOG_DEBUG("ParsePredicates end.");
         return OK;
     }
 
@@ -331,15 +331,15 @@ int ParsePredicates(const napi_env env, const napi_value arg, std::shared_ptr<Rd
     // proxy is nullptr, it isn't rdb predicates or datashare predicates
     RDB_CHECK_RETURN_CALL_RESULT(proxy != nullptr, context->SetError(paramError));
     // proxy is not nullptr, it's a datashare predicates.
-    LOG_DEBUG("Parse DataShare Predicates");
+    LOG_DEBUG("Parse DataShare Predicates.");
     paramError = std::make_shared<ParamTypeError>("predicates", "an DataShare Predicates.");
-    LOG_ERROR("dsPredicates is null ? %{public}d", (proxy->predicates_ == nullptr));
+    LOG_ERROR("dsPredicates is null ? %{public}d.", (proxy->predicates_ == nullptr));
     RDB_CHECK_RETURN_CALL_RESULT(proxy->predicates_ != nullptr, context->SetError(paramError));
     std::shared_ptr<DataShareAbsPredicates> dsPredicates = proxy->predicates_;
     context->rdbPredicates = std::make_shared<RdbPredicates>(
         RdbDataShareAdapter::RdbUtils::ToPredicates(*dsPredicates, context->tableName));
 #endif
-    LOG_DEBUG("ParsePredicates end");
+    LOG_DEBUG("ParsePredicates end.");
     return OK;
 }
 
@@ -349,7 +349,7 @@ int ParseSrcName(const napi_env env, const napi_value arg, std::shared_ptr<RdbSt
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("srcName", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->srcName.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseSrcName end");
+    LOG_DEBUG("ParseSrcName end.");
     return OK;
 }
 
@@ -372,7 +372,7 @@ int ParseWhereClause(const napi_env env, const napi_value arg, std::shared_ptr<R
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("whereClause", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->whereClause.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseWhereClause end");
+    LOG_DEBUG("ParseWhereClause end.");
     return OK;
 }
 
@@ -382,7 +382,7 @@ int ParseAlias(const napi_env env, const napi_value arg, std::shared_ptr<RdbStor
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("aliasName", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->aliasName.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseAlias end");
+    LOG_DEBUG("ParseAlias end.");
     return OK;
 }
 
@@ -392,7 +392,7 @@ int ParsePath(const napi_env env, const napi_value arg, std::shared_ptr<RdbStore
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("pathName", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->pathName.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParsePath end");
+    LOG_DEBUG("ParsePath end.");
     return OK;
 }
 
@@ -428,7 +428,7 @@ int ParseSql(const napi_env env, const napi_value arg, std::shared_ptr<RdbStoreC
     std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("sql", "a non empty string.");
     RDB_CHECK_RETURN_CALL_RESULT(!context->sql.empty(), context->SetError(paramError));
 
-    LOG_DEBUG("ParseSql end");
+    LOG_DEBUG("ParseSql end.");
     return OK;
 }
 
@@ -447,7 +447,7 @@ int ParseValuesBucket(const napi_env env, const napi_value arg, std::shared_ptr<
         napi_value key = nullptr;
         status = napi_get_element(env, keys, i, &key);
         if (status != napi_ok) {
-            LOG_DEBUG("ValuesBucket get_element errr");
+            LOG_DEBUG("ValuesBucket get_element errr.");
         }
         RDB_CHECK_RETURN_CALL_RESULT(status == napi_ok, context->SetError(paramError));
 
@@ -457,6 +457,13 @@ int ParseValuesBucket(const napi_env env, const napi_value arg, std::shared_ptr<
 
         ValueObject valueObject;
         int32_t ret = JSUtils::Convert2Value(env, value, valueObject.value);
+        if (ret == napi_ok && valueObject.GetType() == ValueObject::TYPE_BLOB) {
+            std::vector<uint8_t> tmpValue;
+            valueObject.GetBlob(tmpValue);
+            if (tmpValue.empty()) {
+                valueObject = ValueObject();
+            }
+        }
         if (ret == napi_ok) {
             context->valuesBucket.Put(keyStr, std::move(valueObject));
         } else if (ret != napi_generic_failure) {
@@ -465,7 +472,7 @@ int ParseValuesBucket(const napi_env env, const napi_value arg, std::shared_ptr<
             RDB_CHECK_RETURN_CALL_RESULT(false, context->SetError(paramError));
         }
     }
-    LOG_DEBUG("ParseValuesBucket end");
+    LOG_DEBUG("ParseValuesBucket end.");
     return OK;
 }
 
@@ -514,7 +521,7 @@ bool IsNapiString(napi_env env, napi_callback_info info)
 napi_value RdbStoreProxy::Insert(napi_env env, napi_callback_info info)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbStoreProxy::Insert start");
+    LOG_DEBUG("RdbStoreProxy::Insert start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("2 or 3");
@@ -527,16 +534,16 @@ napi_value RdbStoreProxy::Insert(napi_env env, napi_callback_info info)
     auto exec = [context]() {
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         int64_t rowId = 0;
-        LOG_DEBUG("RdbStoreProxy::Insert Async");
+        LOG_DEBUG("RdbStoreProxy::Insert Async.");
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->Insert(rowId, context->tableName, context->valuesBucket);
         context->rowId = rowId;
-        LOG_DEBUG("RdbStoreProxy::Insert errCode is: %{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Insert errCode is: %{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->rowId, &result);
-        LOG_DEBUG("RdbStoreProxy::Insert end");
+        LOG_DEBUG("RdbStoreProxy::Insert end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -572,7 +579,7 @@ napi_value RdbStoreProxy::BatchInsert(napi_env env, napi_callback_info info)
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->insertNum, &result);
-        LOG_DEBUG("RdbStoreProxy::BatchInsert end. tableName is: %{public}s",
+        LOG_DEBUG("RdbStoreProxy::BatchInsert end. tableName is: %{public}s.",
             context->tableName.c_str());
         return (status == napi_ok) ? OK : ERR;
     };
@@ -584,7 +591,7 @@ napi_value RdbStoreProxy::BatchInsert(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::Delete(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Delete start");
+    LOG_DEBUG("RdbStoreProxy::Delete start.");
     auto context = std::make_shared<RdbStoreContext>();
     context->isNapiString = IsNapiString(env, info);
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
@@ -602,18 +609,18 @@ napi_value RdbStoreProxy::Delete(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Delete Async");
+        LOG_DEBUG("RdbStoreProxy::Delete Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         int deletedRows = 0;
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->Delete(deletedRows, *(context->rdbPredicates));
         context->rowId = deletedRows;
-        LOG_DEBUG("RdbStoreProxy::Delete errCode is: %{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Delete errCode is: %{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->rowId, &result);
-        LOG_DEBUG("RdbStoreProxy::Delete end");
+        LOG_DEBUG("RdbStoreProxy::Delete end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -625,7 +632,7 @@ napi_value RdbStoreProxy::Delete(napi_env env, napi_callback_info info)
 napi_value RdbStoreProxy::Update(napi_env env, napi_callback_info info)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbStoreProxy::Update start");
+    LOG_DEBUG("RdbStoreProxy::Update start.");
     auto context = std::make_shared<RdbStoreContext>();
     context->isNapiString = IsNapiString(env, info);
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
@@ -645,18 +652,18 @@ napi_value RdbStoreProxy::Update(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Update Async");
+        LOG_DEBUG("RdbStoreProxy::Update Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         int changedRows = 0;
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->Update(changedRows, context->valuesBucket, *(context->rdbPredicates));
         context->rowId = changedRows;
-        LOG_DEBUG("RdbStoreProxy::Update errCode is: %{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Update errCode is: %{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->rowId, &result);
-        LOG_DEBUG("RdbStoreProxy::Update end");
+        LOG_DEBUG("RdbStoreProxy::Update end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -694,7 +701,7 @@ napi_value RdbStoreProxy::Query(napi_env env, napi_callback_info info)
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         context->resultSet = obj->rdbStore_->Query(*(context->rdbPredicates), context->columns);
-        LOG_DEBUG("RdbStoreProxy::Query result is nullptr ? %{public}d", (context->resultSet == nullptr));
+        LOG_DEBUG("RdbStoreProxy::Query result is nullptr ? %{public}d.", (context->resultSet == nullptr));
         return (context->resultSet != nullptr) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
@@ -769,6 +776,13 @@ int ParseBindArgs(const napi_env env, const napi_value arg, std::shared_ptr<RdbS
         int32_t ret = JSUtils::Convert2Value(env, element, valueObject.value);
         std::shared_ptr<Error> paramError = std::make_shared<ParamTypeError>("tables", "a string array.");
         RDB_CHECK_RETURN_CALL_RESULT(ret == napi_ok, context->SetError(paramError));
+        if (valueObject.GetType() == ValueObject::TYPE_BLOB) {
+            std::vector<uint8_t> tmpValue;
+            valueObject.GetBlob(tmpValue);
+            if (tmpValue.empty()) {
+                valueObject = ValueObject();
+            }
+        }
         context->bindArgs.push_back(valueObject);
     }
     return OK;
@@ -776,7 +790,7 @@ int ParseBindArgs(const napi_env env, const napi_value arg, std::shared_ptr<RdbS
 
 napi_value RdbStoreProxy::ExecuteSql(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::ExecuteSql start");
+    LOG_DEBUG("RdbStoreProxy::ExecuteSql start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("1, 2 or 3");
@@ -789,16 +803,16 @@ napi_value RdbStoreProxy::ExecuteSql(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::ExecuteSql Async");
+        LOG_DEBUG("RdbStoreProxy::ExecuteSql Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->ExecuteSql(context->sql, context->bindArgs);
-        LOG_DEBUG("RdbStoreProxy::ExecuteSql errCode is: %{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::ExecuteSql errCode is: %{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_get_undefined(env, &result);
-        LOG_DEBUG("RdbStoreProxy::ExecuteSql end");
+        LOG_DEBUG("RdbStoreProxy::ExecuteSql end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -809,7 +823,7 @@ napi_value RdbStoreProxy::ExecuteSql(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::Count(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Count start");
+    LOG_DEBUG("RdbStoreProxy::Count start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("1 or 2");
@@ -819,7 +833,7 @@ napi_value RdbStoreProxy::Count(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Count Async");
+        LOG_DEBUG("RdbStoreProxy::Count Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         std::int64_t temp = 0;
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
@@ -827,12 +841,12 @@ napi_value RdbStoreProxy::Count(napi_env env, napi_callback_info info)
             context->predicatesProxy->GetPredicates() != nullptr);
         int errCode = obj->rdbStore_->Count(temp, *(context->predicatesProxy->GetPredicates()));
         context->rowId = temp;
-        LOG_DEBUG("RdbStoreProxy::Count errCode is: %{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Count errCode is: %{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->rowId, &result);
-        LOG_DEBUG("RdbStoreProxy::Count end");
+        LOG_DEBUG("RdbStoreProxy::Count end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -844,7 +858,7 @@ napi_value RdbStoreProxy::Count(napi_env env, napi_callback_info info)
 napi_value RdbStoreProxy::Replace(napi_env env, napi_callback_info info)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbStoreProxy::Replace start");
+    LOG_DEBUG("RdbStoreProxy::Replace start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("2 or 3");
@@ -855,18 +869,18 @@ napi_value RdbStoreProxy::Replace(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Replace Async");
+        LOG_DEBUG("RdbStoreProxy::Replace Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         int64_t rowId = 0;
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->Replace(rowId, context->tableName, context->valuesBucket);
         context->rowId = rowId;
-        LOG_DEBUG("RdbStoreProxy::Replace errCode is:%{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Replace errCode is:%{public}d.", errCode);
         return (errCode == E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, context->rowId, &result);
-        LOG_DEBUG("RdbStoreProxy::Replace end");
+        LOG_DEBUG("RdbStoreProxy::Replace end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -877,7 +891,7 @@ napi_value RdbStoreProxy::Replace(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::Attach(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Attach start");
+    LOG_DEBUG("RdbStoreProxy::Attach start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("3 or 4");
@@ -888,16 +902,16 @@ napi_value RdbStoreProxy::Attach(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Attach Async");
+        LOG_DEBUG("RdbStoreProxy::Attach Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         CHECK_RETURN_ERR(obj != nullptr && obj->rdbStore_ != nullptr);
         int errCode = obj->rdbStore_->Attach(context->aliasName, context->pathName, context->newKey);
-        LOG_ERROR("RdbStoreProxy::Attach errCode is:%{public}d ", errCode);
+        LOG_ERROR("RdbStoreProxy::Attach errCode is:%{public}d.", errCode);
         return (errCode != E_OK) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_get_undefined(env, &result);
-        LOG_DEBUG("RdbStoreProxy::Attach end");
+        LOG_DEBUG("RdbStoreProxy::Attach end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -914,7 +928,7 @@ napi_value RdbStoreProxy::IsHoldingConnection(napi_env env, napi_callback_info i
     NAPI_ASSERT(env, rdbStoreProxy != nullptr &&
         rdbStoreProxy->rdbStore_ != nullptr, "RdbStoreProxy or rdbStore_ is nullptr");
     bool out = rdbStoreProxy->rdbStore_->IsHoldingConnection();
-    LOG_DEBUG("RdbStoreProxy::IsHoldingConnection out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::IsHoldingConnection out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, out);
 }
 
@@ -926,7 +940,7 @@ napi_value RdbStoreProxy::IsReadOnly(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, rdbStoreProxy != nullptr
         && rdbStoreProxy->rdbStore_ != nullptr, "RdbStoreProxy or rdbStore_ is nullptr");
     bool out = rdbStoreProxy->rdbStore_->IsReadOnly();
-    LOG_DEBUG("RdbStoreProxy::IsReadOnly out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::IsReadOnly out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, out);
 }
 
@@ -938,7 +952,7 @@ napi_value RdbStoreProxy::IsMemoryRdb(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, rdbStoreProxy != nullptr
         && rdbStoreProxy->rdbStore_ != nullptr, "RdbStoreProxy or rdbStore_ is nullptr");
     bool out = rdbStoreProxy->rdbStore_->IsMemoryRdb();
-    LOG_DEBUG("RdbStoreProxy::IsMemoryRdb out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::IsMemoryRdb out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, out);
 }
 
@@ -950,7 +964,7 @@ napi_value RdbStoreProxy::GetPath(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, rdbStoreProxy != nullptr
         && rdbStoreProxy->rdbStore_ != nullptr, "RdbStoreProxy or rdbStore_ is nullptr");
     std::string path = rdbStoreProxy->rdbStore_->GetPath();
-    LOG_DEBUG("RdbStoreProxy::GetPath path is empty ? %{public}d", path.empty());
+    LOG_DEBUG("RdbStoreProxy::GetPath path is empty ? %{public}d.", path.empty());
     return JSUtils::Convert2JSValue(env, path);
 }
 
@@ -963,7 +977,7 @@ napi_value RdbStoreProxy::BeginTransaction(napi_env env, napi_callback_info info
         && rdbStoreProxy->rdbStore_ != nullptr, "RdbStoreProxy or rdbStore_ is nullptr");
     int errCode = rdbStoreProxy->rdbStore_->BeginTransaction();
     NAPI_ASSERT(env, errCode == E_OK, "call BeginTransaction failed");
-    LOG_DEBUG("RdbStoreProxy::BeginTransaction end, errCode is:%{public}d", errCode);
+    LOG_DEBUG("RdbStoreProxy::BeginTransaction end, errCode is:%{public}d.", errCode);
     return nullptr;
 }
 
@@ -975,7 +989,7 @@ napi_value RdbStoreProxy::RollBack(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, rdbStoreProxy != nullptr, "RdbStoreProxy is nullptr");
     int errCode = rdbStoreProxy->rdbStore_->RollBack();
     NAPI_ASSERT(env, errCode == E_OK, "call RollBack failed");
-    LOG_DEBUG("RdbStoreProxy::RollBack end, errCode is:%{public}d", errCode);
+    LOG_DEBUG("RdbStoreProxy::RollBack end, errCode is:%{public}d.", errCode);
     return nullptr;
 }
 
@@ -987,14 +1001,14 @@ napi_value RdbStoreProxy::Commit(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, rdbStoreProxy != nullptr, "RdbStoreProxy is nullptr");
     int errCode = rdbStoreProxy->rdbStore_->Commit();
     NAPI_ASSERT(env, errCode == E_OK, "call Commit failed");
-    LOG_DEBUG("RdbStoreProxy::Commit end, errCode is:%{public}d", errCode);
+    LOG_DEBUG("RdbStoreProxy::Commit end, errCode is:%{public}d.", errCode);
     return nullptr;
 }
 
 napi_value RdbStoreProxy::QueryByStep(napi_env env, napi_callback_info info)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbStoreProxy::QueryByStep start");
+    LOG_DEBUG("RdbStoreProxy::QueryByStep start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("2 or 3");
@@ -1005,20 +1019,20 @@ napi_value RdbStoreProxy::QueryByStep(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::QueryByStep Async");
+        LOG_DEBUG("RdbStoreProxy::QueryByStep Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         if (obj == nullptr || obj->rdbStore_ == nullptr) {
             return ERR;
         }
         context->stepResultSet = obj->rdbStore_->QueryByStep(context->sql, context->columns);
-        LOG_ERROR("RdbStoreProxy::QueryByStep is nullptr ? %{public}d ", context->stepResultSet == nullptr);
+        LOG_ERROR("RdbStoreProxy::QueryByStep is nullptr ? %{public}d.", context->stepResultSet == nullptr);
         return (context->stepResultSet != nullptr) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         if (context->stepResultSet != nullptr) {
             result = ResultSetProxy::NewInstance(env, context->stepResultSet, context->apiversion);
         }
-        LOG_DEBUG("RdbStoreProxy::QueryByStep end");
+        LOG_DEBUG("RdbStoreProxy::QueryByStep end.");
         return (result != nullptr) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -1034,7 +1048,7 @@ napi_value RdbStoreProxy::IsInTransaction(napi_env env, napi_callback_info info)
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
     NAPI_ASSERT(env, rdbStoreProxy != nullptr, "RdbStoreProxy is nullptr");
     bool out = rdbStoreProxy->rdbStore_->IsInTransaction();
-    LOG_DEBUG("RdbStoreProxy::IsInTransaction out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::IsInTransaction out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, out);
 }
 
@@ -1045,7 +1059,7 @@ napi_value RdbStoreProxy::IsOpen(napi_env env, napi_callback_info info)
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
     NAPI_ASSERT(env, (rdbStoreProxy != nullptr) && (rdbStoreProxy->rdbStore_ != nullptr), "RdbStoreProxy is nullptr");
     bool out = rdbStoreProxy->rdbStore_->IsOpen();
-    LOG_DEBUG("RdbStoreProxy::IsOpen out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::IsOpen out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, out);
 }
 
@@ -1057,7 +1071,7 @@ napi_value RdbStoreProxy::GetVersion(napi_env env, napi_callback_info info)
     NAPI_ASSERT(env, (rdbStoreProxy != nullptr) && (rdbStoreProxy->rdbStore_ != nullptr), "RdbStoreProxy is nullptr");
     int32_t version = 0;
     int out = rdbStoreProxy->rdbStore_->GetVersion(version);
-    LOG_DEBUG("RdbStoreProxy::GetVersion out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::GetVersion out is : %{public}d.", out);
     return JSUtils::Convert2JSValue(env, version);
 }
 
@@ -1073,14 +1087,14 @@ napi_value RdbStoreProxy::SetVersion(napi_env env, napi_callback_info info)
     int32_t version = 0;
     napi_get_value_int32(env, args[0], &version);
     int out = rdbStoreProxy->rdbStore_->SetVersion(version);
-    LOG_DEBUG("RdbStoreProxy::SetVersion out is : %{public}d", out);
+    LOG_DEBUG("RdbStoreProxy::SetVersion out is : %{public}d.", out);
     return nullptr;
 }
 
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM)
 napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::SetDistributedTables start");
+    LOG_DEBUG("RdbStoreProxy::SetDistributedTables start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("1 or 2");
@@ -1090,18 +1104,18 @@ napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::SetDistributedTables Async");
+        LOG_DEBUG("RdbStoreProxy::SetDistributedTables Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         if (obj == nullptr || obj->rdbStore_.get() == nullptr) {
             return ERR;
         }
         int res = obj->rdbStore_->SetDistributedTables(context->tablesName);
-        LOG_DEBUG("RdbStoreProxy::SetDistributedTables res is : %{public}d", res);
+        LOG_DEBUG("RdbStoreProxy::SetDistributedTables res is : %{public}d.", res);
         return (res == E_OK || res == E_NOT_SUPPORT) ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_get_undefined(env, &result);
-        LOG_DEBUG("RdbStoreProxy::SetDistributedTables end");
+        LOG_DEBUG("RdbStoreProxy::SetDistributedTables end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -1112,7 +1126,7 @@ napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info
 
 napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName start");
+    LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("2 or 3");
@@ -1123,7 +1137,7 @@ napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName Async");
+        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName Async.");
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         int errCode = E_ERROR;
         if (obj == nullptr || obj->rdbStore_.get() == nullptr) {
@@ -1138,7 +1152,7 @@ napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status =
             napi_create_string_utf8(env, context->tableName.c_str(), context->tableName.length(), &result);
-        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName end");
+        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -1149,7 +1163,7 @@ napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback
 
 napi_value RdbStoreProxy::Sync(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Sync start");
+    LOG_DEBUG("RdbStoreProxy::Sync start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
         std::shared_ptr<Error> paramNumError = std::make_shared<ParamNumError>("2 or 3");
@@ -1160,7 +1174,7 @@ napi_value RdbStoreProxy::Sync(napi_env env, napi_callback_info info)
         return OK;
     };
     auto exec = [context]() {
-        LOG_DEBUG("RdbStoreProxy::Sync Async");
+        LOG_DEBUG("RdbStoreProxy::Sync Async.");
         auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         SyncOption option;
         option.mode = static_cast<DistributedRdb::SyncMode>(context->enumArg);
@@ -1170,12 +1184,12 @@ napi_value RdbStoreProxy::Sync(napi_env env, napi_callback_info info)
         }
         int res = obj->rdbStore_->Sync(option, *context->predicatesProxy->GetPredicates(),
             [context](const SyncResult &result) { context->syncResult = result; });
-        LOG_INFO("RdbStoreProxy::Sync res is : %{public}d", res);
+        LOG_INFO("RdbStoreProxy::Sync res is : %{public}d.", res);
         return res == E_OK ? OK : ERR;
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         result = JSUtils::Convert2JSValue(env, context->syncResult);
-        LOG_DEBUG("RdbStoreProxy::Sync end");
+        LOG_DEBUG("RdbStoreProxy::Sync end.");
         return (result != nullptr) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -1189,27 +1203,27 @@ void RdbStoreProxy::OnDataChangeEvent(napi_env env, size_t argc, napi_value *arg
     napi_valuetype type = napi_undefined;
     napi_typeof(env, argv[0], &type);
     if (type != napi_number) {
-        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: first argument is not number");
+        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: first argument is not number.");
         return;
     }
     int32_t mode = SubscribeMode::SUBSCRIBE_MODE_MAX;
     napi_get_value_int32(env, argv[0], &mode);
     if (mode < 0 || mode >= SubscribeMode::SUBSCRIBE_MODE_MAX) {
-        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: first argument value is invalid");
+        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: first argument value is invalid.");
         return;
     }
-    LOG_INFO("RdbStoreProxy::OnDataChangeEvent: mode=%{public}d", mode);
+    LOG_INFO("RdbStoreProxy::OnDataChangeEvent: mode=%{public}d.", mode);
 
     napi_typeof(env, argv[1], &type);
     if (type != napi_function) {
-        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: second argument is not function");
+        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: second argument is not function.");
         return;
     }
 
     std::lock_guard<std::mutex> lockGuard(mutex_);
     for (const auto &observer : observers_[mode]) {
         if (observer != nullptr && *observer == argv[1]) {
-            LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: duplicate subscribe");
+            LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: duplicate subscribe.");
             return;
         }
     }
@@ -1218,11 +1232,11 @@ void RdbStoreProxy::OnDataChangeEvent(napi_env env, size_t argc, napi_value *arg
     auto observer = std::make_shared<NapiRdbStoreObserver>(env, argv[1]);
     int errCode = rdbStore_->Subscribe(option, observer.get());
     if (errCode != E_OK) {
-        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: subscribe failed");
+        LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: subscribe failed.");
         return;
     }
     observers_[mode].push_back(observer);
-    LOG_INFO("RdbStoreProxy::OnDataChangeEvent: subscribe success, mode is: %{public}d", mode);
+    LOG_INFO("RdbStoreProxy::OnDataChangeEvent: subscribe success, mode is: %{public}d.", mode);
 }
 
 void RdbStoreProxy::OffDataChangeEvent(napi_env env, size_t argc, napi_value *argv)
@@ -1230,20 +1244,20 @@ void RdbStoreProxy::OffDataChangeEvent(napi_env env, size_t argc, napi_value *ar
     napi_valuetype type = napi_undefined;
     napi_typeof(env, argv[0], &type);
     if (type != napi_number) {
-        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: first argument is not number");
+        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: first argument is not number.");
         return;
     }
     int32_t mode = SubscribeMode::SUBSCRIBE_MODE_MAX;
     napi_get_value_int32(env, argv[0], &mode);
     if (mode < 0 || mode >= SubscribeMode::SUBSCRIBE_MODE_MAX) {
-        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: first argument value is invalid");
+        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: first argument value is invalid.");
         return;
     }
-    LOG_INFO("RdbStoreProxy::OffDataChangeEvent: mode=%{public}d", mode);
+    LOG_INFO("RdbStoreProxy::OffDataChangeEvent: mode=%{public}d.", mode);
 
     napi_typeof(env, argv[1], &type);
     if (type != napi_function) {
-        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: second argument is not function");
+        LOG_ERROR("RdbStoreProxy::OffDataChangeEvent: second argument is not function.");
         return;
     }
 
@@ -1253,16 +1267,16 @@ void RdbStoreProxy::OffDataChangeEvent(napi_env env, size_t argc, napi_value *ar
     for (auto it = observers_[mode].begin(); it != observers_[mode].end(); it++) {
         if (*it != nullptr && **it == argv[1]) {
             if (rdbStore_.get() == nullptr) {
-                LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: rdbStore_ invalid");
+                LOG_ERROR("RdbStoreProxy::OnDataChangeEvent: rdbStore_ invalid.");
                 return;
             }
             rdbStore_->UnSubscribe(option, it->get());
             observers_[mode].erase(it);
-            LOG_INFO("RdbStoreProxy::OffDataChangeEvent: unsubscribe success");
+            LOG_INFO("RdbStoreProxy::OffDataChangeEvent: unsubscribe success.");
             return;
         }
     }
-    LOG_INFO("RdbStoreProxy::OffDataChangeEvent: not found");
+    LOG_INFO("RdbStoreProxy::OffDataChangeEvent: not found.");
 }
 
 napi_value RdbStoreProxy::OnEvent(napi_env env, napi_callback_info info)
@@ -1271,7 +1285,7 @@ napi_value RdbStoreProxy::OnEvent(napi_env env, napi_callback_info info)
     napi_value argv[MAX_ON_EVENT_ARG_NUM]{};
     napi_value self = nullptr;
     if (napi_get_cb_info(env, info, &argc, argv, &self, nullptr) != napi_ok) {
-        LOG_ERROR("RdbStoreProxy::OnEvent: get args failed");
+        LOG_ERROR("RdbStoreProxy::OnEvent: get args failed.");
         return nullptr;
     }
     bool invalid_condition = argc < MIN_ON_EVENT_ARG_NUM || argc > MAX_ON_EVENT_ARG_NUM || self == nullptr;
@@ -1285,7 +1299,7 @@ napi_value RdbStoreProxy::OnEvent(napi_env env, napi_callback_info info)
         proxy->OnDataChangeEvent(env, argc - 1, argv + 1);
     }
 
-    LOG_INFO("RdbStoreProxy::OnEvent end");
+    LOG_INFO("RdbStoreProxy::OnEvent end.");
     return nullptr;
 }
 
@@ -1295,7 +1309,7 @@ napi_value RdbStoreProxy::OffEvent(napi_env env, napi_callback_info info)
     napi_value argv[MAX_ON_EVENT_ARG_NUM]{};
     napi_value self = nullptr;
     if (napi_get_cb_info(env, info, &argc, argv, &self, nullptr) != napi_ok) {
-        LOG_ERROR("RdbStoreProxy::OffEvent: get args failed");
+        LOG_ERROR("RdbStoreProxy::OffEvent: get args failed.");
         return nullptr;
     }
     bool invalid_condition = argc < MIN_ON_EVENT_ARG_NUM || argc > MAX_ON_EVENT_ARG_NUM || self == nullptr;
@@ -1309,7 +1323,7 @@ napi_value RdbStoreProxy::OffEvent(napi_env env, napi_callback_info info)
         proxy->OffDataChangeEvent(env, argc - 1, argv + 1);
     }
 
-    LOG_INFO("RdbStoreProxy::OffEvent end");
+    LOG_INFO("RdbStoreProxy::OffEvent end.");
     return nullptr;
 }
 #endif
diff --git a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_helper.cpp b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_helper.cpp
index 38627a32571c7a376d0ccbdca7a1f2f24930d1e2..71a54cd7cb4fc4f3121059f6e25e1d6e89009635 100644
--- a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_helper.cpp
+++ b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_helper.cpp
@@ -103,7 +103,7 @@ public:
 
     int OnCreate(OHOS::NativeRdb::RdbStore &rdbStore) override
     {
-        LOG_DEBUG("OnCreate Callback");
+        LOG_DEBUG("OnCreate Callback.");
         callbacks_.emplace_back([this]() -> int {
             napi_value self = nullptr;
             napi_status status = napi_get_reference_value(env_, ref_, &self);
@@ -130,7 +130,7 @@ public:
 
     int OnUpgrade(OHOS::NativeRdb::RdbStore &rdbStore, int oldVersion, int newVersion) override
     {
-        LOG_DEBUG("OnUpgrade Callback");
+        LOG_DEBUG("OnUpgrade Callback.");
         callbacks_.emplace_back([this, oldVersion, newVersion]() -> int {
             napi_value self = nullptr;
             napi_status status = napi_get_reference_value(env_, ref_, &self);
@@ -165,7 +165,7 @@ public:
 
     int OnDowngrade(OHOS::NativeRdb::RdbStore &rdbStore, int oldVersion, int newVersion) override
     {
-        LOG_DEBUG("OnDowngrade Callback");
+        LOG_DEBUG("OnDowngrade Callback.");
         callbacks_.emplace_back([this, oldVersion, newVersion]() -> int {
             napi_value self = nullptr;
             napi_status status = napi_get_reference_value(env_, ref_, &self);
@@ -200,7 +200,7 @@ public:
 
     int OnOpen(OHOS::NativeRdb::RdbStore &rdbStore) override
     {
-        LOG_DEBUG("OnOpen Callback");
+        LOG_DEBUG("OnOpen Callback.");
         callbacks_.emplace_back([this]() -> int {
             napi_value self = nullptr;
             napi_status status = napi_get_reference_value(env_, ref_, &self);
@@ -358,7 +358,7 @@ int ParseSecurityLevel(const napi_env &env, const napi_value &object, std::share
     }
     context->config.SetSecurityLevel(sl);
 
-    LOG_DEBUG("ParseSecurityLevel end");
+    LOG_DEBUG("ParseSecurityLevel end.");
     return OK;
 }
 
@@ -427,7 +427,7 @@ napi_value InnerGetRdbStore(napi_env env, napi_callback_info info, std::shared_p
     ParseStoreConfigFunction parseStoreConfig)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbJsKit::GetRdbStore start");
+    LOG_DEBUG("RdbJsKit::GetRdbStore start.");
     context->iscontext = JSAbility::CheckContext(env, info);
     // context: Context, config: StoreConfig, version: number
     auto input = [context, parseStoreConfig](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
@@ -447,7 +447,7 @@ napi_value InnerGetRdbStore(napi_env env, napi_callback_info info, std::shared_p
         return OK;
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbJsKit::GetRdbStore Async");
+        LOG_DEBUG("RdbJsKit::GetRdbStore Async.");
         int errCode = OK;
         DefaultOpenCallback callback;
         context->proxy = RdbHelper::GetRdbStore(context->config, context->version, callback, errCode);
@@ -458,7 +458,7 @@ napi_value InnerGetRdbStore(napi_env env, napi_callback_info info, std::shared_p
     auto output = [context](napi_env env, napi_value &result) -> int {
         result = RdbStoreProxy::NewInstance(env, context->proxy, context->apiversion);
         context->openCallback.DelayNotify();
-        LOG_DEBUG("RdbJsKit::GetRdbStore end");
+        LOG_DEBUG("RdbJsKit::GetRdbStore end.");
         return (result != nullptr) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
@@ -487,7 +487,7 @@ napi_value GetRdbStoreV9(napi_env env, napi_callback_info info)
 napi_value InnerDeleteRdbStore(napi_env env, napi_callback_info info, std::shared_ptr<HelperRdbContext> context)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
-    LOG_DEBUG("RdbJsKit::DeleteRdbStore start");
+    LOG_DEBUG("RdbJsKit::DeleteRdbStore start.");
     context->iscontext = JSAbility::CheckContext(env, info);
     // context: Context, config: StoreConfig, version: number
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> int {
@@ -512,7 +512,7 @@ napi_value InnerDeleteRdbStore(napi_env env, napi_callback_info info, std::share
     };
     auto output = [context](napi_env env, napi_value &result) -> int {
         napi_status status = napi_create_int64(env, OK, &result);
-        LOG_DEBUG("RdbJsKit::DeleteRdbStore end");
+        LOG_DEBUG("RdbJsKit::DeleteRdbStore end.");
         return (status == napi_ok) ? OK : ERR;
     };
     context->SetAction(env, info, input, exec, output);
diff --git a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_observer.cpp b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_observer.cpp
index 2c8360cf4b551192d75df4b2ba25478babd7b598..216e2f659a478b273b0f7a1e6850c7ffb34c7c58 100644
--- a/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_observer.cpp
+++ b/relational_store/frameworks/js/napi/rdb/src/napi_rdb_store_observer.cpp
@@ -32,11 +32,11 @@ NapiRdbStoreObserver::~NapiRdbStoreObserver() noexcept
 
 void NapiRdbStoreObserver::OnChange(const std::vector<std::string> &devices)
 {
-    LOG_INFO("NapiRdbStoreObserver::OnChange begin");
+    LOG_INFO("NapiRdbStoreObserver::OnChange begin.");
     CallFunction([devices](napi_env env, int &argc, napi_value *argv) {
         argc = 1;
         if (argv == nullptr) {
-            LOG_ERROR("NapiRdbStoreObserver::CallFunction error");
+            LOG_ERROR("NapiRdbStoreObserver::CallFunction error.");
             return;
         }
         argv[0] = JSUtils::Convert2JSValue(env, devices);
diff --git a/relational_store/frameworks/js/napi/rdb/src/napi_result_set.cpp b/relational_store/frameworks/js/napi/rdb/src/napi_result_set.cpp
index 4979a71671f1f50b1415c3ae0eea25db00b22f72..1f12bd438e1d3581d831b9fa5b2a049b441f49b2 100644
--- a/relational_store/frameworks/js/napi/rdb/src/napi_result_set.cpp
+++ b/relational_store/frameworks/js/napi/rdb/src/napi_result_set.cpp
@@ -105,7 +105,7 @@ std::shared_ptr<DataShare::ResultSetBridge> ResultSetProxy::Create()
 {
     auto instance = GetInstance();
     if (instance == nullptr) {
-        LOG_ERROR("resultSet_ is null");
+        LOG_ERROR("resultSet_ is null.");
         return nullptr;
     }
     SetInstance(nullptr);
@@ -173,7 +173,7 @@ napi_value ResultSetProxy::InnerInitialize(napi_env env, napi_callback_info info
     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
     auto *proxy = new (std::nothrow) ResultSetProxy();
     if (proxy == nullptr) {
-        LOG_ERROR("ResultSetProxy::InnerInitialize new failed, proxy is nullptr");
+        LOG_ERROR("ResultSetProxy::InnerInitialize new failed, proxy is nullptr.");
         return nullptr;
     }
     proxy->apiversion = version;
@@ -183,7 +183,7 @@ napi_value ResultSetProxy::InnerInitialize(napi_env env, napi_callback_info info
     };
     napi_status status = napi_wrap(env, self, proxy, finalize, nullptr, nullptr);
     if (status != napi_ok) {
-        LOG_ERROR("ResultSetProxy napi_wrap failed! code:%{public}d!, version:%{public}d", status, version);
+        LOG_ERROR("ResultSetProxy napi_wrap failed! code:%{public}d!, version:%{public}d.", status, version);
         finalize(env, proxy, nullptr);
         return nullptr;
     }
@@ -281,7 +281,7 @@ napi_value ResultSetProxy::GetAllColumnNames(napi_env env, napi_callback_info in
 
     int errCode = resultSetProxy->GetInstance()->GetAllColumnNames(colNames);
     if (errCode != E_OK) {
-        LOG_ERROR("GetAllColumnNames failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("GetAllColumnNames failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, colNames);
 }
@@ -305,7 +305,7 @@ napi_value ResultSetProxy::GetColumnCount(napi_env env, napi_callback_info info)
 
     int errCode = resultSetProxy->GetInstance()->GetColumnCount(count);
     if (errCode != E_OK) {
-        LOG_ERROR("GetColumnCount failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("GetColumnCount failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, count);
 }
@@ -332,7 +332,7 @@ napi_value ResultSetProxy::GetColumnType(napi_env env, napi_callback_info info)
 
     int errCode = resultSetProxy->GetInstance()->GetColumnType(columnIndex, columnType);
     if (errCode != E_OK) {
-        LOG_ERROR("GetColumnType failed code:%{public}d, version:%{public}d", errCode, resultSetProxy->apiversion);
+        LOG_ERROR("GetColumnType failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion);
     }
     return JSUtils::Convert2JSValue(env, int32_t(columnType));
 }
@@ -356,7 +356,7 @@ napi_value ResultSetProxy::GetColumnIndex(napi_env env, napi_callback_info info)
 
     int errCode = resultSetProxy->GetInstance()->GetColumnIndex(input, result);
     if (errCode != E_OK) {
-        LOG_ERROR("GetColumnIndex failed code:%{public}d, version:%{public}d", errCode, resultSetProxy->apiversion);
+        LOG_ERROR("GetColumnIndex failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -383,7 +383,7 @@ napi_value ResultSetProxy::GetColumnName(napi_env env, napi_callback_info info)
 
     int errCode = resultSetProxy->GetInstance()->GetColumnName(columnIndex, result);
     if (errCode != E_OK) {
-        LOG_ERROR("GetColumnName failed code:%{public}d, version:%{public}d", errCode, resultSetProxy->apiversion);
+        LOG_ERROR("GetColumnName failed code:%{public}d, version:%{public}d.", errCode, resultSetProxy->apiversion);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -410,7 +410,7 @@ napi_value ResultSetProxy::GetRowCount(napi_env env, napi_callback_info info)
     int32_t result;
     int errCode = resultSetProxy->GetInstance()->GetRowCount(result);
     if (errCode != E_OK) {
-        LOG_ERROR("GetRowCount failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("GetRowCount failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -424,7 +424,7 @@ napi_value ResultSetProxy::GetRowIndex(napi_env env, napi_callback_info info)
     int32_t result;
     int errCode = resultSetProxy->GetInstance()->GetRowIndex(result);
     if (errCode != E_OK) {
-        LOG_ERROR("GetRowIndex failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("GetRowIndex failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -438,7 +438,7 @@ napi_value ResultSetProxy::IsEnded(napi_env env, napi_callback_info info)
     bool result = false;
     int errCode = resultSetProxy->GetInstance()->IsEnded(result);
     if (errCode != E_OK) {
-        LOG_ERROR("IsEnded failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("IsEnded failed code:%{public}d, version:%{public}d.", errCode, version);
         result = true;
     }
     return JSUtils::Convert2JSValue(env, result);
@@ -453,7 +453,7 @@ napi_value ResultSetProxy::IsBegin(napi_env env, napi_callback_info info)
     bool result = false;
     int errCode = resultSetProxy->GetInstance()->IsStarted(result);
     if (errCode != E_OK) {
-        LOG_ERROR("IsBegin failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("IsBegin failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -507,7 +507,7 @@ napi_value ResultSetProxy::IsAtFirstRow(napi_env env, napi_callback_info info)
     bool result = false;
     int errCode = resultSetProxy->GetInstance()->IsAtFirstRow(result);
     if (errCode != E_OK) {
-        LOG_ERROR("IsAtFirstRow failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("IsAtFirstRow failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
@@ -521,7 +521,7 @@ napi_value ResultSetProxy::IsAtLastRow(napi_env env, napi_callback_info info)
     bool result = false;
     int errCode = resultSetProxy->GetInstance()->IsAtLastRow(result);
     if (errCode != E_OK) {
-        LOG_ERROR("IsAtLastRow failed code:%{public}d, version:%{public}d", errCode, version);
+        LOG_ERROR("IsAtLastRow failed code:%{public}d, version:%{public}d.", errCode, version);
     }
     return JSUtils::Convert2JSValue(env, result);
 }
diff --git a/relational_store/frameworks/js/napi/relationalstore/BUILD.gn b/relational_store/frameworks/js/napi/relationalstore/BUILD.gn
index 524aad4a9dc2949b3fd6db149e9c8cf4342700ea..60d56eb45ee7ee410484c90c73db6abd1ff29b3c 100644
--- a/relational_store/frameworks/js/napi/relationalstore/BUILD.gn
+++ b/relational_store/frameworks/js/napi/relationalstore/BUILD.gn
@@ -23,6 +23,7 @@ ohos_copy("relational_store_declaration") {
 
 sources = [
   "../common/src/js_scope.cpp",
+  "../common/src/js_sendable_utils.cpp",
   "../common/src/js_utils.cpp",
   "../common/src/js_uv_queue.cpp",
   "src/entry_point.cpp",
@@ -31,6 +32,7 @@ sources = [
   "src/napi_rdb_error.cpp",
   "src/napi_rdb_js_utils.cpp",
   "src/napi_rdb_predicates.cpp",
+  "src/napi_rdb_sendable_utils.cpp",
   "src/napi_rdb_store.cpp",
   "src/napi_rdb_store_helper.cpp",
   "src/napi_result_set.cpp",
@@ -39,15 +41,6 @@ sources = [
 
 if (is_ohos) {
   ohos_shared_library("relationalstore") {
-    branch_protector_ret = "pac_ret"
-    sanitize = {
-      boundary_sanitize = true
-      ubsan = true
-      cfi = true
-      cfi_cross_dso = true
-      debug = false
-    }
-
     include_dirs = [
       "include",
       "${datashare_path}/common/include/",
@@ -74,6 +67,7 @@ if (is_ohos) {
       "ability_runtime:abilitykit_native",
       "ability_runtime:extensionkit_native",
       "ability_runtime:napi_base_context",
+      "bounds_checking_function:libsec_shared",
       "c_utils:utils",
       "common_event_service:cesfwk_innerkits",
       "eventhandler:libeventhandler",
@@ -117,6 +111,8 @@ if (is_ohos) {
       "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb",
     ]
 
+    external_deps = [ "bounds_checking_function:libsec_static" ]
+
     subsystem_name = "distributeddatamgr"
     part_name = "relational_store"
     relative_install_dir = "module/data"
@@ -150,6 +146,8 @@ if (is_ohos) {
       "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb",
     ]
 
+    external_deps = [ "bounds_checking_function:libsec_static" ]
+
     subsystem_name = "distributeddatamgr"
     part_name = "relational_store"
     relative_install_dir = "module/data"
@@ -188,6 +186,8 @@ if (is_ohos) {
       "//foundation/arkui/ace_engine/adapter/android/build:libarkui_android",
     ]
 
+    external_deps = [ "bounds_checking_function:libsec_static" ]
+
     subsystem_name = "distributeddatamgr"
     part_name = "relational_store"
   }
@@ -222,7 +222,10 @@ if (is_ohos) {
       "//plugins/libs/napi:napi_ios",
     ]
 
-    external_deps = [ "c_utils:utils" ]
+    external_deps = [
+      "bounds_checking_function:libsec_static",
+      "c_utils:utils",
+    ]
 
     subsystem_name = "distributeddatamgr"
     part_name = "relational_store"
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_context.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a89fe25caa2c62371afa0c80d593e9f02eb917e
--- /dev/null
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_context.h
@@ -0,0 +1,78 @@
+/*
+* Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NAPI_RDB_CONTEXT_H
+#define NAPI_RDB_CONTEXT_H
+
+#include "napi_async_call.h"
+#include "napi_rdb_predicates.h"
+
+namespace OHOS {
+namespace RelationalStoreJsKit {
+class ResultSetProxy;
+using namespace OHOS::NativeRdb;
+struct RdbStoreContextBase : public ContextBase {
+    std::shared_ptr<NativeRdb::RdbStore> rdbStore = nullptr;
+};
+
+struct RdbStoreContext : public RdbStoreContextBase {
+    std::string device;
+    std::string tableName;
+    std::vector<std::string> tablesNames;
+    std::string whereClause;
+    std::string sql;
+    RdbPredicatesProxy *predicatesProxy;
+    std::vector<std::string> columns;
+    ValuesBucket valuesBucket;
+    std::vector<ValuesBucket> valuesBuckets;
+    std::map<std::string, ValueObject> numberMaps;
+    std::vector<ValueObject> bindArgs;
+    int64_t int64Output;
+    int intOutput;
+    ValueObject sqlExeOutput;
+    std::vector<uint8_t> newKey;
+    std::shared_ptr<ResultSet> resultSet;
+    std::string aliasName;
+    std::string pathName;
+    std::string srcName;
+    std::string columnName;
+    int32_t enumArg;
+    int32_t distributedType;
+    int32_t syncMode;
+    uint64_t cursor = UINT64_MAX;
+    int64_t txId = 0;
+    DistributedRdb::DistributedConfig distributedConfig;
+    napi_ref asyncHolder = nullptr;
+    NativeRdb::ConflictResolution conflictResolution;
+    DistributedRdb::SyncResult syncResult;
+    std::shared_ptr<RdbPredicates> rdbPredicates = nullptr;
+    std::vector<NativeRdb::RdbStore::PRIKey> keys;
+    std::map<RdbStore::PRIKey, RdbStore::Date> modifyTime;
+    bool isQuerySql = false;
+    uint32_t expiredTime = 0;
+
+    RdbStoreContext()
+        : predicatesProxy(nullptr), int64Output(0), intOutput(0), enumArg(-1),
+          distributedType(DistributedRdb::DistributedTableType::DISTRIBUTED_DEVICE),
+          syncMode(DistributedRdb::SyncMode::PUSH), conflictResolution(ConflictResolution::ON_CONFLICT_NONE)
+    {
+    }
+    virtual ~RdbStoreContext()
+    {
+    }
+};
+} // namespace RelationalStoreJsKit
+} // namespace OHOS
+#endif // NAPI_RDB_CONTEXT_H
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_error.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_error.h
index 151c456778c33f4e91f711227e4d45853a96dfd0..1ff7aa4b376a745693b78d61b2eeba7e8a14bb1a 100644
--- a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_error.h
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_error.h
@@ -40,14 +40,6 @@ struct JsErrorCode {
 };
 const std::optional<JsErrorCode> GetJsErrorCode(int32_t errorCode);
 
-#define ASSERT(condition, message, retVal)                             \
-    do {                                                               \
-        if (!(condition)) {                                            \
-            LOG_ERROR("test (" #condition ") failed: " message);       \
-            return retVal;                                             \
-        }                                                              \
-    } while (0)
-
 #define RDB_REVT_NOTHING
 #define RDB_DO_NOTHING
 
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_js_utils.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_js_utils.h
index ce6fc72adec6475e8628f5375a47bfd66f555f16..b578cca131cb61ddcaa7626341a76b3a30f6dd00 100644
--- a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_js_utils.h
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_js_utils.h
@@ -17,13 +17,16 @@
 #define RDB_JSKIT_NAPI_RDB_JS_UTILS_H
 
 #include <stdint.h>
+
 #include "asset_value.h"
+#include "js_sendable_utils.h"
 #include "js_utils.h"
 #include "napi_rdb_error.h"
 #include "napi_rdb_store_observer.h"
 #include "rdb_store_config.h"
 #include "result_set.h"
 #include "value_object.h"
+#include "values_bucket.h"
 namespace OHOS::AppDataMgrJsKit {
 namespace JSUtils {
 using Asset = OHOS::NativeRdb::AssetValue;
@@ -37,10 +40,12 @@ using SecurityLevel = NativeRdb::SecurityLevel;
 using RdbStoreConfig = NativeRdb::RdbStoreConfig;
 using BigInt = OHOS::NativeRdb::BigInteger;
 using SqlExecInfo = DistributedRdb::SqlObserver::SqlExecutionInfo;
+using ValuesBucket = OHOS::NativeRdb::ValuesBucket;
+using HAMode = NativeRdb::HAMode;
 struct RdbConfig {
     bool isEncrypt = false;
     bool isSearchable = false;
-    bool isAutoClean = false;
+    bool isAutoClean = true;
     bool vector = false;
     bool allowRebuild = false;
     bool isReadOnly = false;
@@ -49,6 +54,8 @@ struct RdbConfig {
     std::string name;
     std::string customDir;
     std::string path;
+    std::vector<std::string> pluginLibs = {};
+    int32_t haMode = HAMode::SINGLE;
 };
 
 struct ContextParam {
@@ -88,11 +95,12 @@ template<>
 napi_value Convert2JSValue(napi_env env, const ValueObject &value);
 
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::Statistic &statistic);
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::Statistic &value);
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::TableDetail &tableDetail);
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::TableDetail &value);
+
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::ProgressDetail &progressDetail);
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::ProgressDetail &value);
 template<>
 napi_value Convert2JSValue(napi_env env, const DistributedRdb::Details &details);
 template<>
@@ -106,13 +114,17 @@ int32_t Convert2Value(napi_env env, napi_value jsValue, BigInt &value);
 template<>
 std::string ToString(const PRIKey &key);
 template<>
-napi_value Convert2JSValue(napi_env env, const SqlExecInfo &sqlExeInfo);
+napi_value Convert2JSValue(napi_env env, const SqlExecInfo &value);
 bool IsNapiString(napi_env env, napi_value value);
 
 std::tuple<int32_t, std::shared_ptr<Error>> GetRealPath(
     napi_env env, napi_value jsValue, RdbConfig &rdbConfig, ContextParam &param);
 RdbStoreConfig GetRdbStoreConfig(const RdbConfig &rdbConfig, const ContextParam &param);
 
+bool HasDuplicateAssets(const ValueObject &value);
+bool HasDuplicateAssets(const std::vector<ValueObject> &values);
+bool HasDuplicateAssets(const ValuesBucket &value);
+bool HasDuplicateAssets(const std::vector<ValuesBucket> &values);
 }; // namespace JSUtils
 } // namespace OHOS::AppDataMgrJsKit
 #endif // RDB_JSKIT_NAPI_RDB_JS_UTILS_H
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_sendable_utils.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_sendable_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..87a81f8f18c7e334cb277ac2cff2529207f68214
--- /dev/null
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_sendable_utils.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RDB_JSKIT_NAPI_RDB_SENDABLE_UTILS_H
+#define RDB_JSKIT_NAPI_RDB_SENDABLE_UTILS_H
+
+#include "napi_rdb_js_utils.h"
+namespace OHOS::AppDataMgrJsKit {
+namespace JSUtils {
+template<>
+napi_value Convert2Sendable(napi_env env, const Asset &value);
+
+template<>
+napi_value Convert2Sendable(napi_env env, const RowEntity &rowEntity);
+
+template<>
+napi_value Convert2Sendable(napi_env env, const ValueObject &value);
+
+template<>
+napi_value Convert2Sendable(napi_env env, const BigInt &value);
+} // namespace JSUtils
+} // namespace OHOS::AppDataMgrJsKit
+#endif // RDB_JSKIT_NAPI_RDB_SENDABLE_UTILS_H
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_store.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_store.h
index dca21316a9bb5c0034290fd8b7ba29a3ec5e2579..6f867da256167db0d32f1d33fd82713f042c6055 100644
--- a/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_store.h
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_rdb_store.h
@@ -56,7 +56,6 @@ private:
     static napi_value ExecuteSql(napi_env env, napi_callback_info info);
     static napi_value Execute(napi_env env, napi_callback_info info);
     static napi_value Backup(napi_env env, napi_callback_info info);
-    static napi_value Count(napi_env env, napi_callback_info info);
     static napi_value Replace(napi_env env, napi_callback_info info);
     static napi_value Attach(napi_env env, napi_callback_info info);
     static napi_value Detach(napi_env env, napi_callback_info info);
@@ -93,6 +92,10 @@ private:
     static napi_value LockRow(napi_env env, napi_callback_info info);
     static napi_value UnlockRow(napi_env env, napi_callback_info info);
     static napi_value QueryLockedRow(napi_env env, napi_callback_info info);
+    static napi_value LockCloudContainer(napi_env env, napi_callback_info info);
+    static napi_value UnlockCloudContainer(napi_env env, napi_callback_info info);
+
+    static void SetBusinessError(napi_env env, std::shared_ptr<Error> error, napi_value *businessError);
 
     static constexpr int EVENT_HANDLE_NUM = 3;
     static constexpr int WAIT_TIME_DEFAULT = 2;
diff --git a/relational_store/frameworks/js/napi/relationalstore/include/napi_result_set.h b/relational_store/frameworks/js/napi/relationalstore/include/napi_result_set.h
index 11ff2900377c6292ab7c67b6784a6417e7179fb3..01bf51d8b31532a693d20da4ecff891c76ce75ab 100644
--- a/relational_store/frameworks/js/napi/relationalstore/include/napi_result_set.h
+++ b/relational_store/frameworks/js/napi/relationalstore/include/napi_result_set.h
@@ -75,6 +75,7 @@ private:
     static napi_value GetDouble(napi_env env, napi_callback_info info);
     static napi_value IsColumnNull(napi_env env, napi_callback_info info);
     static napi_value GetRow(napi_env env, napi_callback_info info);
+    static napi_value GetSendableRow(napi_env env, napi_callback_info info);
     static napi_value GetValue(napi_env env, napi_callback_info info);
     static napi_value IsClosed(napi_env env, napi_callback_info info);
 };
diff --git a/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_rdb_store.h b/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_rdb_store.h
index fdb0f6861d142c968b437d3495e6b466acb64ae3..7784564e2bf77db29a5f4870fbcf44f3aa341bfb 100644
--- a/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_rdb_store.h
+++ b/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_rdb_store.h
@@ -54,7 +54,6 @@ private:
     static napi_value ExecuteSql(napi_env env, napi_callback_info info);
     static napi_value Execute(napi_env env, napi_callback_info info);
     static napi_value Backup(napi_env env, napi_callback_info info);
-    static napi_value Count(napi_env env, napi_callback_info info);
     static napi_value Replace(napi_env env, napi_callback_info info);
     static napi_value Attach(napi_env env, napi_callback_info info);
     static napi_value Detach(napi_env env, napi_callback_info info);
@@ -76,6 +75,7 @@ private:
     static napi_value Restore(napi_env env, napi_callback_info info);
     static napi_value Close(napi_env env, napi_callback_info info);
 
+    int32_t dbType = NativeRdb::DB_SQLITE;
     std::mutex mutex_;
     bool isSystemAppCalled_ = false;
     std::shared_ptr<AppDataMgrJsKit::UvQueue> queue_;
diff --git a/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_result_set.h b/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_result_set.h
index e98aed2b237258f4d3cbed0d01986c6ae80212ca..48fb8604d4c3d1e3ed44cd1ad9452386877e1835 100644
--- a/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_result_set.h
+++ b/relational_store/frameworks/js/napi/relationalstore/mock/include/napi_result_set.h
@@ -72,6 +72,7 @@ private:
     static napi_value GetDouble(napi_env env, napi_callback_info info);
     static napi_value IsColumnNull(napi_env env, napi_callback_info info);
     static napi_value GetRow(napi_env env, napi_callback_info info);
+    static napi_value GetSendableRow(napi_env env, napi_callback_info info);
     static napi_value GetValue(napi_env env, napi_callback_info info);
     static napi_value IsClosed(napi_env env, napi_callback_info info);
 
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_async_call.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_async_call.cpp
index 06223b793f1c4b60b0e7023bbac4d522f5624b3d..1a88b3da838290f64c3efdc3e76e299833a8df5b 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_async_call.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_async_call.cpp
@@ -42,8 +42,12 @@ void ContextBase::SetAction(
         status = napi_typeof(env, argv[argc - 1], &valueType);
         if (status == napi_ok && valueType == napi_function) {
             LOG_DEBUG("asyncCall set callback");
-            status = napi_create_reference(env, argv[argc - 1], 1, &callback_);
-            argc = argc - 1;
+            if (argc == 1) {
+                error = std::make_shared<ParamNumError>("1");
+            } else {
+                status = napi_create_reference(env, argv[argc - 1], 1, &callback_);
+                argc = argc - 1;
+            }
         }
     }
     if (data) {
@@ -95,9 +99,11 @@ ContextBase::~ContextBase()
     }
     if (work_ != nullptr) {
         napi_delete_async_work(env_, work_);
+        work_ = nullptr;
     }
     if (callback_ != nullptr) {
         napi_delete_reference(env_, callback_);
+        callback_ = nullptr;
     }
     napi_delete_reference(env_, self_);
     env_ = nullptr;
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_const_properties.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_const_properties.cpp
index ced69f94f0db20c683c9686fc55b075d94824db1..7786a504c257ce535fde30505a5817fde31cda04 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_const_properties.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_const_properties.cpp
@@ -126,6 +126,7 @@ static napi_value ExportField(napi_env env)
     SET_NAPI_PROPERTY(field, "CURSOR_FIELD", std::string(DistributedRdb::Field::CURSOR_FIELD));
     SET_NAPI_PROPERTY(field, "ORIGIN_FIELD", std::string(DistributedRdb::Field::ORIGIN_FIELD));
     SET_NAPI_PROPERTY(field, "DELETED_FLAG_FIELD", std::string(DistributedRdb::Field::DELETED_FLAG_FIELD));
+    SET_NAPI_PROPERTY(field, "DATA_STATUS_FIELD", std::string(DistributedRdb::Field::DATA_STATUS_FIELD));
     SET_NAPI_PROPERTY(field, "OWNER_FIELD", std::string(DistributedRdb::Field::OWNER_FIELD));
     SET_NAPI_PROPERTY(field, "PRIVILEGE_FIELD", std::string(DistributedRdb::Field::PRIVILEGE_FIELD));
     SET_NAPI_PROPERTY(field, "SHARING_RESOURCE_FIELD", std::string(DistributedRdb::Field::SHARING_RESOURCE_FIELD));
@@ -199,6 +200,17 @@ static napi_value ExportRebuiltType(napi_env env)
     return rebuiltType;
 }
 
+static napi_value ExportHAMode(napi_env env)
+{
+    napi_value haMode = nullptr;
+    napi_create_object(env, &haMode);
+
+    SET_NAPI_PROPERTY(haMode, "SINGLE", int32_t(NativeRdb::HAMode::SINGLE));
+    SET_NAPI_PROPERTY(haMode, "MAIN_REPLICA", int32_t(NativeRdb::HAMode::MAIN_REPLICA));
+    napi_object_freeze(env, haMode);
+    return haMode;
+}
+
 napi_status InitConstProperties(napi_env env, napi_value exports)
 {
     const napi_property_descriptor properties[] = {
@@ -216,6 +228,7 @@ napi_status InitConstProperties(napi_env env, napi_value exports)
         DECLARE_NAPI_PROPERTY("Origin", ExportOrigin(env)),
         DECLARE_NAPI_PROPERTY("Field", ExportField(env)),
         DECLARE_NAPI_PROPERTY("RebuildType", ExportRebuiltType(env)),
+        DECLARE_NAPI_PROPERTY("HAMode", ExportHAMode(env)),
     };
 
     size_t count = sizeof(properties) / sizeof(properties[0]);
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_error.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_error.cpp
index 5b9f0e9da748fc53eb0c06022412c6465962a083..1fbf4a561d760c8f3e96462146db6cc0fa7288c6 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_error.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_error.cpp
@@ -34,6 +34,7 @@ static constexpr JsErrorCode JS_ERROR_CODE_MSGS[] = {
     { NativeRdb::E_GET_DATAOBSMGRCLIENT_FAIL, 14801050, "Failed to get DataObsMgrClient." },
     { NativeRdb::E_TYPE_MISMATCH, 14800051, "The type of the distributed table does not match." },
     { NativeRdb::E_SQLITE_FULL, 14800029, "SQLite: The database is full." },
+    { NativeRdb::E_NOT_SUPPORT_THE_SQL, 14800021, "SQLite: Generic error."},
     { NativeRdb::E_ATTACHED_DATABASE_EXIST, 14800016, "The database is already attached." },
     { NativeRdb::E_SQLITE_ERROR, 14800021, "SQLite: Generic error." },
     { NativeRdb::E_SQLITE_CORRUPT, 14800011, "Database corrupted." },
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_js_utils.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_js_utils.cpp
index 44d4fd89e26b510924172b528df6d71a2a4772ce..6cfd5a857b5f38954da007ae87559a5b6f05ec56 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_js_utils.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_js_utils.cpp
@@ -22,8 +22,8 @@
 #include "js_native_api_types.h"
 #include "logger.h"
 #include "rdb_errno.h"
-#include "rdb_sql_utils.h"
 #include "rdb_sql_statistic.h"
+#include "rdb_sql_utils.h"
 #include "rdb_types.h"
 #include "result_set.h"
 
@@ -113,91 +113,104 @@ int32_t Convert2Value(napi_env env, napi_value jsValue, ValueObject &valueObject
 template<>
 napi_value Convert2JSValue(napi_env env, const Asset &value)
 {
-    napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "name", value.name), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "uri", value.uri), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "createTime", value.createTime), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "modifyTime", value.modifyTime), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "size", value.size), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "path", value.path), object);
     auto outputStatus = value.status & ~0xF0000000;
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "status", outputStatus), object);
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "name", value.name),
+        DECLARE_JS_PROPERTY(env, "uri", value.uri),
+        DECLARE_JS_PROPERTY(env, "createTime", value.createTime),
+        DECLARE_JS_PROPERTY(env, "modifyTime", value.modifyTime),
+        DECLARE_JS_PROPERTY(env, "size", value.size),
+        DECLARE_JS_PROPERTY(env, "path", value.path),
+        DECLARE_JS_PROPERTY(env, "status", outputStatus),
+    };
+
+    napi_value object = nullptr;
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
 template<>
 napi_value Convert2JSValue(napi_env env, const RowEntity &rowEntity)
 {
-    napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
+    std::vector<napi_property_descriptor> descriptors;
     auto &values = rowEntity.Get();
     for (auto const &[key, value] : values) {
-        NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, key.c_str(), value), object);
+        descriptors.emplace_back(DECLARE_JS_PROPERTY(env, key.c_str(), value));
     }
+
+    napi_value object = nullptr;
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
 template<>
-napi_value Convert2JSValue(napi_env env, const ValueObject &valueObject)
+napi_value Convert2JSValue(napi_env env, const ValueObject &value)
 {
-    return JSUtils::Convert2JSValue(env, valueObject.value);
+    return Convert2JSValue(env, value.value);
 }
 
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::Statistic &statistic)
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::Statistic &value)
 {
-    napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "total", value.total),
+        DECLARE_JS_PROPERTY(env, "success", value.success),
+        DECLARE_JS_PROPERTY(env, "successful", value.success),
+        DECLARE_JS_PROPERTY(env, "failed", value.failed),
+        DECLARE_JS_PROPERTY(env, "remained", value.untreated),
+    };
 
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "total", statistic.total), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "success", statistic.success), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "successful", statistic.success), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "failed", statistic.failed), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "remained", statistic.untreated), object);
+    napi_value object = nullptr;
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::TableDetail &tableDetail)
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::TableDetail &value)
 {
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "upload", value.upload),
+        DECLARE_JS_PROPERTY(env, "download", value.download),
+    };
+
     napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "upload", tableDetail.upload), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "download", tableDetail.download), object);
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::ProgressDetail &progressDetail)
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::ProgressDetail &value)
 {
-    napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "schedule", value.progress),
+        DECLARE_JS_PROPERTY(env, "code", value.code),
+        DECLARE_JS_PROPERTY(env, "details", value.details),
+    };
 
-    napi_value schedule = Convert2JSValue(env, progressDetail.progress);
-    napi_value code = Convert2JSValue(env, progressDetail.code);
-    napi_value details = Convert2JSValue(env, progressDetail.details);
-    if (details == nullptr) {
-        return nullptr;
-    }
-    napi_set_named_property(env, object, "schedule", schedule);
-    napi_set_named_property(env, object, "code", code);
-    napi_set_named_property(env, object, "details", details);
+    napi_value object = nullptr;
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
 template<>
-napi_value Convert2JSValue(napi_env env, const DistributedRdb::SqlObserver::SqlExecutionInfo &sqlExeInfo)
+napi_value Convert2JSValue(napi_env env, const DistributedRdb::SqlObserver::SqlExecutionInfo &value)
 {
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "sql", value.sql_),
+        DECLARE_JS_PROPERTY(env, "totalTime", value.totalTime_),
+        DECLARE_JS_PROPERTY(env, "waitTime", value.waitTime_),
+        DECLARE_JS_PROPERTY(env, "prepareTime", value.prepareTime_),
+        DECLARE_JS_PROPERTY(env, "executeTime", value.executeTime_),
+    };
+
     napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
-
-    std::vector<std::string> sql(sqlExeInfo.sql_.begin(), sqlExeInfo.sql_.end());
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "sql", sql), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "totalTime", sqlExeInfo.totalTime_), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "waitTime", sqlExeInfo.waitTime_), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "prepareTime", sqlExeInfo.prepareTime_), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "executeTime", sqlExeInfo.executeTime_), object);
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
@@ -210,13 +223,17 @@ napi_value Convert2JSValue(napi_env env, const DistributedRdb::Details &details)
 template<>
 napi_value Convert2JSValue(napi_env env, const JSChangeInfo &value)
 {
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_JS_PROPERTY(env, "table", value.table),
+        DECLARE_JS_PROPERTY(env, "type", value.type),
+        DECLARE_JS_PROPERTY(env, "inserted", value.inserted),
+        DECLARE_JS_PROPERTY(env, "updated", value.updated),
+        DECLARE_JS_PROPERTY(env, "deleted", value.deleted),
+    };
+
     napi_value object = nullptr;
-    NAPI_CALL_RETURN_ERR(napi_create_object(env, &object), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "table", value.table), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "type", value.type), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "inserted", value.inserted), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "updated", value.updated), object);
-    NAPI_CALL_RETURN_ERR(SetNamedProperty(env, object, "deleted", value.deleted), object);
+    NAPI_CALL_RETURN_ERR(
+        napi_create_object_with_properties(env, &object, descriptors.size(), descriptors.data()), object);
     return object;
 }
 
@@ -228,7 +245,7 @@ napi_value Convert2JSValue(napi_env env, const Date &date)
     return jsDeta;
 }
 template<>
-napi_value Convert2JSValue(napi_env env, const BigInt& value)
+napi_value Convert2JSValue(napi_env env, const BigInt &value)
 {
     napi_value val = nullptr;
     napi_status status = napi_create_bigint_words(env, value.Sign(), value.Size(), value.TrueForm(), &val);
@@ -239,7 +256,7 @@ napi_value Convert2JSValue(napi_env env, const BigInt& value)
 }
 
 template<>
-int32_t Convert2Value(napi_env env, napi_value jsValue, BigInt& value)
+int32_t Convert2Value(napi_env env, napi_value jsValue, BigInt &value)
 {
     napi_valuetype type = napi_undefined;
     napi_status status = napi_typeof(env, jsValue, &type);
@@ -335,6 +352,12 @@ int32_t Convert2Value(napi_env env, napi_value jsValue, RdbConfig &rdbConfig)
 
     GetNamedProperty(env, jsValue, "isReadOnly", rdbConfig.isReadOnly, true);
     ASSERT(OK == status, "get isReadOnly failed.", napi_invalid_arg);
+
+    GetNamedProperty(env, jsValue, "pluginLibs", rdbConfig.pluginLibs, true);
+    ASSERT(OK == status, "get pluginLibs failed.", napi_invalid_arg);
+ 
+    status = GetNamedProperty(env, jsValue, "haMode", rdbConfig.haMode, true);
+    ASSERT(OK == status, "get haMode failed.", napi_invalid_arg);
     return napi_ok;
 }
 
@@ -387,6 +410,8 @@ int32_t Convert2Value(napi_env env, napi_value jsValue, ContextParam &param)
         ASSERT(status == napi_ok, "get applicationInfo.name failed.", napi_invalid_arg);
         status = GetNamedProperty(env, appInfo, "systemApp", param.isSystemApp, true);
         ASSERT(status == napi_ok, "get applicationInfo.systemApp failed.", napi_invalid_arg);
+        int32_t hapVersion = JSAbility::GetHapVersion(env, jsValue);
+        JSUtils::SetHapVersion(hapVersion);
     }
     return napi_ok;
 }
@@ -403,7 +428,8 @@ std::tuple<int32_t, std::shared_ptr<Error>> GetRealPath(
             std::make_tuple(ERR, std::make_shared<ParamError>("customDir", "a relative directory.")));
         // customDir length is limited to 128 bytes
         CHECK_RETURN_CORE(rdbConfig.customDir.length() <= 128, RDB_DO_NOTHING,
-            std::make_tuple(ERR, std::make_shared<ParamError>("customDir length", "less than or equal to 128 bytes.")));
+            std::make_tuple(ERR, std::make_shared<ParamError>("customDir length", "less than or equal to 128 "
+                                                                                  "bytes.")));
     }
 
     std::string baseDir = param.baseDir;
@@ -444,13 +470,64 @@ RdbStoreConfig GetRdbStoreConfig(const RdbConfig &rdbConfig, const ContextParam
     rdbStoreConfig.SetCustomDir(rdbConfig.customDir);
     rdbStoreConfig.SetAllowRebuild(rdbConfig.allowRebuild);
     rdbStoreConfig.SetReadOnly(rdbConfig.isReadOnly);
+    rdbStoreConfig.SetIntegrityCheck(IntegrityCheck::NONE);
 
     if (!param.bundleName.empty()) {
         rdbStoreConfig.SetBundleName(param.bundleName);
     }
     rdbStoreConfig.SetModuleName(param.moduleName);
     rdbStoreConfig.SetArea(param.area);
+    rdbStoreConfig.SetPluginLibs(rdbConfig.pluginLibs);
+    rdbStoreConfig.SetHaMode(rdbConfig.haMode);
     return rdbStoreConfig;
 }
+
+bool HasDuplicateAssets(const ValueObject &value)
+{
+    auto *assets = std::get_if<ValueObject::Assets>(&value.value);
+    if (assets == nullptr) {
+        return false;
+    }
+    std::set<std::string> names;
+    auto item = assets->begin();
+    while (item != assets->end()) {
+        if (!names.insert(item->name).second) {
+            LOG_ERROR("duplicate assets! name = %{public}.6s", item->name.c_str());
+            return true;
+        }
+        item++;
+    }
+    return false;
+}
+
+bool HasDuplicateAssets(const std::vector<ValueObject> &values)
+{
+    for (auto &val : values) {
+        if (HasDuplicateAssets(val)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool HasDuplicateAssets(const ValuesBucket &value)
+{
+    for (auto &[key, val] : value.values_) {
+        if (HasDuplicateAssets(val)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool HasDuplicateAssets(const std::vector<ValuesBucket> &values)
+{
+    for (auto &valueBucket : values) {
+        if (HasDuplicateAssets(valueBucket)) {
+            return true;
+        }
+    }
+    return false;
+}
 }; // namespace JSUtils
 } // namespace OHOS::AppDataMgrJsKit
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_predicates.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_predicates.cpp
index d73d1f7cfd9ccc0da10b9175839377cbe5ccf681..724e1296518c6737a13730e62f50557e76db89c7 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_predicates.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_predicates.cpp
@@ -83,7 +83,7 @@ void RdbPredicatesProxy::Init(napi_env env, napi_value exports)
     NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor_));
     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "RdbPredicates", cons));
 
-    LOG_DEBUG("RdbPredicatesProxy::Init end");
+    LOG_DEBUG("RdbPredicatesProxy::Init end.");
 }
 
 napi_value RdbPredicatesProxy::New(napi_env env, napi_callback_info info)
@@ -105,7 +105,7 @@ napi_value RdbPredicatesProxy::New(napi_env env, napi_callback_info info)
         RDB_NAPI_ASSERT(env, !tableName.empty(), std::make_shared<ParamError>("name", "not empty"));
         auto *proxy = new (std::nothrow) RdbPredicatesProxy(tableName);
         if (proxy == nullptr) {
-            LOG_ERROR("RdbPredicatesProxy::New new failed, proxy is nullptr");
+            LOG_ERROR("RdbPredicatesProxy::New new failed, proxy is nullptr.");
             return nullptr;
         }
         napi_status status = napi_wrap(env, thiz, proxy, RdbPredicatesProxy::Destructor, nullptr, nullptr);
@@ -163,7 +163,7 @@ void RdbPredicatesProxy::Destructor(napi_env env, void *nativeObject, void *)
 
 RdbPredicatesProxy::~RdbPredicatesProxy()
 {
-    LOG_DEBUG("RdbPredicatesProxy destructor");
+    LOG_DEBUG("RdbPredicatesProxy destructor.");
 }
 
 RdbPredicatesProxy::RdbPredicatesProxy(std::string &tableName)
@@ -652,6 +652,9 @@ napi_value RdbPredicatesProxy::In(napi_env env, napi_callback_info info)
     std::vector<ValueObject> values;
     auto predicatesProxy = ParseFieldAndValueArray(env, info, thiz, field, values, "ValueType");
     CHECK_RETURN_NULL(predicatesProxy && predicatesProxy->GetInstance());
+    if (values.empty()) {
+        return thiz;
+    }
     predicatesProxy->GetInstance()->In(field, values);
     return thiz;
 }
@@ -663,6 +666,9 @@ napi_value RdbPredicatesProxy::NotIn(napi_env env, napi_callback_info info)
     std::vector<ValueObject> values;
     auto predicatesProxy = ParseFieldAndValueArray(env, info, thiz, field, values, "ValueType");
     CHECK_RETURN_NULL(predicatesProxy && predicatesProxy->GetInstance());
+    if (values.empty()) {
+        return thiz;
+    }
     predicatesProxy->GetInstance()->NotIn(field, values);
     return thiz;
 }
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_sendable_utils.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_sendable_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac6789489af0dc0c93f2f0bcc0b174d9dd927b57
--- /dev/null
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_sendable_utils.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "NapiRdbSendableUtils"
+#include "napi_rdb_sendable_utils.h"
+
+#define NAPI_CALL_RETURN_ERR(theCall, retVal) \
+    do {                                      \
+        if ((theCall) != napi_ok) {           \
+            return retVal;                    \
+        }                                     \
+    } while (0)
+
+namespace OHOS::AppDataMgrJsKit {
+namespace JSUtils {
+
+template<>
+napi_value Convert2Sendable(napi_env env, const Asset &value)
+{
+    auto outputStatus = value.status & ~0xF0000000;
+    std::vector<napi_property_descriptor> descriptors = {
+        DECLARE_SENDABLE_PROPERTY(env, "name", value.name),
+        DECLARE_SENDABLE_PROPERTY(env, "uri", value.uri),
+        DECLARE_SENDABLE_PROPERTY(env, "createTime", value.createTime),
+        DECLARE_SENDABLE_PROPERTY(env, "modifyTime", value.modifyTime),
+        DECLARE_SENDABLE_PROPERTY(env, "size", value.size),
+        DECLARE_SENDABLE_PROPERTY(env, "path", value.path),
+        DECLARE_SENDABLE_PROPERTY(env, "status", outputStatus),
+    };
+
+    napi_value object = nullptr;
+    NAPI_CALL_RETURN_ERR(
+        napi_create_sendable_object_with_properties(env, descriptors.size(), descriptors.data(), &object), object);
+    return object;
+}
+
+template<>
+napi_value Convert2Sendable(napi_env env, const RowEntity &rowEntity)
+{
+    napi_value map = nullptr;
+    NAPI_CALL_RETURN_ERR(napi_create_sendable_map(env, &map), nullptr);
+    auto &values = rowEntity.Get();
+    for (auto const &[key, value] : values) {
+        NAPI_CALL_RETURN_ERR(napi_map_set_named_property(env, map, key.c_str(), Convert2Sendable(env, value)), nullptr);
+    }
+    return map;
+}
+
+template<>
+napi_value Convert2Sendable(napi_env env, const ValueObject &value)
+{
+    return Convert2Sendable(env, value.value);
+}
+
+template<>
+napi_value Convert2Sendable(napi_env env, const BigInt &value)
+{
+    return Convert2JSValue(env, value);
+}
+}; // namespace JSUtils
+} // namespace OHOS::AppDataMgrJsKit
\ No newline at end of file
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_store.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_store.cpp
index 607c510b775c233cbccee3bc471af9af0faa02d3..15acf6ffe69ba7607f96881d77f1a1ed4ef9a64e 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_store.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_rdb_store.cpp
@@ -12,21 +12,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #define LOG_TAG "NapiRdbStore"
 #include "napi_rdb_store.h"
 
 #include <algorithm>
 #include <cinttypes>
+#include <cstdint>
 #include <string>
 #include <vector>
 
+#include "js_native_api.h"
 #include "js_native_api_types.h"
 #include "js_utils.h"
 #include "logger.h"
-#include "napi_async_call.h"
+#include "napi_rdb_context.h"
 #include "napi_rdb_error.h"
 #include "napi_rdb_js_utils.h"
-#include "napi_rdb_predicates.h"
 #include "napi_rdb_trace.h"
 #include "napi_result_set.h"
 #include "rdb_errno.h"
@@ -39,7 +41,6 @@ using namespace OHOS::DataShare;
 #endif
 
 using namespace OHOS::Rdb;
-using namespace OHOS::NativeRdb;
 using namespace OHOS::AppDataMgrJsKit;
 using namespace OHOS::AppDataMgrJsKit::JSUtils;
 
@@ -48,8 +49,8 @@ using OHOS::DistributedRdb::SubscribeMode;
 using OHOS::DistributedRdb::SubscribeOption;
 using OHOS::DistributedRdb::SyncOption;
 
-using OHOS::DistributedRdb::SyncResult;
 using OHOS::DistributedRdb::Details;
+using OHOS::DistributedRdb::SyncResult;
 #endif
 
 namespace OHOS {
@@ -60,52 +61,8 @@ struct PredicatesProxy {
     std::shared_ptr<DataShareAbsPredicates> predicates_;
 };
 #endif
-struct RdbStoreContext : public ContextBase {
-    std::string device;
-    std::string tableName;
-    std::vector<std::string> tablesNames;
-    std::string whereClause;
-    std::string sql;
-    RdbPredicatesProxy *predicatesProxy;
-    std::vector<std::string> columns;
-    ValuesBucket valuesBucket;
-    std::vector<ValuesBucket> valuesBuckets;
-    std::map<std::string, ValueObject> numberMaps;
-    std::vector<ValueObject> bindArgs;
-    int64_t int64Output;
-    int intOutput;
-    ValueObject sqlExeOutput;
-    std::vector<uint8_t> newKey;
-    std::shared_ptr<ResultSet> resultSet;
-    std::string aliasName;
-    std::string pathName;
-    std::string srcName;
-    std::string columnName;
-    int32_t enumArg;
-    int32_t distributedType;
-    int32_t syncMode;
-    uint64_t cursor = UINT64_MAX;
-    int64_t txId = 0;
-    DistributedRdb::DistributedConfig distributedConfig;
-    napi_ref asyncHolder = nullptr;
-    NativeRdb::ConflictResolution conflictResolution;
-    DistributedRdb::SyncResult syncResult;
-    std::shared_ptr<RdbPredicates> rdbPredicates = nullptr;
-    std::vector<NativeRdb::RdbStore::PRIKey> keys;
-    std::map<RdbStore::PRIKey, RdbStore::Date> modifyTime;
-    bool isQuerySql = false;
-
-    RdbStoreContext()
-        : predicatesProxy(nullptr), int64Output(0), intOutput(0), enumArg(-1),
-          distributedType(DistributedRdb::DistributedTableType::DISTRIBUTED_DEVICE),
-          syncMode(DistributedRdb::SyncMode::PUSH),
-          conflictResolution(ConflictResolution::ON_CONFLICT_NONE)
-    {
-    }
-    virtual ~RdbStoreContext()
-    {
-    }
-};
+constexpr int32_t KEY_INDEX = 0;
+constexpr int32_t VALUE_INDEX = 1;
 
 RdbStoreProxy::RdbStoreProxy()
 {
@@ -113,11 +70,12 @@ RdbStoreProxy::RdbStoreProxy()
 
 RdbStoreProxy::~RdbStoreProxy()
 {
-    LOG_DEBUG("RdbStoreProxy destructor");
+    LOG_DEBUG("RdbStoreProxy destructor.");
     auto rdbStore = GetInstance();
     if (rdbStore == nullptr) {
         return;
     }
+#if !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
     for (int32_t mode = DistributedRdb::REMOTE; mode < DistributedRdb::LOCAL; mode++) {
         for (auto &obs : observers_[mode]) {
             if (obs == nullptr) {
@@ -145,6 +103,7 @@ RdbStoreProxy::~RdbStoreProxy()
     for (const auto &obs : syncObservers_) {
         rdbStore->UnregisterAutoSyncCallback(obs);
     }
+#endif
 }
 
 RdbStoreProxy::RdbStoreProxy(std::shared_ptr<NativeRdb::RdbStore> rdbStore)
@@ -220,6 +179,8 @@ Descriptor RdbStoreProxy::GetDescriptors()
             DECLARE_NAPI_FUNCTION("lockRow", LockRow),
             DECLARE_NAPI_FUNCTION("unlockRow", UnlockRow),
             DECLARE_NAPI_FUNCTION("queryLockedRow", QueryLockedRow),
+            DECLARE_NAPI_FUNCTION("lockCloudContainer", LockCloudContainer),
+            DECLARE_NAPI_FUNCTION("unlockCloudContainer", UnlockCloudContainer),
 #endif
         };
         AddSyncFunctions(properties);
@@ -250,8 +211,8 @@ napi_value RdbStoreProxy::Initialize(napi_env env, napi_callback_info info)
     NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &self, nullptr));
     auto finalize = [](napi_env env, void *data, void *hint) {
         if (data != hint) {
-            LOG_ERROR("RdbStoreProxy memory corrupted! data:0x%016" PRIXPTR "hint:0x%016" PRIXPTR,
-                uintptr_t(data), uintptr_t(hint));
+            LOG_ERROR("RdbStoreProxy memory corrupted! data:0x%016" PRIXPTR "hint:0x%016" PRIXPTR, uintptr_t(data),
+                uintptr_t(hint));
             return;
         }
         RdbStoreProxy *proxy = reinterpret_cast<RdbStoreProxy *>(data);
@@ -313,12 +274,13 @@ RdbStoreProxy *GetNativeInstance(napi_env env, napi_value self)
     return proxy;
 }
 
-int ParserThis(const napi_env &env, const napi_value &self, std::shared_ptr<ContextBase> context)
+int ParserThis(const napi_env &env, const napi_value &self, std::shared_ptr<RdbStoreContextBase> context)
 {
     RdbStoreProxy *obj = GetNativeInstance(env, self);
-    CHECK_RETURN_SET(obj, std::make_shared<ParamError>("RdbStore", "not nullptr."));
-    CHECK_RETURN_SET(obj->GetInstance(), std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
+    CHECK_RETURN_SET(obj != nullptr, std::make_shared<ParamError>("RdbStore", "not nullptr."));
+    CHECK_RETURN_SET(obj->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     context->boundObj = obj;
+    context->rdbStore = obj->GetInstance();
     return OK;
 }
 
@@ -378,22 +340,22 @@ int ParseSyncModeArg(const napi_env env, const napi_value arg, std::shared_ptr<R
     return OK;
 }
 
-int ParseDistributedTypeArg(const napi_env &env, size_t argc, napi_value * argv,
-    std::shared_ptr<RdbStoreContext> context)
+int ParseDistributedTypeArg(
+    const napi_env &env, size_t argc, napi_value *argv, std::shared_ptr<RdbStoreContext> context)
 {
     context->distributedType = DistributedRdb::DISTRIBUTED_DEVICE;
     if (argc > 1) {
         auto status = JSUtils::Convert2ValueExt(env, argv[1], context->distributedType);
-        bool checked = status == napi_ok && context->distributedType >= DistributedRdb::DISTRIBUTED_DEVICE
-                       && context->distributedType <= DistributedRdb::DISTRIBUTED_CLOUD;
+        bool checked = status == napi_ok && context->distributedType >= DistributedRdb::DISTRIBUTED_DEVICE &&
+                       context->distributedType <= DistributedRdb::DISTRIBUTED_CLOUD;
         CHECK_RETURN_SET(JSUtils::IsNull(env, argv[1]) || checked,
             std::make_shared<ParamError>("distributedType", "a DistributedType"));
     }
     return OK;
 }
 
-int ParseDistributedConfigArg(const napi_env &env, size_t argc, napi_value * argv,
-    std::shared_ptr<RdbStoreContext> context)
+int ParseDistributedConfigArg(
+    const napi_env &env, size_t argc, napi_value *argv, std::shared_ptr<RdbStoreContext> context)
 {
     context->distributedConfig = { false };
     // '2' Ensure that the incoming argv contains 3 parameter
@@ -408,8 +370,8 @@ int ParseDistributedConfigArg(const napi_env &env, size_t argc, napi_value * arg
 int ParseCloudSyncModeArg(const napi_env env, const napi_value arg, std::shared_ptr<RdbStoreContext> context)
 {
     auto status = JSUtils::Convert2ValueExt(env, arg, context->syncMode);
-    bool checked = (status == napi_ok && context->syncMode >= DistributedRdb::TIME_FIRST
-                    && context->syncMode <= DistributedRdb::CLOUD_FIRST);
+    bool checked = (status == napi_ok && context->syncMode >= DistributedRdb::TIME_FIRST &&
+                    context->syncMode <= DistributedRdb::CLOUD_FIRST);
     CHECK_RETURN_SET(checked, std::make_shared<ParamError>("mode", "a SyncMode of cloud."));
     return OK;
 }
@@ -418,8 +380,8 @@ int ParseCallback(const napi_env env, const napi_value arg, std::shared_ptr<RdbS
 {
     napi_valuetype valueType = napi_undefined;
     napi_status status = napi_typeof(env, arg, &valueType);
-    CHECK_RETURN_SET((status == napi_ok && valueType == napi_function),
-        std::make_shared<ParamError>("callback", "a function."));
+    CHECK_RETURN_SET(
+        (status == napi_ok && valueType == napi_function), std::make_shared<ParamError>("callback", "a function."));
     NAPI_CALL_BASE(env, napi_create_reference(env, arg, 1, &context->callback_), ERR);
     return OK;
 }
@@ -514,6 +476,15 @@ int ParseBindArgs(const napi_env env, const napi_value arg, std::shared_ptr<RdbS
         ValueObject valueObject;
         int32_t ret = JSUtils::Convert2Value(env, element, valueObject.value);
         CHECK_RETURN_SET(ret == OK, std::make_shared<ParamError>(std::to_string(i), "ValueObject"));
+        // The blob is an empty vector.
+        // If the API version is less than 12, and insert null. Otherwise, insert an empty vector.
+        if (valueObject.GetType() == ValueObject::TYPE_BLOB && JSUtils::GetHapVersion() < 12) {
+            std::vector<uint8_t> tmpValue;
+            valueObject.GetBlob(tmpValue);
+            if (tmpValue.empty()) {
+                valueObject = ValueObject();
+            }
+        }
         context->bindArgs.push_back(std::move(valueObject));
     }
     return OK;
@@ -535,14 +506,54 @@ int ParseTxId(const napi_env env, const napi_value arg, std::shared_ptr<RdbStore
     return OK;
 }
 
+int ParseSendableValuesBucket(const napi_env env, const napi_value map, std::shared_ptr<RdbStoreContext> context)
+{
+    uint32_t length = 0;
+    napi_status status = napi_map_get_size(env, map, &length);
+    auto error = std::make_shared<ParamError>("ValuesBucket is invalid.");
+    CHECK_RETURN_SET(status == napi_ok && length > 0, error);
+    napi_value entries = nullptr;
+    status = napi_map_get_entries(env, map, &entries);
+    CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_map_get_entries failed."));
+    for (uint32_t i = 0; i < length; ++i) {
+        napi_value iter = nullptr;
+        status = napi_map_iterator_get_next(env, entries, &iter);
+        CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_map_iterator_get_next failed."));
+        napi_value values = nullptr;
+        status = napi_get_named_property(env, iter, "value", &values);
+        CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_get_named_property value failed."));
+        napi_value key = nullptr;
+        status = napi_get_element(env, values, KEY_INDEX, &key);
+        CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_get_element key failed."));
+        std::string keyStr = JSUtils::Convert2String(env, key);
+        napi_value value = nullptr;
+        status = napi_get_element(env, values, VALUE_INDEX, &value);
+        CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_get_element value failed."));
+        ValueObject valueObject;
+        int32_t ret = JSUtils::Convert2Value(env, value, valueObject.value);
+        if (ret == napi_ok) {
+            context->valuesBucket.Put(keyStr, valueObject);
+        } else if (ret != napi_generic_failure) {
+            CHECK_RETURN_SET(false, std::make_shared<ParamError>("The value type of " + keyStr, "invalid."));
+        }
+    }
+    return OK;
+}
+
 int ParseValuesBucket(const napi_env env, const napi_value arg, std::shared_ptr<RdbStoreContext> context)
 {
+    bool isMap = false;
+    napi_status status = napi_is_map(env, arg, &isMap);
+    CHECK_RETURN_SET(
+        status == napi_ok, std::make_shared<InnerError>("call napi_is_map failed " + std::to_string(status)));
+    if (isMap) {
+        return ParseSendableValuesBucket(env, arg, context);
+    }
     napi_value keys = nullptr;
     napi_get_all_property_names(env, arg, napi_key_own_only,
-        static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols),
-        napi_key_numbers_to_strings, &keys);
+        static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, &keys);
     uint32_t arrLen = 0;
-    napi_status status = napi_get_array_length(env, keys, &arrLen);
+    status = napi_get_array_length(env, keys, &arrLen);
     CHECK_RETURN_SET(status == napi_ok && arrLen > 0, std::make_shared<ParamError>("ValuesBucket is invalid"));
 
     for (size_t i = 0; i < arrLen; ++i) {
@@ -554,6 +565,15 @@ int ParseValuesBucket(const napi_env env, const napi_value arg, std::shared_ptr<
         napi_get_property(env, arg, key, &value);
         ValueObject valueObject;
         int32_t ret = JSUtils::Convert2Value(env, value, valueObject.value);
+        // The blob is an empty vector.
+        // If the API version is less than 12, and insert null. Otherwise, insert an empty vector.
+        if (ret == napi_ok && valueObject.GetType() == ValueObject::TYPE_BLOB && JSUtils::GetHapVersion() < 12) {
+            std::vector<uint8_t> tmpValue;
+            valueObject.GetBlob(tmpValue);
+            if (tmpValue.empty()) {
+                valueObject = ValueObject();
+            }
+        }
         if (ret == napi_ok) {
             context->valuesBucket.Put(keyStr, valueObject);
         } else if (ret != napi_generic_failure) {
@@ -579,7 +599,7 @@ int ParseValuesBuckets(const napi_env env, const napi_value arg, std::shared_ptr
         CHECK_RETURN_SET(status == napi_ok, std::make_shared<InnerError>("napi_get_element failed."));
 
         CHECK_RETURN_ERR(ParseValuesBucket(env, obj, context) == OK);
-        context->valuesBuckets.push_back(context->valuesBucket);
+        context->valuesBuckets.push_back(std::move(context->valuesBucket));
         context->valuesBucket.Clear();
     }
     return OK;
@@ -605,14 +625,16 @@ napi_value RdbStoreProxy::Insert(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParserThis(env, self, context));
         CHECK_RETURN(OK == ParseTableName(env, argv[0], context));
         CHECK_RETURN(OK == ParseValuesBucket(env, argv[1], context));
+        CHECK_RETURN_SET_E(!HasDuplicateAssets(context->valuesBucket), std::make_shared<ParamError>("Duplicate assets "
+                                                                                                   "are not allowed"));
         if (argc == 3) {
             CHECK_RETURN(OK == ParseConflictResolution(env, argv[2], context));
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->InsertWithConflictResolution(
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->InsertWithConflictResolution(
             context->int64Output, context->tableName, context->valuesBucket, context->conflictResolution);
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -633,11 +655,13 @@ napi_value RdbStoreProxy::BatchInsert(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParserThis(env, self, context));
         CHECK_RETURN(OK == ParseTableName(env, argv[0], context));
         CHECK_RETURN(OK == ParseValuesBuckets(env, argv[1], context));
+        CHECK_RETURN_SET_E(!HasDuplicateAssets(context->valuesBuckets), std::make_shared<ParamError>("Duplicate assets "
+                                                                                                   "are not allowed"));
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->BatchInsert(context->int64Output, context->tableName, context->valuesBuckets);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->BatchInsert(context->int64Output, context->tableName, context->valuesBuckets);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_create_int64(env, context->int64Output, &result);
@@ -663,10 +687,9 @@ napi_value RdbStoreProxy::Delete(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
-        return obj->GetInstance()->Delete(context->intOutput, *(context->rdbPredicates));
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->Delete(context->intOutput, *(context->rdbPredicates));
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_create_int64(env, context->intOutput, &result);
@@ -701,11 +724,10 @@ napi_value RdbStoreProxy::Update(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
-        return obj->GetInstance()->UpdateWithConflictResolution(context->intOutput, context->tableName,
-            context->valuesBucket, context->rdbPredicates->GetWhereClause(), context->rdbPredicates->GetBindArgs(),
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->UpdateWithConflictResolution(context->intOutput, context->tableName, context->valuesBucket,
+            context->rdbPredicates->GetWhereClause(), context->rdbPredicates->GetBindArgs(),
             context->conflictResolution);
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -739,10 +761,9 @@ napi_value RdbStoreProxy::Query(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
-        context->resultSet = obj->GetInstance()->Query(*(context->rdbPredicates), context->columns);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
+        context->resultSet = context->rdbStore->Query(*(context->rdbPredicates), context->columns);
+        context->rdbStore = nullptr;
         return (context->resultSet != nullptr) ? E_OK : E_ERROR;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -770,12 +791,11 @@ napi_value RdbStoreProxy::RemoteQuery(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
         int errCode = E_ERROR;
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
         context->resultSet =
-            obj->GetInstance()->RemoteQuery(context->device, *(context->rdbPredicates), context->columns, errCode);
+            context->rdbStore->RemoteQuery(context->device, *(context->rdbPredicates), context->columns, errCode);
+        context->rdbStore = nullptr;
         return errCode;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -803,16 +823,17 @@ napi_value RdbStoreProxy::QuerySql(napi_env env, napi_callback_info info)
     };
     auto exec = [context]() -> int {
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
+        CHECK_RETURN_ERR(obj != nullptr && context->rdbStore != nullptr);
         if (obj->dbType == DB_VECTOR) {
-            context->resultSet = obj->GetInstance()->QueryByStep(context->sql, context->bindArgs);
+            context->resultSet = context->rdbStore->QueryByStep(context->sql, context->bindArgs);
             return (context->resultSet != nullptr) ? E_OK : E_ERROR;
         }
 #if defined(WINDOWS_PLATFORM) || defined(MAC_PLATFORM) || defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
-        context->resultSet = obj->GetInstance()->QueryByStep(context->sql, context->bindArgs);
+        context->resultSet = context->rdbStore->QueryByStep(context->sql, context->bindArgs);
 #else
-        context->resultSet = obj->GetInstance()->QuerySql(context->sql, context->bindArgs);
+        context->resultSet = context->rdbStore->QuerySql(context->sql, context->bindArgs);
 #endif
+        context->rdbStore = nullptr;
         return (context->resultSet != nullptr) ? E_OK : E_ERROR;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -834,12 +855,14 @@ napi_value RdbStoreProxy::ExecuteSql(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParseSql(env, argv[0], context));
         if (argc == 2) {
             CHECK_RETURN(OK == ParseBindArgs(env, argv[1], context));
+            CHECK_RETURN_SET_E(!HasDuplicateAssets(context->bindArgs), std::make_shared<ParamError>("Duplicate assets "
+                                                                                                    "are not allowed"));
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->ExecuteSql(context->sql, context->bindArgs);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->ExecuteSql(context->sql, context->bindArgs);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
@@ -865,19 +888,23 @@ napi_value RdbStoreProxy::Execute(napi_env env, napi_callback_info info)
                 CHECK_RETURN(OK == ParseTxId(env, argv[1], context));
             } else {
                 CHECK_RETURN(OK == ParseBindArgs(env, argv[1], context));
+                CHECK_RETURN_SET_E(!HasDuplicateAssets(context->bindArgs),
+                    std::make_shared<ParamError>("Duplicate assets are not allowed"));
             }
         }
         if (argc == 3) {
             CHECK_RETURN(OK == ParseTxId(env, argv[1], context));
             CHECK_RETURN(OK == ParseBindArgs(env, argv[2], context));
+            CHECK_RETURN_SET_E(!HasDuplicateAssets(context->bindArgs),
+                std::make_shared<ParamError>("Duplicate assets are not allowed"));
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
         auto status = E_ERROR;
         std::tie(status, context->sqlExeOutput) =
-            obj->GetInstance()->Execute(context->sql, context->bindArgs, context->txId);
+            context->rdbStore->Execute(context->sql, context->bindArgs, context->txId);
+        context->rdbStore = nullptr;
         return status;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -890,30 +917,6 @@ napi_value RdbStoreProxy::Execute(napi_env env, napi_callback_info info)
     return ASYNC_CALL(env, context);
 }
 
-napi_value RdbStoreProxy::Count(napi_env env, napi_callback_info info)
-{
-    auto context = std::make_shared<RdbStoreContext>();
-    auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
-        CHECK_RETURN_SET_E(argc == 1, std::make_shared<ParamNumError>("1 or 2"));
-        CHECK_RETURN(OK == ParserThis(env, self, context));
-        CHECK_RETURN(OK == ParsePredicates(env, argv[0], context));
-    };
-    auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->predicatesProxy != nullptr && context->predicatesProxy->GetPredicates() != nullptr);
-        return obj->GetInstance()->Count(context->int64Output, *(context->predicatesProxy->GetPredicates()));
-    };
-    auto output = [context](napi_env env, napi_value &result) {
-        napi_status status = napi_create_int64(env, context->int64Output, &result);
-        CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
-    };
-    context->SetAction(env, info, input, exec, output);
-
-    CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
-    return ASYNC_CALL(env, context);
-}
-
 napi_value RdbStoreProxy::Replace(napi_env env, napi_callback_info info)
 {
     auto context = std::make_shared<RdbStoreContext>();
@@ -922,11 +925,13 @@ napi_value RdbStoreProxy::Replace(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParserThis(env, self, context));
         CHECK_RETURN(OK == ParseTableName(env, argv[0], context));
         CHECK_RETURN(OK == ParseValuesBucket(env, argv[1], context));
+        CHECK_RETURN_SET_E(!HasDuplicateAssets(context->valuesBucket),
+            std::make_shared<ParamError>("Duplicate assets are not allowed"));
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->Replace(context->int64Output, context->tableName, context->valuesBucket);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->Replace(context->int64Output, context->tableName, context->valuesBucket);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_create_int64(env, context->int64Output, &result);
@@ -947,9 +952,9 @@ napi_value RdbStoreProxy::Backup(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParseTableName(env, argv[0], context));
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->Backup(context->tableName, context->newKey);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->Backup(context->tableName, context->newKey);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
@@ -961,7 +966,7 @@ napi_value RdbStoreProxy::Backup(napi_env env, napi_callback_info info)
     return ASYNC_CALL(env, context);
 }
 
-struct AttachContext : public ContextBase {
+struct AttachContext : public RdbStoreContextBase {
     ContextParam param;
     RdbConfig config;
     std::string attachName;
@@ -1006,10 +1011,10 @@ napi_value RdbStoreProxy::Attach(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        auto res = obj->GetInstance()->Attach(
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto res = context->rdbStore->Attach(
             GetRdbStoreConfig(context->config, context->param), context->attachName, context->waitTime);
+        context->rdbStore = nullptr;
         context->attachedNum = res.second;
         return res.first;
     };
@@ -1025,7 +1030,7 @@ napi_value RdbStoreProxy::Attach(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::Detach(napi_env env, napi_callback_info info)
 {
-    struct DetachContext : public ContextBase {
+    struct DetachContext : public RdbStoreContextBase {
         std::string attachName;
         int32_t waitTime;
         int32_t attachedNum;
@@ -1047,9 +1052,9 @@ napi_value RdbStoreProxy::Detach(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        auto res = obj->GetInstance()->Detach(context->attachName, context->waitTime);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto res = context->rdbStore->Detach(context->attachName, context->waitTime);
+        context->rdbStore = nullptr;
         context->attachedNum = res.second;
         return res.first;
     };
@@ -1068,8 +1073,8 @@ napi_value RdbStoreProxy::IsReadOnly(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
-    RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr && rdbStoreProxy->GetInstance() != nullptr,
+        std::make_shared<ParamError>("RdbStore", "valid"));
     bool out = rdbStoreProxy->GetInstance()->IsReadOnly();
     LOG_DEBUG("RdbStoreProxy::IsReadOnly out is : %{public}d", out);
     return JSUtils::Convert2JSValue(env, out);
@@ -1080,8 +1085,8 @@ napi_value RdbStoreProxy::IsMemoryRdb(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
-    RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr && rdbStoreProxy->GetInstance() != nullptr,
+        std::make_shared<ParamError>("RdbStore", "valid"));
     bool out = rdbStoreProxy->GetInstance()->IsMemoryRdb();
     LOG_DEBUG("RdbStoreProxy::IsMemoryRdb out is : %{public}d", out);
     return JSUtils::Convert2JSValue(env, out);
@@ -1121,11 +1126,11 @@ napi_value RdbStoreProxy::BeginTrans(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParserThis(env, self, context));
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
         LOG_DEBUG("RdbStoreProxy::BeginTrans start");
         auto status = E_ERROR;
-        std::tie(status, context->intOutput) = obj->GetInstance()->BeginTrans();
+        std::tie(status, context->intOutput) = context->rdbStore->BeginTrans();
+        context->rdbStore = nullptr;
         return status;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -1163,10 +1168,10 @@ napi_value RdbStoreProxy::RollBackByTxId(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::roll back by txId start async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->RollBack(context->txId);
+        LOG_DEBUG("RdbStoreProxy::roll back by txId start async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->RollBack(context->txId);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
@@ -1186,28 +1191,23 @@ napi_value RdbStoreProxy::Commit(napi_env env, napi_callback_info info)
     napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisObj, nullptr);
     RDB_NAPI_ASSERT(
         env, status == napi_ok && (argc == 0 || argc == 1), std::make_shared<ParamError>("parameter", "1 to 2"));
-    RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
-    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
-    RDB_NAPI_ASSERT(
-        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
+    auto context = std::make_shared<RdbStoreContext>();
+    RDB_NAPI_ASSERT(env, OK == ParserThis(env, thisObj, context), context->error);
     if (argc == 0) {
-        int errCode = rdbStoreProxy->GetInstance()->Commit();
+        int errCode = context->rdbStore->Commit();
         NAPI_ASSERT(env, errCode == E_OK, "call Commit failed");
-        LOG_DEBUG("RdbStoreProxy::Commit end, errCode is:%{public}d", errCode);
+        LOG_DEBUG("RdbStoreProxy::Commit end, errCode is:%{public}d.", errCode);
         return nullptr;
     }
 
-    auto context = std::make_shared<RdbStoreContext>();
-    context->boundObj = rdbStoreProxy;
-
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN(OK == ParseTxId(env, argv[0], context));
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::commit by txId start async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->Commit(context->txId);
+        LOG_DEBUG("RdbStoreProxy::commit by txId start async.");
+        CHECK_RETURN_ERR(context != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->Commit(context->txId);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
@@ -1240,11 +1240,10 @@ napi_value RdbStoreProxy::QueryByStep(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        context->resultSet = context->isQuerySql
-                                 ? obj->GetInstance()->QueryByStep(context->sql, context->bindArgs)
-                                 : obj->GetInstance()->QueryByStep(*(context->rdbPredicates), context->columns);
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        context->resultSet = context->isQuerySql ? rdbStore->QueryByStep(context->sql, context->bindArgs)
+                                                 : rdbStore->QueryByStep(*(context->rdbPredicates), context->columns);
         return (context->resultSet != nullptr) ? E_OK : E_ERROR;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -1261,8 +1260,9 @@ napi_value RdbStoreProxy::IsInTransaction(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
     RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     bool out = rdbStoreProxy->GetInstance()->IsInTransaction();
     LOG_DEBUG("RdbStoreProxy::IsInTransaction out is : %{public}d", out);
     return JSUtils::Convert2JSValue(env, out);
@@ -1273,8 +1273,9 @@ napi_value RdbStoreProxy::IsOpen(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
     RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     bool out = rdbStoreProxy->GetInstance()->IsOpen();
     LOG_DEBUG("RdbStoreProxy::IsOpen out is : %{public}d", out);
     return JSUtils::Convert2JSValue(env, out);
@@ -1285,8 +1286,9 @@ napi_value RdbStoreProxy::GetVersion(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
     RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     int32_t version = 0;
     int out = rdbStoreProxy->GetInstance()->GetVersion(version);
     RDB_NAPI_ASSERT(env, out == E_OK, std::make_shared<InnerError>(out));
@@ -1299,8 +1301,9 @@ napi_value RdbStoreProxy::GetRebuilt(napi_env env, napi_callback_info info)
     napi_value thisObj = nullptr;
     napi_get_cb_info(env, info, nullptr, nullptr, &thisObj, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thisObj);
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
     RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     auto rebuilt = RebuiltType::NONE;
     rdbStoreProxy->GetInstance()->GetRebuilt(rebuilt);
     return JSUtils::Convert2JSValue(env, (uint32_t)rebuilt);
@@ -1313,8 +1316,9 @@ napi_value RdbStoreProxy::SetVersion(napi_env env, napi_callback_info info)
     napi_value args[1] = { 0 };
     napi_get_cb_info(env, info, &argc, args, &thiz, nullptr);
     RdbStoreProxy *rdbStoreProxy = GetNativeInstance(env, thiz);
+    RDB_NAPI_ASSERT(env, rdbStoreProxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
     RDB_NAPI_ASSERT(
-        env, rdbStoreProxy && rdbStoreProxy->GetInstance(), std::make_shared<ParamError>("RdbStore", "valid"));
+        env, rdbStoreProxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     int32_t version = 0;
     napi_get_value_int32(env, args[0], &version);
     RDB_NAPI_ASSERT(env, version > 0, std::make_shared<ParamError>("version", "> 0"));
@@ -1326,23 +1330,25 @@ napi_value RdbStoreProxy::SetVersion(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::Restore(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Restore start");
+    LOG_DEBUG("RdbStoreProxy::Restore start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
-        CHECK_RETURN_SET_E(argc == 1, std::make_shared<ParamNumError>("1 or 2"));
+        CHECK_RETURN_SET_E(argc == 0 || argc == 1, std::make_shared<ParamNumError>("0 to 2"));
         CHECK_RETURN(OK == ParserThis(env, self, context));
-        CHECK_RETURN(OK == ParseSrcName(env, argv[0], context));
+        if (argc == 1) {
+            CHECK_RETURN(OK == ParseSrcName(env, argv[0], context));
+        }
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::Restore Async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->Restore(context->srcName, context->newKey);
+        LOG_DEBUG("RdbStoreProxy::Restore Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->Restore(context->srcName, context->newKey);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
         CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("RdbStoreProxy::Restore end");
+        LOG_DEBUG("RdbStoreProxy::Restore end.");
     };
     context->SetAction(env, info, input, exec, output);
 
@@ -1353,7 +1359,7 @@ napi_value RdbStoreProxy::Restore(napi_env env, napi_callback_info info)
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::SetDistributedTables start");
+    LOG_DEBUG("RdbStoreProxy::SetDistributedTables start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(1 <= argc && argc <= 3, std::make_shared<ParamNumError>("1 - 4"));
@@ -1363,16 +1369,16 @@ napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info
         CHECK_RETURN(OK == ParseDistributedConfigArg(env, argc, argv, context));
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::SetDistributedTables Async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->SetDistributedTables(
+        LOG_DEBUG("RdbStoreProxy::SetDistributedTables Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->SetDistributedTables(
             context->tablesNames, context->distributedType, context->distributedConfig);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
         CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("RdbStoreProxy::SetDistributedTables end");
+        LOG_DEBUG("RdbStoreProxy::SetDistributedTables end.");
     };
     context->SetAction(env, info, input, exec, output);
 
@@ -1382,7 +1388,7 @@ napi_value RdbStoreProxy::SetDistributedTables(napi_env env, napi_callback_info
 
 napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName start");
+    LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc == 2, std::make_shared<ParamNumError>("2 or 3"));
@@ -1391,19 +1397,19 @@ napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback
         CHECK_RETURN(OK == ParseTableName(env, argv[1], context));
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName Async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
+        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
         int errCode = E_ERROR;
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
         context->tableName =
-            obj->GetInstance()->ObtainDistributedTableName(context->device, context->tableName, errCode);
+            context->rdbStore->ObtainDistributedTableName(context->device, context->tableName, errCode);
+        context->rdbStore = nullptr;
         return errCode;
     };
     auto output = [context](napi_env env, napi_value &result) {
         std::string table = context->tableName;
         napi_status status = napi_create_string_utf8(env, table.c_str(), table.length(), &result);
         CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName end");
+        LOG_DEBUG("RdbStoreProxy::ObtainDistributedTableName end.");
     };
     context->SetAction(env, info, input, exec, output);
 
@@ -1413,7 +1419,6 @@ napi_value RdbStoreProxy::ObtainDistributedTableName(napi_env env, napi_callback
 
 napi_value RdbStoreProxy::Sync(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Sync start");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc == 2, std::make_shared<ParamNumError>("2 or 3"));
@@ -1421,26 +1426,52 @@ napi_value RdbStoreProxy::Sync(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParseSyncModeArg(env, argv[0], context));
         CHECK_RETURN(OK == ParsePredicates(env, argv[1], context));
     };
-    auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::Sync Async");
-        auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        SyncOption option;
-        option.mode = static_cast<DistributedRdb::SyncMode>(context->enumArg);
-        option.isBlock = true;
-        CHECK_RETURN_ERR(context->predicatesProxy != nullptr && context->predicatesProxy->GetPredicates() != nullptr);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->Sync(option, *context->predicatesProxy->GetPredicates(),
-            [context](const SyncResult &result) { context->syncResult = result; });
-    };
-    auto output = [context](napi_env env, napi_value &result) {
-        result = JSUtils::Convert2JSValue(env, context->syncResult);
-        CHECK_RETURN_SET_E(result != nullptr, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("RdbStoreProxy::Sync end");
+    context->SetAction(env, info, std::move(input), nullptr, nullptr);
+    CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
+    RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
+    auto queue = obj->queue_;
+    napi_value promise = nullptr;
+    auto defer = context->defer_;
+    auto callback = context->callback_;
+    context->callback_ = nullptr;
+    if (callback == nullptr) {
+        napi_status status = napi_create_promise(env, &defer, &promise);
+        RDB_NAPI_ASSERT_BASE(env, status == napi_ok,
+            std::make_shared<InnerError>("failed(" + std::to_string(status) + ") to create promise"), nullptr);
+    } else {
+        napi_get_undefined(env, &promise);
+    }
+    auto predicates = *context->predicatesProxy->GetPredicates();
+    auto exec = [queue, defer, callback, predicates, rdbStore = std::move(context->rdbStore),
+                    enumArg = context->enumArg]() mutable {
+        SyncOption option{ static_cast<DistributedRdb::SyncMode>(enumArg), false };
+        auto ret = rdbStore->Sync(option, predicates, [queue, defer, callback](const SyncResult &result) {
+            auto args = [result](napi_env env, int &argc, napi_value *argv) {
+                argv[1] = JSUtils::Convert2JSValue(env, result);
+            };
+            callback ? queue->AsyncCall({ callback }, args) : queue->AsyncPromise({ defer }, args);
+        });
+        if (ret != NativeRdb::E_OK) {
+            auto args = [ret](napi_env env, int &argc, napi_value *argv) mutable {
+                SetBusinessError(env, std::make_shared<InnerError>(ret), &argv[0]);
+            };
+            callback ? queue->AsyncCall({ callback }, args) : queue->AsyncPromise({ defer }, args);
+        }
     };
-    context->SetAction(env, info, input, exec, output);
+    queue->Execute(std::move(exec));
+    context = nullptr;
+    return promise;
+}
 
-    CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
-    return ASYNC_CALL(env, context);
+void RdbStoreProxy::SetBusinessError(napi_env env, std::shared_ptr<Error> error, napi_value *businessError)
+{
+    if (error != nullptr) {
+        napi_value code = nullptr;
+        napi_value msg = nullptr;
+        napi_create_int32(env, error->GetCode(), &code);
+        napi_create_string_utf8(env, error->GetMessage().c_str(), NAPI_AUTO_LENGTH, &msg);
+        napi_create_error(env, code, msg, businessError);
+    }
 }
 
 InputAction GetCloudSyncInput(std::shared_ptr<RdbStoreContext> context)
@@ -1475,16 +1506,17 @@ InputAction GetCloudSyncInput(std::shared_ptr<RdbStoreContext> context)
 
 napi_value RdbStoreProxy::CloudSync(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::CloudSync start");
+    LOG_DEBUG("RdbStoreProxy::CloudSync start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = GetCloudSyncInput(context);
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::CloudSync Async");
+        LOG_DEBUG("RdbStoreProxy::CloudSync Async.");
         auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
         SyncOption option;
         option.mode = static_cast<DistributedRdb::SyncMode>(context->syncMode);
         option.isBlock = false;
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
+        CHECK_RETURN_ERR(obj != nullptr && context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
         auto async = [queue = obj->queue_, callback = context->asyncHolder](const Details &details) {
             if (queue == nullptr || callback == nullptr) {
                 return;
@@ -1496,14 +1528,14 @@ napi_value RdbStoreProxy::CloudSync(napi_env env, napi_callback_info info)
             });
         };
         if (context->rdbPredicates == nullptr) {
-            context->execCode_ = obj->GetInstance()->Sync(option, context->tablesNames, async);
+            context->execCode_ = rdbStore->Sync(option, context->tablesNames, async);
         } else {
-            context->execCode_ = obj->GetInstance()->Sync(option, *(context->rdbPredicates), async);
+            context->execCode_ = rdbStore->Sync(option, *(context->rdbPredicates), async);
         }
         return OK;
     };
     auto output = [context](napi_env env, napi_value &result) {
-        LOG_DEBUG("RdbStoreProxy::CloudSync output");
+        LOG_DEBUG("RdbStoreProxy::CloudSync output.");
         if (context->execCode_ != E_OK && context->asyncHolder != nullptr) {
             napi_delete_reference(env, context->asyncHolder);
         }
@@ -1517,7 +1549,7 @@ napi_value RdbStoreProxy::CloudSync(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::GetModifyTime(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::GetModifyTime start");
+    LOG_DEBUG("RdbStoreProxy::GetModifyTime start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc == 3, std::make_shared<ParamNumError>("3 - 4"));
@@ -1527,14 +1559,14 @@ napi_value RdbStoreProxy::GetModifyTime(napi_env env, napi_callback_info info)
         CHECK_RETURN(OK == ParsePrimaryKey(env, argv[2], context));
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::GetModifyTime Async");
-        auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        context->modifyTime = obj->GetInstance()->GetModifyTime(context->tableName, context->columnName, context->keys);
+        LOG_DEBUG("RdbStoreProxy::GetModifyTime Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        context->modifyTime = context->rdbStore->GetModifyTime(context->tableName, context->columnName, context->keys);
+        context->rdbStore = nullptr;
         return context->modifyTime.empty() ? E_ERROR : E_OK;
     };
     auto output = [context](napi_env env, napi_value &result) {
-        LOG_DEBUG("RdbStoreProxy::GetModifyTime output");
+        LOG_DEBUG("RdbStoreProxy::GetModifyTime output.");
         result = JSUtils::Convert2JSValue(env, context->modifyTime);
         CHECK_RETURN_SET_E(result != nullptr, std::make_shared<InnerError>(E_ERROR));
     };
@@ -1546,7 +1578,7 @@ napi_value RdbStoreProxy::GetModifyTime(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::CleanDirtyData(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::Clean start");
+    LOG_DEBUG("RdbStoreProxy::Clean start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc >= 1, std::make_shared<ParamNumError>("1 - 3"));
@@ -1557,10 +1589,10 @@ napi_value RdbStoreProxy::CleanDirtyData(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::CleanDirtyData Async");
-        auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        return obj->GetInstance()->CleanDirtyData(context->tableName, context->cursor);
+        LOG_DEBUG("RdbStoreProxy::CleanDirtyData Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->CleanDirtyData(context->tableName, context->cursor);
     };
 
     auto output = [context](napi_env env, napi_value &result) {
@@ -1584,11 +1616,10 @@ napi_value RdbStoreProxy::OnRemote(napi_env env, size_t argc, napi_value *argv)
     napi_typeof(env, argv[1], &type);
     RDB_NAPI_ASSERT(env, type == napi_function, std::make_shared<ParamError>("observer", "function"));
 
-    bool result = std::any_of(observers_[mode].begin(), observers_[mode].end(), [argv](const auto &observer) {
-        return *observer == argv[1];
-    });
+    bool result = std::any_of(observers_[mode].begin(), observers_[mode].end(),
+        [argv](const auto &observer) { return *observer == argv[1]; });
     if (result) {
-        LOG_INFO("duplicate subscribe");
+        LOG_INFO("duplicate subscribe.");
         return nullptr;
     }
     SubscribeOption option;
@@ -1604,7 +1635,7 @@ napi_value RdbStoreProxy::OnRemote(napi_env env, size_t argc, napi_value *argv)
     }
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
     observers_[mode].push_back(observer);
-    LOG_INFO("subscribe success");
+    LOG_INFO("subscribe success.");
     return nullptr;
 }
 
@@ -1613,9 +1644,8 @@ napi_value RdbStoreProxy::RegisteredObserver(napi_env env, const DistributedRdb:
 {
     observers.try_emplace(option.event);
     auto &list = observers.find(option.event)->second;
-    bool result = std::any_of(list.begin(), list.end(), [callback](const auto &observer) {
-        return *observer == callback;
-    });
+    bool result =
+        std::any_of(list.begin(), list.end(), [callback](const auto &observer) { return *observer == callback; });
     if (result) {
         LOG_INFO("duplicate subscribe event: %{public}s", option.event.c_str());
         return nullptr;
@@ -1649,7 +1679,7 @@ napi_value RdbStoreProxy::OffRemote(napi_env env, size_t argc, napi_value *argv)
     bool valid = (mode >= 0 && mode < SubscribeMode::SUBSCRIBE_MODE_MAX);
     RDB_NAPI_ASSERT(env, valid, std::make_shared<ParamError>("type", "SubscribeType"));
 
-    bool isNotNull = argc >=2 && !JSUtils::IsNull(env, argv[1]);
+    bool isNotNull = argc >= 2 && !JSUtils::IsNull(env, argv[1]);
     if (isNotNull) {
         napi_typeof(env, argv[1], &type);
         RDB_NAPI_ASSERT(env, type == napi_function, std::make_shared<ParamError>("observer", "function"));
@@ -1809,8 +1839,7 @@ napi_value RdbStoreProxy::Notify(napi_env env, napi_callback_info info)
     RDB_NAPI_ASSERT(env, status == napi_ok && argc == 1, std::make_shared<ParamNumError>("1"));
     auto *proxy = GetNativeInstance(env, self);
     RDB_NAPI_ASSERT(env, proxy != nullptr, std::make_shared<ParamError>("RdbStore", "valid"));
-    RDB_NAPI_ASSERT(
-        env, proxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
+    RDB_NAPI_ASSERT(env, proxy->GetInstance() != nullptr, std::make_shared<InnerError>(NativeRdb::E_ALREADY_CLOSED));
     int errCode = proxy->GetInstance()->Notify(JSUtils::Convert2String(env, argv[0]));
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
     return nullptr;
@@ -1818,7 +1847,7 @@ napi_value RdbStoreProxy::Notify(napi_env env, napi_callback_info info)
 
 napi_value RdbStoreProxy::QuerySharingResource(napi_env env, napi_callback_info info)
 {
-    LOG_DEBUG("RdbStoreProxy::QuerySharingResource start");
+    LOG_DEBUG("RdbStoreProxy::QuerySharingResource start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc > 0 && argc < 4, std::make_shared<ParamNumError>("1 to 3"));
@@ -1831,12 +1860,12 @@ napi_value RdbStoreProxy::QuerySharingResource(napi_env env, napi_callback_info
         CHECK_RETURN_SET_E(obj != nullptr && obj->IsSystemAppCalled(), std::make_shared<NonSystemError>());
     };
     auto exec = [context]() -> int {
-        LOG_DEBUG("RdbStoreProxy::QuerySharingResource Async");
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
+        LOG_DEBUG("RdbStoreProxy::QuerySharingResource Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
         auto status = E_ERROR;
         std::tie(status, context->resultSet) =
-            obj->GetInstance()->QuerySharingResource(*(context->rdbPredicates), context->columns);
+            context->rdbStore->QuerySharingResource(*(context->rdbPredicates), context->columns);
+        context->rdbStore = nullptr;
         LOG_DEBUG("RdbStoreProxy::QuerySharingResource resultSet is nullptr:%{public}d, status:%{public}d",
             context->resultSet == nullptr, status);
         return (status == E_OK && context->resultSet != nullptr) ? E_OK : E_ERROR;
@@ -1844,7 +1873,7 @@ napi_value RdbStoreProxy::QuerySharingResource(napi_env env, napi_callback_info
     auto output = [context](napi_env env, napi_value &result) {
         result = ResultSetProxy::NewInstance(env, context->resultSet);
         CHECK_RETURN_SET_E(result != nullptr, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("RdbStoreProxy::QuerySharingResource end");
+        LOG_DEBUG("RdbStoreProxy::QuerySharingResource end.");
     };
     context->SetAction(env, info, input, exec, output);
 
@@ -1857,18 +1886,17 @@ napi_value RdbStoreProxy::RegisterSyncCallback(napi_env env, size_t argc, napi_v
     napi_valuetype type = napi_undefined;
     napi_typeof(env, argv[0], &type);
     RDB_NAPI_ASSERT(env, type == napi_function, std::make_shared<ParamError>("progress", "function"));
-    bool result = std::any_of(syncObservers_.begin(), syncObservers_.end(), [argv](const auto &observer) {
-        return *observer == argv[0];
-    });
+    bool result = std::any_of(
+        syncObservers_.begin(), syncObservers_.end(), [argv](const auto &observer) { return *observer == argv[0]; });
     if (result) {
-        LOG_DEBUG("duplicate subscribe");
+        LOG_DEBUG("duplicate subscribe.");
         return nullptr;
     }
     auto observer = std::make_shared<SyncObserver>(env, argv[0], queue_);
     int errCode = GetInstance()->RegisterAutoSyncCallback(observer);
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
     syncObservers_.push_back(std::move(observer));
-    LOG_INFO("progress subscribe success");
+    LOG_INFO("progress subscribe success.");
     return nullptr;
 }
 
@@ -1895,7 +1923,7 @@ napi_value RdbStoreProxy::UnregisterSyncCallback(napi_env env, size_t argc, napi
         RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
         (*it)->Clear();
         it = syncObservers_.erase(it);
-        LOG_DEBUG("observer unsubscribe success");
+        LOG_DEBUG("observer unsubscribe success.");
     }
     return nullptr;
 }
@@ -1908,14 +1936,14 @@ napi_value RdbStoreProxy::OnStatistics(napi_env env, size_t argc, napi_value *ar
     bool result = std::any_of(statisticses_.begin(), statisticses_.end(),
         [argv](std::shared_ptr<NapiStatisticsObserver> obs) { return obs && *obs == argv[0]; });
     if (result) {
-        LOG_DEBUG("duplicate subscribe");
+        LOG_DEBUG("duplicate subscribe.");
         return nullptr;
     }
     auto observer = std::make_shared<NapiStatisticsObserver>(env, argv[0], queue_);
     int errCode = DistributedRdb::SqlStatistic::Subscribe(observer);
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
     statisticses_.push_back(std::move(observer));
-    LOG_DEBUG("statistics subscribe success");
+    LOG_DEBUG("statistics subscribe success.");
     return nullptr;
 }
 
@@ -2028,7 +2056,7 @@ void RdbStoreProxy::SyncObserver::ProgressNotification(const Details &details)
 
 napi_value RdbStoreProxy::ModifyLockStatus(napi_env env, napi_callback_info info, bool isLock)
 {
-    LOG_DEBUG("start");
+    LOG_DEBUG("start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN_SET_E(argc >= 1, std::make_shared<ParamNumError>("1"));
@@ -2036,16 +2064,15 @@ napi_value RdbStoreProxy::ModifyLockStatus(napi_env env, napi_callback_info info
         CHECK_RETURN(OK == ParsePredicates(env, argv[0], context));
     };
     auto exec = [context, isLock]() -> int {
-        LOG_DEBUG("Async");
-        auto *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
-        return obj->GetInstance()->ModifyLockStatus(*(context->rdbPredicates), isLock);
+        LOG_DEBUG("Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->ModifyLockStatus(*(context->rdbPredicates), isLock);
     };
     auto output = [context](napi_env env, napi_value &result) {
         napi_status status = napi_get_undefined(env, &result);
         CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
-        LOG_DEBUG("end");
+        LOG_DEBUG("end.");
     };
     context->SetAction(env, info, input, exec, output);
 
@@ -2075,13 +2102,11 @@ napi_value RdbStoreProxy::QueryLockedRow(napi_env env, napi_callback_info info)
         }
     };
     auto exec = [context]() -> int {
-        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
-        CHECK_RETURN_ERR(context->rdbPredicates != nullptr);
-
+        CHECK_RETURN_ERR(context->rdbStore != nullptr && context->rdbPredicates != nullptr);
         context->rdbPredicates->BeginWrap()->EqualTo(AbsRdbPredicates::LOCK_STATUS, AbsRdbPredicates::LOCKED)->Or();
         context->rdbPredicates->EqualTo(AbsRdbPredicates::LOCK_STATUS, AbsRdbPredicates::LOCK_CHANGED)->EndWrap();
-        context->resultSet = obj->GetInstance()->QueryByStep(*(context->rdbPredicates), context->columns);
+        context->resultSet = context->rdbStore->QueryByStep(*(context->rdbPredicates), context->columns);
+        context->rdbStore = nullptr;
         return (context->resultSet != nullptr) ? E_OK : E_ERROR;
     };
     auto output = [context](napi_env env, napi_value &result) {
@@ -2093,18 +2118,72 @@ napi_value RdbStoreProxy::QueryLockedRow(napi_env env, napi_callback_info info)
     CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
     return ASYNC_CALL(env, context);
 }
-#endif
 
-napi_value RdbStoreProxy::Close(napi_env env, napi_callback_info info)
+napi_value RdbStoreProxy::LockCloudContainer(napi_env env, napi_callback_info info)
 {
+    LOG_DEBUG("RdbStoreProxy::LockCloudContainer start.");
     auto context = std::make_shared<RdbStoreContext>();
     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
         CHECK_RETURN(OK == ParserThis(env, self, context));
+        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
+        CHECK_RETURN_SET_E(obj != nullptr && obj->IsSystemAppCalled(), std::make_shared<NonSystemError>());
     };
+
     auto exec = [context]() -> int {
+        LOG_DEBUG("RdbStoreProxy::LockCloudContainer Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        auto result = rdbStore->LockCloudContainer();
+        context->expiredTime = result.second;
+        return result.first;
+    };
+
+    auto output = [context](napi_env env, napi_value &res) {
+        auto status = napi_create_uint32(env, context->expiredTime, &res);
+        CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
+    };
+    context->SetAction(env, info, input, exec, output);
+
+    CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
+    return ASYNC_CALL(env, context);
+}
+
+napi_value RdbStoreProxy::UnlockCloudContainer(napi_env env, napi_callback_info info)
+{
+    LOG_DEBUG("RdbStoreProxy::UnlockCloudContainer start.");
+    auto context = std::make_shared<RdbStoreContext>();
+    auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
+        CHECK_RETURN(OK == ParserThis(env, self, context));
+        RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
+        CHECK_RETURN_SET_E(obj != nullptr && obj->IsSystemAppCalled(), std::make_shared<NonSystemError>());
+    };
+    auto exec = [context]() {
+        LOG_DEBUG("RdbStoreProxy::UnlockCloudContainer Async.");
+        CHECK_RETURN_ERR(context->rdbStore != nullptr);
+        auto rdbStore = std::move(context->rdbStore);
+        return rdbStore->UnlockCloudContainer();
+    };
+    auto output = [context](napi_env env, napi_value &result) {
+        auto status = napi_get_undefined(env, &result);
+        CHECK_RETURN_SET_E(status == napi_ok, std::make_shared<InnerError>(E_ERROR));
+    };
+    context->SetAction(env, info, input, exec, output);
+
+    CHECK_RETURN_NULL(context->error == nullptr || context->error->GetCode() == OK);
+    return ASYNC_CALL(env, context);
+}
+#endif
+
+napi_value RdbStoreProxy::Close(napi_env env, napi_callback_info info)
+{
+    auto context = std::make_shared<RdbStoreContext>();
+    auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) {
+        CHECK_RETURN(OK == ParserThis(env, self, context));
         RdbStoreProxy *obj = reinterpret_cast<RdbStoreProxy *>(context->boundObj);
-        CHECK_RETURN_ERR(obj != nullptr && obj->GetInstance() != nullptr);
         obj->SetInstance(nullptr);
+    };
+    auto exec = [context]() -> int {
+        context->rdbStore = nullptr;
         return OK;
     };
     auto output = [context](napi_env env, napi_value &result) {
diff --git a/relational_store/frameworks/js/napi/relationalstore/src/napi_result_set.cpp b/relational_store/frameworks/js/napi/relationalstore/src/napi_result_set.cpp
index ef692ce4999199273b504deb4057ba3a18e50356..9cbb6f1add31285455e4e44ac8513b86cd322231 100644
--- a/relational_store/frameworks/js/napi/relationalstore/src/napi_result_set.cpp
+++ b/relational_store/frameworks/js/napi/relationalstore/src/napi_result_set.cpp
@@ -20,8 +20,9 @@
 #include "js_utils.h"
 #include "logger.h"
 #include "napi_rdb_error.h"
+#include "napi_rdb_js_utils.h"
+#include "napi_rdb_sendable_utils.h"
 #include "napi_rdb_trace.h"
-
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 #include "rdb_result_set_bridge.h"
 #include "string_ex.h"
@@ -67,7 +68,7 @@ std::shared_ptr<DataShare::ResultSetBridge> ResultSetProxy::Create()
 {
     auto instance = GetInstance();
     if (instance == nullptr) {
-        LOG_ERROR("resultSet is null");
+        LOG_ERROR("resultSet is null.");
         return nullptr;
     }
     SetInstance(nullptr);
@@ -81,7 +82,7 @@ napi_value ResultSetProxy::Initialize(napi_env env, napi_callback_info info)
     NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
     auto *proxy = new (std::nothrow) ResultSetProxy();
     if (proxy == nullptr) {
-        LOG_ERROR("ResultSetProxy::Initialize new failed, proxy is nullptr");
+        LOG_ERROR("ResultSetProxy::Initialize new failed, proxy is nullptr.");
         return nullptr;
     }
     auto finalize = [](napi_env env, void *data, void *hint) {
@@ -431,7 +432,7 @@ napi_value ResultSetProxy::GetAsset(napi_env env, napi_callback_info info)
     Asset result;
     int errCode = resultSetProxy->GetInstance()->GetAsset(columnIndex, result);
     if (errCode == E_NULL_OBJECT) {
-        LOG_DEBUG("getAsset col %{public}d is null ", columnIndex);
+        LOG_DEBUG("getAsset col %{public}d is null.", columnIndex);
         return JSUtils::Convert2JSValue(env, std::monostate());
     }
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
@@ -449,7 +450,7 @@ napi_value ResultSetProxy::GetAssets(napi_env env, napi_callback_info info)
     Assets result;
     int errCode = resultSetProxy->GetInstance()->GetAssets(columnIndex, result);
     if (errCode == E_NULL_OBJECT) {
-        LOG_DEBUG("getAssets col %{public}d is null ", columnIndex);
+        LOG_DEBUG("getAssets col %{public}d is null.", columnIndex);
         return JSUtils::Convert2JSValue(env, std::monostate());
     }
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
@@ -467,7 +468,7 @@ napi_value ResultSetProxy::GetFloat32Array(napi_env env, napi_callback_info info
     FloatVector result = {};
     int errCode = resultSetProxy->GetInstance()->GetFloat32Array(columnIndex, result);
     if (errCode == E_NULL_OBJECT) {
-        LOG_DEBUG("GetFloat32Array col %{public}d is null ", columnIndex);
+        LOG_DEBUG("GetFloat32Array col %{public}d is null.", columnIndex);
         return JSUtils::Convert2JSValue(env, std::monostate());
     }
     RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
@@ -556,6 +557,18 @@ napi_value ResultSetProxy::GetRow(napi_env env, napi_callback_info info)
     return JSUtils::Convert2JSValue(env, rowEntity);
 }
 
+napi_value ResultSetProxy::GetSendableRow(napi_env env, napi_callback_info info)
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
+    ResultSetProxy *resultSetProxy = GetInnerResultSet(env, info);
+    CHECK_RETURN_NULL(resultSetProxy && resultSetProxy->GetInstance());
+
+    RowEntity rowEntity;
+    int errCode = resultSetProxy->GetInstance()->GetRow(rowEntity);
+    RDB_NAPI_ASSERT(env, errCode == E_OK, std::make_shared<InnerError>(errCode));
+    return JSUtils::Convert2Sendable(env, rowEntity);
+}
+
 napi_value ResultSetProxy::GetValue(napi_env env, napi_callback_info info)
 {
     DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
@@ -604,6 +617,7 @@ void ResultSetProxy::Init(napi_env env, napi_value exports)
             DECLARE_NAPI_FUNCTION("isColumnNull", IsColumnNull),
             DECLARE_NAPI_FUNCTION("getValue", GetValue),
             DECLARE_NAPI_FUNCTION("getRow", GetRow),
+            DECLARE_NAPI_FUNCTION("getSendableRow", GetSendableRow),
 
             DECLARE_NAPI_GETTER("columnNames", GetAllColumnNames),
             DECLARE_NAPI_GETTER("columnCount", GetColumnCount),
@@ -621,7 +635,7 @@ void ResultSetProxy::Init(napi_env env, napi_value exports)
     auto jsCtor = JSUtils::DefineClass(env, "ohos.data.relationalStore", "ResultSet", lambda, Initialize);
     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "ResultSet", jsCtor));
 
-    LOG_DEBUG("ResultSetProxy::Init end");
+    LOG_DEBUG("ResultSetProxy::Init end.");
 }
 } // namespace RelationalStoreJsKit
 } // namespace OHOS
diff --git a/relational_store/frameworks/js/napi/sendablerelationalstore/BUILD.gn b/relational_store/frameworks/js/napi/sendablerelationalstore/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..9742fe000886c4ada1ad41e7813316c36d3d4989
--- /dev/null
+++ b/relational_store/frameworks/js/napi/sendablerelationalstore/BUILD.gn
@@ -0,0 +1,60 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/ohos.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+ohos_copy("relational_store_declaration") {
+  sources = [ "./api" ]
+  outputs = [ target_out_dir + "/$target_name/" ]
+  module_source_dir = target_out_dir + "/$target_name"
+  module_install_name = ""
+  subsystem_name = "distributeddatamgr"
+  part_name = "relational_store"
+}
+
+ohos_shared_library("sendablerelationalstore") {
+  include_dirs = [
+    "${relational_store_common_path}/include",
+    "${relational_store_js_common_path}/include",
+    "${relational_store_napi_path}/relationalstore/include",
+    "include",
+  ]
+
+  sources = [
+    "${relational_store_js_common_path}/src/js_ability.cpp",
+    "${relational_store_js_common_path}/src/js_sendable_utils.cpp",
+    "${relational_store_js_common_path}/src/js_utils.cpp",
+    "${relational_store_napi_path}/relationalstore/src/napi_rdb_error.cpp",
+    "${relational_store_napi_path}/relationalstore/src/napi_rdb_js_utils.cpp",
+    "${relational_store_napi_path}/relationalstore/src/napi_rdb_sendable_utils.cpp",
+    "src/entry_point.cpp",
+    "src/napi_rdb_store_convert_utils.cpp",
+  ]
+
+  defines = [ "SQLITE_DISTRIBUTE_RELATIONAL" ]
+
+  deps = [ "${relational_store_innerapi_path}/rdb:native_rdb" ]
+
+  external_deps = [
+    "ability_runtime:abilitykit_native",
+    "ability_runtime:napi_base_context",
+    "bounds_checking_function:libsec_shared",
+    "hilog:libhilog",
+    "hitrace:hitrace_meter",
+    "napi:ace_napi",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "relational_store"
+  relative_install_dir = "module/data"
+}
diff --git a/relational_store/frameworks/js/napi/sendablerelationalstore/include/napi_rdb_store_convert_utils.h b/relational_store/frameworks/js/napi/sendablerelationalstore/include/napi_rdb_store_convert_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b7322696d2206a372e6c6f29ab01cb4b43363a2
--- /dev/null
+++ b/relational_store/frameworks/js/napi/sendablerelationalstore/include/napi_rdb_store_convert_utils.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RDB_JSKIT_NAPI_RDB_STORE_CONVERT_UTILS_H
+#define RDB_JSKIT_NAPI_RDB_STORE_CONVERT_UTILS_H
+
+#include "napi/native_api.h"
+#include "napi/native_common.h"
+#include "napi/native_node_api.h"
+
+namespace OHOS {
+namespace SendableRdb {
+napi_value InitRdbStoreUtils(napi_env env, napi_value info);
+} // namespace SendableRdb
+} // namespace OHOS
+
+#endif
diff --git a/relational_store/frameworks/js/napi/sendablerelationalstore/src/entry_point.cpp b/relational_store/frameworks/js/napi/sendablerelationalstore/src/entry_point.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f24ae3da80325f9cf0cb33fad81fc5ed0ab3d6ae
--- /dev/null
+++ b/relational_store/frameworks/js/napi/sendablerelationalstore/src/entry_point.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "napi_rdb_store_convert_utils.h"
+#include "napi/native_api.h"
+
+using namespace OHOS::SendableRdb;
+
+EXTERN_C_START
+/*
+ * function for module exports
+ */
+static napi_value Init(napi_env env, napi_value exports)
+{
+    InitRdbStoreUtils(env, exports);
+    return exports;
+}
+EXTERN_C_END
+
+/*
+ * Module define
+ */
+static napi_module _module = {
+    .nm_version = 1,
+    .nm_flags = 0,
+    .nm_filename = nullptr,
+    .nm_register_func = Init,
+    .nm_modname = "data.sendableRelationalStore",
+    .nm_priv = ((void *)0),
+    .reserved = { 0 }
+};
+
+/*
+ * Module register function
+ */
+static __attribute__((constructor)) void RegisterModule(void)
+{
+    napi_module_register(&_module);
+}
diff --git a/relational_store/frameworks/js/napi/sendablerelationalstore/src/napi_rdb_store_convert_utils.cpp b/relational_store/frameworks/js/napi/sendablerelationalstore/src/napi_rdb_store_convert_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8565f0ce9c41c3936a822b5a288408912c8db11a
--- /dev/null
+++ b/relational_store/frameworks/js/napi/sendablerelationalstore/src/napi_rdb_store_convert_utils.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "NapiRdbStoreConvertUtils"
+#include "napi_rdb_store_convert_utils.h"
+
+#include "js_native_api.h"
+#include "js_native_api_types.h"
+#include "js_sendable_utils.h"
+#include "js_utils.h"
+#include "logger.h"
+#include "napi_rdb_error.h"
+#include "napi_rdb_js_utils.h"
+#include "napi_rdb_sendable_utils.h"
+
+using namespace OHOS::RelationalStoreJsKit;
+using namespace OHOS::AppDataMgrJsKit::JSUtils;
+namespace OHOS {
+namespace SendableRdb {
+
+constexpr int32_t KEY_INDEX = 0;
+constexpr int32_t VALUE_INDEX = 1;
+
+napi_value FromSendableValuesBucket(napi_env env, napi_callback_info info)
+{
+    size_t argc = 1;
+    napi_value args[1] = { nullptr };
+    napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    RDB_NAPI_ASSERT(env, status == napi_ok && argc == 1, std::make_shared<ParamNumError>("1"));
+
+    bool isMap = false;
+    status = napi_is_map(env, args[0], &isMap);
+    RDB_NAPI_ASSERT(env, status == napi_ok && isMap,
+        std::make_shared<ParamError>("ValuesBucket is invalid" + std::to_string(status)));
+
+    uint32_t length = 0;
+    status = napi_map_get_size(env, args[0], &length);
+    RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_map_get_size failed."));
+    napi_value entries = nullptr;
+    status = napi_map_get_entries(env, args[0], &entries);
+    RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_map_get_entries failed."));
+    napi_value object = nullptr;
+    status = napi_create_object(env, &object);
+    for (uint32_t i = 0; i < length; ++i) {
+        napi_value iter = nullptr;
+        status = napi_map_iterator_get_next(env, entries, &iter);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_map_iterator_get_next failed."));
+        napi_value values = nullptr;
+        status = napi_get_named_property(env, iter, "value", &values);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_named_property value failed."));
+
+        napi_value key = nullptr;
+        status = napi_get_element(env, values, KEY_INDEX, &key);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_element key failed."));
+
+        napi_value value = nullptr;
+        status = napi_get_element(env, values, VALUE_INDEX, &value);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_element value failed."));
+
+        status = napi_set_property(env, object, key, Convert2JSValue(env, value));
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_set_property failed."));
+    }
+
+    return object;
+}
+
+napi_value ToSendableValuesBucket(napi_env env, napi_callback_info info)
+{
+    size_t argc = 1;
+    napi_value args[1] = { nullptr };
+    napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    RDB_NAPI_ASSERT(env, status == napi_ok && argc == 1, std::make_shared<ParamNumError>("1"));
+
+    napi_valuetype type = napi_undefined;
+    status = napi_typeof(env, args[0], &type);
+    RDB_NAPI_ASSERT(env, status == napi_ok && type == napi_object,
+        std::make_shared<ParamError>("ValuesBucket is invalid" + std::to_string(status)));
+
+    napi_value keys = nullptr;
+    napi_get_all_property_names(env, args[0], napi_key_own_only,
+        static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, &keys);
+    uint32_t length = 0;
+    status = napi_get_array_length(env, keys, &length);
+    RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_array_length failed."));
+
+    napi_value map = nullptr;
+    status = napi_create_sendable_map(env, &map);
+    RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_create_sendable_map failed."));
+    for (uint32_t i = 0; i < length; ++i) {
+        napi_value key = nullptr;
+        status = napi_get_element(env, keys, i, &key);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_element failed."));
+        napi_value value = nullptr;
+        status = napi_get_property(env, args[0], key, &value);
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_get_property failed."));
+        status = napi_map_set_property(env, map, key, Convert2Sendable(env, value));
+
+        RDB_NAPI_ASSERT(env, status == napi_ok, std::make_shared<InnerError>("napi_map_set_property failed."));
+    }
+    return map;
+}
+
+napi_value FromSendableAsset(napi_env env, napi_callback_info info)
+{
+    size_t argc = 1;
+    napi_value args[1] = { nullptr };
+    napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    RDB_NAPI_ASSERT(env, status == napi_ok && argc == 1, std::make_shared<ParamNumError>("1"));
+
+    napi_valuetype type = napi_undefined;
+    status = napi_typeof(env, args[0], &type);
+    RDB_NAPI_ASSERT(env, status == napi_ok && type == napi_object,
+        std::make_shared<ParamError>("Asset is invalid" + std::to_string(status)));
+
+    return Convert2JSValue(env, args[0]);
+}
+
+napi_value ToSendableAsset(napi_env env, napi_callback_info info)
+{
+    size_t argc = 1;
+    napi_value args[1] = { nullptr };
+    napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+    RDB_NAPI_ASSERT(env, status == napi_ok && argc == 1, std::make_shared<ParamNumError>("1"));
+
+    napi_valuetype type = napi_undefined;
+    status = napi_typeof(env, args[0], &type);
+    RDB_NAPI_ASSERT(env, status == napi_ok && type == napi_object,
+        std::make_shared<ParamError>("Asset is invalid" + std::to_string(status)));
+
+    return Convert2Sendable(env, args[0]);
+}
+
+napi_value InitRdbStoreUtils(napi_env env, napi_value exports)
+{
+    napi_property_descriptor properties[] = {
+        DECLARE_NAPI_FUNCTION("fromSendableValuesBucket", FromSendableValuesBucket),
+        DECLARE_NAPI_FUNCTION("toSendableValuesBucket", ToSendableValuesBucket),
+        DECLARE_NAPI_FUNCTION("fromSendableAsset", FromSendableAsset),
+        DECLARE_NAPI_FUNCTION("toSendableAsset", ToSendableAsset),
+    };
+    NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(*properties), properties));
+    return exports;
+}
+} // namespace SendableRdb
+} // namespace OHOS
\ No newline at end of file
diff --git a/relational_store/frameworks/native/appdatafwk/src/shared_block.cpp b/relational_store/frameworks/native/appdatafwk/src/shared_block.cpp
index 5dc020cdeee1573c8b2848fe2ab60f77685b0a55..69067bdb0fa9384a8d2cc2c05c73049041117df5 100644
--- a/relational_store/frameworks/native/appdatafwk/src/shared_block.cpp
+++ b/relational_store/frameworks/native/appdatafwk/src/shared_block.cpp
@@ -84,7 +84,7 @@ int SharedBlock::Create(const std::string &name, size_t size, SharedBlock *&outS
 
     sptr<Ashmem> ashmem = Ashmem::CreateAshmem(ashmemName.c_str(), size);
     if (ashmem == nullptr) {
-        LOG_ERROR("SharedBlock: CreateAshmem function error.");
+        LOG_ERROR("failed to create ashmem errno %{public}d", errno);
         return SHARED_BLOCK_ASHMEM_ERROR;
     }
 
@@ -159,7 +159,7 @@ int SharedBlock::Clear()
         mHeader->groupOffset[0] = sizeof(SharedBlockHeader);
         return SHARED_BLOCK_OK;
     }
-    LOG_ERROR("SharedBlock::Clear mHeader is nullptr");
+    LOG_ERROR("SharedBlock::Clear mHeader is nullptr.");
     return SHARED_BLOCK_BAD_VALUE;
 }
 
diff --git a/relational_store/frameworks/native/cloud_data/src/cloud_manager.cpp b/relational_store/frameworks/native/cloud_data/src/cloud_manager.cpp
index 37ce18a6d91aa81e7601b599431c29e99905e722..020e01062118774abced40f8e01aa79cd08a968b 100644
--- a/relational_store/frameworks/native/cloud_data/src/cloud_manager.cpp
+++ b/relational_store/frameworks/native/cloud_data/src/cloud_manager.cpp
@@ -62,24 +62,24 @@ std::pair<int32_t, std::shared_ptr<CloudService>> CloudManager::GetCloudService(
 
     auto saMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (saMgr == nullptr) {
-        LOG_ERROR("get system ability manager failed");
+        LOG_ERROR("get system ability manager failed.");
         return std::make_pair(CloudService::Status::SERVER_UNAVAILABLE, nullptr);
     }
     auto dataMgrObject = saMgr->CheckSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
     if (dataMgrObject == nullptr) {
-        LOG_ERROR("get distributed data manager failed");
+        LOG_ERROR("get distributed data manager failed.");
         return std::make_pair(CloudService::Status::SERVER_UNAVAILABLE, nullptr);
     }
 
     sptr<DataMgrService> dataMgr = new (std::nothrow) DataMgrService(dataMgrObject);
     if (dataMgr == nullptr) {
-        LOG_ERROR("new CloudDataServiceProxy failed");
+        LOG_ERROR("new CloudDataServiceProxy failed.");
         return std::make_pair(CloudService::Status::SERVER_UNAVAILABLE, nullptr);
     }
 
     auto cloudObject = dataMgr->GetFeatureInterface(CloudService::SERVICE_NAME);
     if (cloudObject == nullptr) {
-        LOG_ERROR("get cloud service failed");
+        LOG_ERROR("get cloud service failed.");
         return std::make_pair(CloudService::Status::FEATURE_UNAVAILABLE, nullptr);
     }
 
@@ -109,12 +109,12 @@ sptr<IRemoteObject> DataMgrService::GetFeatureInterface(const std::string &name)
     LOG_INFO("%s", name.c_str());
     MessageParcel data;
     if (!data.WriteInterfaceToken(DataMgrService::GetDescriptor())) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return nullptr;
     }
 
     if (!ITypesUtil::Marshal(data, name)) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return nullptr;
     }
 
@@ -129,7 +129,7 @@ sptr<IRemoteObject> DataMgrService::GetFeatureInterface(const std::string &name)
 
     sptr<IRemoteObject> remoteObject;
     if (!ITypesUtil::Unmarshal(reply, remoteObject)) {
-        LOG_ERROR("remote object is nullptr");
+        LOG_ERROR("remote object is nullptr.");
         return nullptr;
     }
     return remoteObject;
diff --git a/relational_store/frameworks/native/dataability/src/ishared_result_set_proxy.cpp b/relational_store/frameworks/native/dataability/src/ishared_result_set_proxy.cpp
index d9ae4aaa05d53d74824df7082a0b7edf22037986..8d572ed23142632bbf5d70eb45b0dacc74c21c87 100644
--- a/relational_store/frameworks/native/dataability/src/ishared_result_set_proxy.cpp
+++ b/relational_store/frameworks/native/dataability/src/ishared_result_set_proxy.cpp
@@ -50,7 +50,7 @@ std::shared_ptr<AbsSharedResultSet> ISharedResultSetProxy::CreateProxy(MessagePa
 
 int ISharedResultSetProxy::GetRowCount(int &count)
 {
-    LOG_DEBUG("GetRowCount Begin");
+    LOG_DEBUG("GetRowCount Begin.");
     if (rowCount_ >= 0) {
         count = rowCount_;
         return E_OK;
@@ -78,7 +78,7 @@ int ISharedResultSetProxy::GetRowCount(int &count)
 
 int ISharedResultSetProxy::OnGo(int oldRowIndex, int newRowIndex)
 {
-    LOG_DEBUG("OnGo Begin");
+    LOG_DEBUG("OnGo Begin.");
     MessageParcel request;
     request.WriteInterfaceToken(GetDescriptor());
     request.WriteInt32(oldRowIndex);
@@ -95,7 +95,7 @@ int ISharedResultSetProxy::OnGo(int oldRowIndex, int newRowIndex)
 
 int ISharedResultSetProxy::Close()
 {
-    LOG_DEBUG("Close Begin");
+    LOG_DEBUG("Close Begin.");
     AbsSharedResultSet::Close();
     MessageParcel request;
     request.WriteInterfaceToken(GetDescriptor());
diff --git a/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.cpp b/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.cpp
index 1b6bd4e5dc1d8736ae6645f513f93e89929f8386..85ae11e3f9a857d0ec2f11ccd34b9e266c233430 100644
--- a/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.cpp
+++ b/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.cpp
@@ -32,11 +32,11 @@ sptr<ISharedResultSet> ISharedResultSetStub::CreateStub(std::shared_ptr<AbsShare
 {
     sptr<ISharedResultSet> stub = new (std::nothrow) ISharedResultSetStub(result);
     if (stub == nullptr) {
-        LOG_ERROR("stub is nullptr");
+        LOG_ERROR("stub is nullptr.");
         return nullptr;
     }
     if (result == nullptr) {
-        LOG_ERROR("result is nullptr");
+        LOG_ERROR("result is nullptr.");
         return nullptr;
     }
     parcel.WriteRemoteObject(stub->AsObject());
@@ -48,44 +48,31 @@ sptr<ISharedResultSet> ISharedResultSetStub::CreateStub(std::shared_ptr<AbsShare
 }
 
 ISharedResultSetStub::ISharedResultSetStub(std::shared_ptr<AbsSharedResultSet> resultSet)
-    : resultSet_(std::move(resultSet)),
-      runnables_(MAX_RUNNABLE),
-      thread_(&ISharedResultSetStub::Run, this)
+    : resultSet_(std::move(resultSet))
 {
-    thread_.detach();
-    LOG_ERROR("ISharedResultSetStub start thread(%{public}" PRIx64 ")", uint64_t(thread_.native_handle()));
 }
 ISharedResultSetStub::~ISharedResultSetStub()
 {
-    auto handle = thread_.native_handle();
-    isRunning_ = false;
-    // do not delete this code, this code is waiting the thread exit.
-    isRunning_ = Submit([this]() -> bool { return isRunning_;}).get();
-    LOG_ERROR("~ISharedResultSetStub thread(%{public}" PRIx64 ")", uint64_t(handle));
 }
 
 int ISharedResultSetStub::OnRemoteRequest(uint32_t code, OHOS::MessageParcel &data,
     OHOS::MessageParcel &reply, OHOS::MessageOption &option)
 {
     if (GetDescriptor() != data.ReadInterfaceToken()) {
-        LOG_ERROR("IPC descriptor is  not equal");
+        LOG_ERROR("IPC descriptor is  not equal.");
         return INVALID_FD;
     }
 
     if (code >= static_cast<uint32_t>(ResultSetCode::FUNC_BUTT)) {
-        LOG_ERROR("OnRemoteRequest method code(%{public}d) out of range", code);
+        LOG_ERROR("OnRemoteRequest method code(%{public}d) out of range.", code);
         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
     }
     Handler handler = handlers[code];
     if (handler == nullptr) {
-        LOG_ERROR("OnRemoteRequest method code(%{public}d) is not support", code);
+        LOG_ERROR("OnRemoteRequest method code(%{public}d) is not support.", code);
         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
     }
-
-    auto future = Submit([this, &data, &reply, handler]() -> int {
-        return (this->*handler)(data, reply);
-    });
-    return future.get();
+    return (this->*handler)(data, reply);
 }
 
 int ISharedResultSetStub::HandleGetRowCountRequest(MessageParcel &data, MessageParcel &reply)
@@ -129,25 +116,6 @@ int ISharedResultSetStub::HandleCloseRequest(MessageParcel &data, MessageParcel
     return NO_ERROR;
 }
 
-void ISharedResultSetStub::Run()
-{
-#if defined(MAC_PLATFORM)
-    pthread_setname_np("RDB_DataAbility");
-#else
-    pthread_setname_np(pthread_self(), "RDB_DataAbility");
-#endif
-    auto handle = thread_.native_handle();
-    bool isRunning = true;
-    while (isRunning) {
-        auto runnable = runnables_.Pop();
-        if (runnable == nullptr) {
-            continue;
-        }
-        isRunning = runnable();
-    }
-    LOG_ERROR("ISharedResultSetStub thread(%{public}" PRIx64 ") is exited", uint64_t(handle));
-}
-
 std::pair<int, std::vector<std::string>> ISharedResultSetStub::GetColumnNames()
 {
     return resultSet_->GetColumnNames();
diff --git a/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.h b/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.h
index c57637ea6ae36745254400ff81b6bbb9587f2254..ace86d935ed8078eb802815a5d71c0c13d31623a 100644
--- a/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.h
+++ b/relational_store/frameworks/native/dataability/src/ishared_result_set_stub.h
@@ -37,28 +37,10 @@ protected:
     int HandleGetColumnNamesRequest(MessageParcel &data, MessageParcel &reply);
     int HandleOnGoRequest(MessageParcel &data, MessageParcel &reply);
     int HandleCloseRequest(MessageParcel &data, MessageParcel &reply);
-    template<typename F, typename... Args>
-    auto Submit(F&& func, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>
-    {
-        auto exec = std::bind(std::forward<F>(func), std::forward<Args>(args)...);
-        auto task = std::make_shared<std::packaged_task<typename std::result_of<F(Args...)>::type()>>(std::move(exec));
-        auto future = task->get_future();
-        runnables_.Push([task, this] {
-            bool isRunning = isRunning_;
-            (*task)();
-            return isRunning;
-        });
-        return future;
-    }
 
 private:
-    void Run();
     using Handler = int(ISharedResultSetStub::*)(MessageParcel &request, MessageParcel &reply);
-    static constexpr int MAX_RUNNABLE = 1024;
     std::shared_ptr<AbsSharedResultSet> resultSet_;
-    SafeBlockQueue<std::function<bool()>> runnables_;
-    bool isRunning_ = true;
-    std::thread thread_;
     static constexpr Handler handlers[static_cast<uint32_t>(ResultSetCode::FUNC_BUTT)] {
         &ISharedResultSetStub::HandleGetRowCountRequest,
         &ISharedResultSetStub::HandleGetColumnNamesRequest,
diff --git a/relational_store/frameworks/native/dfx/include/rdb_fault_hiview_reporter.h b/relational_store/frameworks/native/dfx/include/rdb_fault_hiview_reporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..5263be1f1a444a55ccc81ffec460ddcf7f9b8406
--- /dev/null
+++ b/relational_store/frameworks/native/dfx/include/rdb_fault_hiview_reporter.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DISTRIBUTEDDATAMGR_RDB_FAULT_HIVIEW_REPORTER_H
+#define DISTRIBUTEDDATAMGR_RDB_FAULT_HIVIEW_REPORTER_H
+
+#include <sys/stat.h>
+#include <ctime>
+#include <string>
+
+#include "rdb_store_config.h"
+
+namespace OHOS::NativeRdb {
+
+struct RdbCorruptedEvent {
+    std::string bundleName;
+    std::string moduleName;
+    std::string storeType;
+    std::string storeName;
+    uint32_t securityLevel;
+    uint32_t pathArea;
+    uint32_t encryptStatus;
+    uint32_t integrityCheck;
+    uint32_t errorCode;
+    int32_t systemErrorNo;
+    std::string appendix;
+    time_t errorOccurTime;
+    int dbFileStatRet;
+    struct stat dbFileStat;
+    int walFileStatRet;
+    struct stat walFileStat;
+};
+
+class RdbFaultHiViewReporter {
+public:
+    static void ReportRdbCorruptedFault(RdbCorruptedEvent &eventInfo);
+
+private:
+    static std::string GetFileStatInfo(const struct stat &fileStat);
+    static std::string GetDateInfo(time_t time);
+};
+} // namespace OHOS::NativeRdb
+#endif //DISTRIBUTEDDATAMGR_RDB_FAULT_HIVIEW_REPORTER_H
diff --git a/relational_store/frameworks/native/dfx/include/rdb_radar_reporter.h b/relational_store/frameworks/native/dfx/include/rdb_radar_reporter.h
index 03e7535157639b1737c7029407f9374eec7a6e17..dcf93e3abcde8a6e31de5ae822c12146ad22a1ac 100644
--- a/relational_store/frameworks/native/dfx/include/rdb_radar_reporter.h
+++ b/relational_store/frameworks/native/dfx/include/rdb_radar_reporter.h
@@ -17,6 +17,7 @@
 #define DISTRIBUTEDDATAMGR_RDB_RADAR_REPORTER_H
 
 #include <string>
+#include <mutex>
 namespace OHOS::NativeRdb {
 
 enum Scene : int {
@@ -41,23 +42,6 @@ enum StageRes : int {
 };
 
 class RdbRadar {
-public:
-    static constexpr char ORG_PKG_LABEL[] = "ORG_PKG";
-    static constexpr char ORG_PKG_VALUE[] = "distributeddata";
-    static constexpr char FUNC_LABEL[] = "FUNC";
-    static constexpr char BIZ_SCENE_LABEL[] = "BIZ_SCENE";
-    static constexpr char BIZ_STATE_LABEL[] = "BIZ_STATE";
-    static constexpr char BIZ_STAGE_LABEL[] = "BIZ_STAGE";
-    static constexpr char STAGE_RES_LABEL[] = "STAGE_RES";
-    static constexpr char ERROR_CODE_LABEL[] = "ERROR_CODE";
-    static constexpr char TO_CALL_PKG_LABEL[] = "TO_CALL_PKG";
-    static constexpr char HOST_PKG_LABEL[] = "HOST_PKG";
-    static constexpr char LOCAL_UUID_LABEL[] = "HOST_PKG";
-    static constexpr char PEER_UUID_LABEL[] = "HOST_PKG";
-    static constexpr char EVENT_NAME[] = "DISTRIBUTED_RDB_BEHAVIOR";
-    static constexpr char HOST_PKG[] = "HOST_PKG";
-    static constexpr char UNKNOW[] = "unknow";
-
 public:
     RdbRadar(Scene scene, const char *funcName, std::string bundleName);
     ~RdbRadar();
@@ -69,12 +53,13 @@ private:
     int errCode_{ 0 };
     Scene scene_;
     const char* funcName_;
+    std::string bundleName_;
 
-    static bool hasHostPkg_;
     static std::string hostPkg_;
+    static std::mutex mutex_;
 
     void LocalReport(int bizSence, const char *funcName, int state, int errCode = 0);
-    void GetHostPkgInfo(std::string bundleName);
+    std::string GetHostPkgInfo();
 };
 } // namespace OHOS::NativeRdb
 #endif //DISTRIBUTEDDATAMGR_RDB_RADAR_REPORTER_H
diff --git a/relational_store/frameworks/native/dfx/src/rdb_fault_hiview_reporter.cpp b/relational_store/frameworks/native/dfx/src/rdb_fault_hiview_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3497867163eaa4e4999301250669f1837f72bb6
--- /dev/null
+++ b/relational_store/frameworks/native/dfx/src/rdb_fault_hiview_reporter.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "RdbFaultHiViewReporter"
+
+#include "rdb_fault_hiview_reporter.h"
+
+#include <iomanip>
+#include <sstream>
+
+#include "hisysevent_c.h"
+#include "logger.h"
+#include "rdb_errno.h"
+
+namespace OHOS::NativeRdb {
+
+using namespace OHOS::Rdb;
+
+static constexpr const char *EVENT_NAME = "DATABASE_CORRUPTED";
+static constexpr const char *DISTRIBUTED_DATAMGR = "DISTDATAMGR";
+
+void RdbFaultHiViewReporter::ReportRdbCorruptedFault(RdbCorruptedEvent &eventInfo)
+{
+    char *bundleName = eventInfo.bundleName.data();
+    char *moduleName = eventInfo.moduleName.data();
+    char *storeType = eventInfo.storeType.data();
+    char *storeName = eventInfo.storeName.data();
+    uint32_t checkType = eventInfo.integrityCheck;
+    std::string appendInfo = eventInfo.appendix;
+    if (eventInfo.dbFileStatRet >= 0) {
+        appendInfo = appendInfo + " \n DB : \n" + GetFileStatInfo(eventInfo.dbFileStat);
+    }
+    if (eventInfo.walFileStatRet >= 0) {
+        appendInfo = appendInfo + " \n WAL : \n" + GetFileStatInfo(eventInfo.walFileStat);
+    }
+    LOG_WARN("storeName: %{public}s, errorCode: %{public}d, appendInfo : %{public}s.", storeName, eventInfo.errorCode,
+        appendInfo.c_str());
+    std::string occurTime = GetDateInfo(eventInfo.errorOccurTime);
+    char *errorOccurTime = occurTime.data();
+    HiSysEventParam params[] = {
+        { .name = "BUNDLE_NAME", .t = HISYSEVENT_STRING, .v = { .s = bundleName }, .arraySize = 0 },
+        { .name = "MODULE_NAME", .t = HISYSEVENT_STRING, .v = { .s = moduleName }, .arraySize = 0 },
+        { .name = "STORE_TYPE", .t = HISYSEVENT_STRING, .v = { .s = storeType }, .arraySize = 0 },
+        { .name = "STORE_NAME", .t = HISYSEVENT_STRING, .v = { .s = storeName }, .arraySize = 0 },
+        { .name = "SECURITY_LEVEL", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.securityLevel }, .arraySize = 0 },
+        { .name = "PATH_AREA", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.pathArea }, .arraySize = 0 },
+        { .name = "ENCRYPT_STATUS", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.encryptStatus }, .arraySize = 0 },
+        { .name = "INTEGRITY_CHECK", .t = HISYSEVENT_UINT32, .v = { .ui32 = checkType }, .arraySize = 0 },
+        { .name = "ERROR_CODE", .t = HISYSEVENT_UINT32, .v = { .ui32 = eventInfo.errorCode }, .arraySize = 0 },
+        { .name = "ERRNO", .t = HISYSEVENT_INT32, .v = { .i32 = eventInfo.systemErrorNo }, .arraySize = 0 },
+        { .name = "APPENDIX", .t = HISYSEVENT_STRING, .v = { .s = appendInfo.data() }, .arraySize = 0 },
+        { .name = "ERROR_TIME", .t = HISYSEVENT_STRING, .v = { .s = errorOccurTime }, .arraySize = 0 },
+    };
+    OH_HiSysEvent_Write(DISTRIBUTED_DATAMGR, EVENT_NAME, HISYSEVENT_FAULT, params, sizeof(params) / sizeof(params[0]));
+}
+
+std::string RdbFaultHiViewReporter::GetFileStatInfo(const struct stat &fileStat)
+{
+    const uint32_t permission = 0777;
+    std::stringstream oss;
+    oss << " device: " << fileStat.st_dev << " inode: " << fileStat.st_ino
+        << " mode: " << (fileStat.st_mode & permission) << " size: " << fileStat.st_size
+        << " natime: " << ctime(&fileStat.st_atime) << " smtime: " << ctime(&fileStat.st_mtime)
+        << " sctime: " << ctime(&fileStat.st_ctime);
+    return oss.str();
+}
+
+std::string RdbFaultHiViewReporter::GetDateInfo(time_t time)
+{
+    std::tm tm;
+    localtime_r(&time, &tm);
+    std::stringstream oss;
+    oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
+    return oss.str();
+}
+} // namespace OHOS::NativeRdb
\ No newline at end of file
diff --git a/relational_store/frameworks/native/dfx/src/rdb_radar_reporter.cpp b/relational_store/frameworks/native/dfx/src/rdb_radar_reporter.cpp
index 283c5ac8fb439e88a17809dbfb9e021e93758b61..cde821359d255100912876a969fe19a14e62b372 100644
--- a/relational_store/frameworks/native/dfx/src/rdb_radar_reporter.cpp
+++ b/relational_store/frameworks/native/dfx/src/rdb_radar_reporter.cpp
@@ -15,23 +15,28 @@
 
 #include "rdb_radar_reporter.h"
 #include "rdb_errno.h"
-#include "hisysevent.h"
 #include "ipc_skeleton.h"
 #include "accesstoken_kit.h"
+#include "hisysevent_c.h"
 
 namespace OHOS::NativeRdb {
 
 using namespace Security::AccessToken;
 
-bool RdbRadar::hasHostPkg_ = false;
+static constexpr const char* ORG_PKG_VALUE = "distributeddata";
+static constexpr const char* EVENT_NAME = "DISTRIBUTED_RDB_BEHAVIOR";
+static constexpr const char* UNKNOW = "unknow";
+static constexpr const char* DISTRIBUTED_DATAMGR = "DISTDATAMGR";
+
 std::string RdbRadar::hostPkg_{ "" };
+std::mutex RdbRadar::mutex_;
 
-RdbRadar::RdbRadar(Scene scene, const char* funcName, std::string bundleName) : scene_(scene), funcName_(funcName)
+RdbRadar::RdbRadar(Scene scene, const char *funcName, std::string bundleName)
+    : scene_(scene), funcName_(funcName), bundleName_(bundleName)
 {
     if (funcName_ == nullptr) {
         funcName_ = UNKNOW;
     }
-    GetHostPkgInfo(bundleName);
     LocalReport(scene_, funcName_, STATE_START);
 }
 
@@ -58,24 +63,32 @@ void RdbRadar::LocalReport(int bizSence, const char* funcName, int state, int er
         stageRes = static_cast<int>(StageRes::RES_FAILED);
     }
 
-    HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::DISTRIBUTED_DATAMGR,
-        RdbRadar::EVENT_NAME,
-        OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR,
-        RdbRadar::ORG_PKG_LABEL, RdbRadar::ORG_PKG_VALUE,
-        RdbRadar::FUNC_LABEL, funcName,
-        RdbRadar::BIZ_SCENE_LABEL, bizSence,
-        RdbRadar::BIZ_STAGE_LABEL, SYNC_STAGE_RUN,
-        RdbRadar::STAGE_RES_LABEL, stageRes,
-        RdbRadar::ERROR_CODE_LABEL, errCode,
-        RdbRadar::BIZ_STATE_LABEL, state,
-        RdbRadar::HOST_PKG, hostPkg_.c_str());
+    std::string hostPkg = GetHostPkgInfo();
+    char *hostPkgPtr = hostPkg.data();
+    if (hostPkgPtr == nullptr) {
+        return;
+    }
+    HiSysEventParam params[] = {
+        {.name = "ORG_PKG", .t = HISYSEVENT_STRING, .v = { .s = const_cast<char *>(ORG_PKG_VALUE) }, .arraySize = 0, },
+        {.name = "FUNC", .t = HISYSEVENT_STRING, .v = { .s = const_cast<char *>(funcName) }, .arraySize = 0, },
+        {.name = "BIZ_SCENE", .t = HISYSEVENT_INT32, .v = { .i32 = bizSence }, .arraySize = 0, },
+        {.name = "BIZ_STAGE", .t = HISYSEVENT_INT32, .v = { .i32 = SYNC_STAGE_RUN }, .arraySize = 0, },
+        {.name = "STAGE_RES", .t = HISYSEVENT_INT32, .v = { .i32 = stageRes }, .arraySize = 0, },
+        {.name = "ERROR_CODE", .t = HISYSEVENT_INT32, .v = { .i32 = errCode }, .arraySize = 0, },
+        {.name = "BIZ_STATE", .t = HISYSEVENT_INT32, .v = { .i32 = state }, .arraySize = 0, },
+        {.name = "HOST_PKG", .t = HISYSEVENT_STRING, .v = { .s = hostPkgPtr }, .arraySize = 0, },
+    };
+
+    OH_HiSysEvent_Write(DISTRIBUTED_DATAMGR, EVENT_NAME,
+        HISYSEVENT_BEHAVIOR, params, sizeof(params) / sizeof(params[0]));
     return;
 }
 
-void RdbRadar::GetHostPkgInfo(std::string bundleName)
+std::string RdbRadar::GetHostPkgInfo()
 {
-    if (hasHostPkg_) {
-        return;
+    std::lock_guard<std::mutex> lockGuard(mutex_);
+    if (!hostPkg_.empty()) {
+        return hostPkg_;
     }
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto tokenType = AccessTokenKit::GetTokenTypeFlag(tokenId);
@@ -83,11 +96,10 @@ void RdbRadar::GetHostPkgInfo(std::string bundleName)
         NativeTokenInfo tokenInfo;
         if (AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo) == 0) {
             hostPkg_ = tokenInfo.processName;
-            hasHostPkg_ = true;
         }
     } else {
-        hostPkg_ = bundleName;
-        hasHostPkg_ = true;
+        hostPkg_ = bundleName_;
     }
+    return hostPkg_;
 }
 }
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/include/connection.h b/relational_store/frameworks/native/rdb/include/connection.h
index e0839abec5c14a0a2fad0d236c72ebbb121d8b41..5ce759bd91a43139bd5994a45b4ecfcdab7a9f15 100644
--- a/relational_store/frameworks/native/rdb/include/connection.h
+++ b/relational_store/frameworks/native/rdb/include/connection.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <utility>
 
+#include "rdb_common.h"
 #include "rdb_types.h"
 #include "statement.h"
 namespace OHOS::NativeRdb {
@@ -34,13 +35,13 @@ public:
     using Notifier = std::function<void(const std::set<std::string> &tables)>;
     using Creator = std::pair<int32_t, SConn> (*)(const RdbStoreConfig &config, bool isWriter);
     using Repairer = int32_t (*)(const RdbStoreConfig &config);
-    using Deleter = void (*)(const RdbStoreConfig &config);
+    using Deleter = int32_t (*)(const RdbStoreConfig &config);
     static std::pair<int32_t, SConn> Create(const RdbStoreConfig &config, bool isWriter);
     static int32_t Repair(const RdbStoreConfig &config);
-    static void DeleteDbFile(const RdbStoreConfig &config);
+    static int32_t Delete(const RdbStoreConfig &config);
     static int32_t RegisterCreator(int32_t dbType, Creator creator);
     static int32_t RegisterRepairer(int32_t dbType, Repairer repairer);
-    static int32_t RegisterFileDeleter(int32_t dbType, Deleter deleter);
+    static int32_t RegisterDeleter(int32_t dbType, Deleter deleter);
 
     int32_t SetId(int32_t id);
     int32_t GetId() const;
@@ -62,8 +63,11 @@ public:
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) = 0;
     virtual int32_t Unsubscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) = 0;
-    virtual int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) = 0;
-    virtual int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) = 0;
+    virtual int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        bool isAsync, SlaveStatus &slaveStatus) = 0;
+    virtual int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        SlaveStatus &slaveStatus) = 0;
+    virtual ExchangeStrategy GenerateExchangeStrategy(const SlaveStatus &status) = 0;
 
 private:
     int32_t id_ = 0;
diff --git a/relational_store/frameworks/native/rdb/mock/include/sqlite_connection_pool.h b/relational_store/frameworks/native/rdb/include/connection_pool.h
similarity index 85%
rename from relational_store/frameworks/native/rdb/mock/include/sqlite_connection_pool.h
rename to relational_store/frameworks/native/rdb/include/connection_pool.h
index 214d0900c17ef634784360f592df2f53f44c8ff4..291b29a9e341b288c43ecbb4c58409f84b8f06bc 100644
--- a/relational_store/frameworks/native/rdb/mock/include/sqlite_connection_pool.h
+++ b/relational_store/frameworks/native/rdb/include/connection_pool.h
@@ -1,138 +1,139 @@
-/*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef NATIVE_RDB_SQLITE_CONNECTION_POOL_H
-#define NATIVE_RDB_SQLITE_CONNECTION_POOL_H
-
-#include <atomic>
-#include <condition_variable>
-#include <iostream>
-#include <iterator>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <sstream>
-#include <stack>
-#include <vector>
-
-#include "base_transaction.h"
-#include "connection.h"
-#include "rdb_common.h"
-#include "rdb_store_config.h"
-#include "rd_statement.h"
-namespace OHOS {
-namespace NativeRdb {
-class SqliteConnectionPool : public std::enable_shared_from_this<SqliteConnectionPool> {
-public:
-    using SharedConn = std::shared_ptr<Connection>;
-    using SharedConns = std::vector<SharedConn>;
-    static constexpr std::chrono::milliseconds INVALID_TIME = std::chrono::milliseconds(0);
-    static std::shared_ptr<SqliteConnectionPool> Create(const RdbStoreConfig &storeConfig, int &errCode);
-    static std::pair<RebuiltType, std::shared_ptr<SqliteConnectionPool>> HandleDataCorruption
-        (const RdbStoreConfig &storeConfig, int &errCode);
-    ~SqliteConnectionPool();
-    std::pair<int32_t, std::shared_ptr<Connection>> CreateConnection(bool isReadOnly);
-    SharedConn AcquireConnection(bool isReadOnly);
-    SharedConn Acquire(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
-    // this interface is only provided for resultSet
-    SharedConn AcquireRef(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
-    std::pair<SharedConn, SharedConns> AcquireAll(int32_t time);
-    std::pair<int32_t, SharedConn> DisableWal();
-    int32_t EnableWal();
-    int RestartReaders();
-    int ConfigLocale(const std::string &localeStr);
-    int ChangeDbFileForRestore(const std::string &newPath, const std::string &backupPath,
-        const std::vector<uint8_t> &newKey);
-    std::stack<BaseTransaction> &GetTransactionStack();
-    std::mutex &GetTransactionStackMutex();
-    int AcquireTransaction();
-    void ReleaseTransaction();
-    void CloseAllConnections();
-    bool IsInTransaction();
-    void SetInTransaction(bool isInTransaction);
-
-private:
-    struct ConnNode {
-        bool using_ = false;
-        int32_t tid_ = 0;
-        int32_t id_ = 0;
-        std::chrono::steady_clock::time_point time_ = std::chrono::steady_clock::now();
-        std::shared_ptr<Connection> connect_;
-
-        explicit ConnNode(std::shared_ptr<Connection> conn);
-        std::shared_ptr<Connection> GetConnect();
-        int64_t GetUsingTime() const;
-        bool IsWriter() const;
-        void Unused();
-    };
-
-    struct Container {
-        using Creator = std::function<std::pair<int32_t, std::shared_ptr<Connection>>()>;
-        static constexpr int32_t MAX_RIGHT = 0x4FFFFFFF;
-        bool disable_ = true;
-        int max_ = 0;
-        int total_ = 0;
-        int count_ = 0;
-        int32_t left_ = 0;
-        int32_t right_ = 0;
-        std::chrono::seconds timeout_;
-        std::list<std::shared_ptr<ConnNode>> nodes_;
-        std::list<std::weak_ptr<ConnNode>> details_;
-        std::mutex mutex_;
-        std::condition_variable cond_;
-        Creator creator_ = nullptr;
-        std::pair<int32_t, std::shared_ptr<ConnNode>> Initialize(Creator creator, int32_t max, int32_t timeout,
-            bool disable, bool acquire = false);
-        int32_t ConfigLocale(const std::string &locale);
-        std::shared_ptr<ConnNode> Acquire(std::chrono::milliseconds milliS);
-        std::list<std::shared_ptr<ConnNode>> AcquireAll(std::chrono::milliseconds milliS);
-
-        void Disable();
-        void Enable();
-        int32_t Release(std::shared_ptr<ConnNode> node);
-        int32_t Clear();
-        bool IsFull();
-        int32_t Dump(const char *header);
-
-    private:
-        int32_t ExtendNode();
-        int32_t RelDetails(std::shared_ptr<ConnNode> node);
-    };
-
-    explicit SqliteConnectionPool(const RdbStoreConfig &storeConfig);
-    std::pair<int32_t, std::shared_ptr<Connection>> Init(const RdbStoreConfig &config, bool needWriter = false);
-    int32_t GetMaxReaders(const RdbStoreConfig &config);
-    std::shared_ptr<Connection> Convert2AutoConn(std::shared_ptr<ConnNode> node);
-    void ReleaseNode(std::shared_ptr<ConnNode> node);
-    void RemoveDBFile();
-    void RemoveDBFile(const std::string &path);
-
-    static constexpr int LIMITATION = 1024;
-    const RdbStoreConfig &config_;
-    Container writers_;
-    Container readers_;
-    int32_t maxReader_ = 0;
-
-    std::stack<BaseTransaction> transactionStack_;
-    std::mutex transactionStackMutex_;
-    std::condition_variable transCondition_;
-    std::mutex transMutex_;
-    bool transactionUsed_;
-    std::atomic<bool> isInTransaction_ = false;
-};
-
-} // namespace NativeRdb
-} // namespace OHOS
-#endif
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NATIVE_RDB_SQLITE_CONNECTION_POOL_H
+#define NATIVE_RDB_SQLITE_CONNECTION_POOL_H
+
+#include <atomic>
+#include <condition_variable>
+#include <iostream>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <stack>
+#include <vector>
+
+#include "base_transaction.h"
+#include "connection.h"
+#include "rdb_common.h"
+#include "rdb_store_config.h"
+namespace OHOS {
+namespace NativeRdb {
+class ConnectionPool : public std::enable_shared_from_this<ConnectionPool> {
+public:
+    using SharedConn = std::shared_ptr<Connection>;
+    using SharedConns = std::vector<SharedConn>;
+    static constexpr std::chrono::milliseconds INVALID_TIME = std::chrono::milliseconds(0);
+    static std::shared_ptr<ConnectionPool> Create(const RdbStoreConfig &storeConfig, int &errCode);
+    ~ConnectionPool();
+    static std::pair<RebuiltType, std::shared_ptr<ConnectionPool>> HandleDataCorruption
+        (const RdbStoreConfig &storeConfig, int &errCode);
+    std::pair<int32_t, std::shared_ptr<Connection>> CreateConnection(bool isReadOnly);
+    SharedConn AcquireConnection(bool isReadOnly);
+    SharedConn Acquire(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
+    // this interface is only provided for resultSet
+    SharedConn AcquireRef(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
+    std::pair<SharedConn, SharedConns> AcquireAll(int32_t time);
+    std::pair<int32_t, SharedConn> DisableWal();
+    int32_t EnableWal();
+    int RestartReaders();
+    int ConfigLocale(const std::string &localeStr);
+    int ChangeDbFileForRestore(const std::string &newPath, const std::string &backupPath,
+        const std::vector<uint8_t> &newKey, SlaveStatus &slaveStatus);
+    std::stack<BaseTransaction> &GetTransactionStack();
+    std::mutex &GetTransactionStackMutex();
+    int AcquireTransaction();
+    void ReleaseTransaction();
+    void CloseAllConnections();
+    bool IsInTransaction();
+    void SetInTransaction(bool isInTransaction);
+
+private:
+    struct ConnNode {
+        bool using_ = false;
+        int32_t tid_ = 0;
+        int32_t id_ = 0;
+        std::chrono::steady_clock::time_point time_ = std::chrono::steady_clock::now();
+        std::shared_ptr<Connection> connect_;
+
+        explicit ConnNode(std::shared_ptr<Connection> conn);
+        std::shared_ptr<Connection> GetConnect();
+        int64_t GetUsingTime() const;
+        bool IsWriter() const;
+        int32_t Unused();
+    };
+
+    struct Container {
+        using Creator = std::function<std::pair<int32_t, std::shared_ptr<Connection>>()>;
+        static constexpr int32_t MAX_RIGHT = 0x4FFFFFFF;
+        bool disable_ = true;
+        int max_ = 0;
+        int total_ = 0;
+        int count_ = 0;
+        int32_t left_ = 0;
+        int32_t right_ = 0;
+        std::chrono::seconds timeout_;
+        std::list<std::shared_ptr<ConnNode>> nodes_;
+        std::list<std::weak_ptr<ConnNode>> details_;
+        std::mutex mutex_;
+        std::condition_variable cond_;
+        Creator creator_ = nullptr;
+        std::pair<int32_t, std::shared_ptr<ConnNode>> Initialize(Creator creator, int32_t max, int32_t timeout,
+            bool disable, bool acquire = false);
+        int32_t ConfigLocale(const std::string &locale);
+        std::shared_ptr<ConnNode> Acquire(std::chrono::milliseconds milliS);
+        std::list<std::shared_ptr<ConnNode>> AcquireAll(std::chrono::milliseconds milliS);
+
+        void Disable();
+        void Enable();
+        int32_t Release(std::shared_ptr<ConnNode> node);
+        int32_t Clear();
+        bool IsFull();
+        int32_t Dump(const char *header);
+
+    private:
+        int32_t ExtendNode();
+        int32_t RelDetails(std::shared_ptr<ConnNode> node);
+    };
+
+    explicit ConnectionPool(const RdbStoreConfig &storeConfig);
+    std::pair<int32_t, std::shared_ptr<Connection>> Init(bool isAttach = false, bool needWriter = false);
+    int32_t GetMaxReaders(const RdbStoreConfig &config);
+    std::shared_ptr<Connection> Convert2AutoConn(std::shared_ptr<ConnNode> node);
+    void ReleaseNode(std::shared_ptr<ConnNode> node);
+    int RestoreByDbSqliteType(const std::string &newPath, const std::string &backupPath, SlaveStatus &slaveStatus);
+
+    static constexpr int LIMITATION = 1024;
+    static constexpr uint32_t ITER_V1 = 5000;
+    static constexpr uint32_t ITERS_COUNT = 2;
+    const RdbStoreConfig &config_;
+    RdbStoreConfig attachConfig_;
+    Container writers_;
+    Container readers_;
+    int32_t maxReader_ = 0;
+
+    std::stack<BaseTransaction> transactionStack_;
+    std::mutex transactionStackMutex_;
+    std::condition_variable transCondition_;
+    std::mutex transMutex_;
+    bool transactionUsed_;
+    std::atomic<bool> isInTransaction_ = false;
+};
+
+} // namespace NativeRdb
+} // namespace OHOS
+#endif
diff --git a/relational_store/frameworks/native/rdb/include/delay_notify.h b/relational_store/frameworks/native/rdb/include/delay_notify.h
index cc99556da1922ffd39e0d0bb45ef1cb4f2eac636..f26f0e073a4c44cab1a8c469bfaaa14e50390e4e 100644
--- a/relational_store/frameworks/native/rdb/include/delay_notify.h
+++ b/relational_store/frameworks/native/rdb/include/delay_notify.h
@@ -16,6 +16,7 @@
 #ifndef NATIVE_RDB_DELAY_NOTIFY_H
 #define NATIVE_RDB_DELAY_NOTIFY_H
 #include <atomic>
+#include <chrono>
 #include <map>
 #include <string>
 #include <functional>
@@ -25,17 +26,23 @@
 namespace OHOS::NativeRdb {
 class DelayNotify {
 public:
-    using Task = std::function<int(const DistributedRdb::RdbChangedData &)>;
+    using Task = std::function<int(const DistributedRdb::RdbChangedData &, const DistributedRdb::RdbNotifyConfig &)>;
+    using Time = std::chrono::steady_clock::time_point;
     DelayNotify();
     ~DelayNotify();
     void SetExecutorPool(std::shared_ptr<ExecutorPool> pool);
     void SetTask(Task task);
-    void UpdateNotify(const DistributedRdb::RdbChangedData &changedData);
+    void UpdateNotify(const DistributedRdb::RdbChangedData &changedData, bool isFull = false);
     void SetAutoSyncInterval(uint32_t autoSyncInterval);
     void Pause();
     void Resume();
 private:
     static constexpr uint32_t AUTO_SYNC_INTERVAL = 200;
+    static constexpr uint32_t MAX_NOTIFY_INTERVAL = 5000;
+    static constexpr uint32_t SERVICE_INTERVAL = 10000;
+    bool isInitialized_ = false;
+    bool isFull_ = false;
+    Time lastTimePoint_;
     std::atomic_int32_t pauseCount_;
     ExecutorPool::TaskId delaySyncTaskId_ = ExecutorPool::INVALID_TASK_ID;
     Task task_;
diff --git a/relational_store/frameworks/native/rdb/include/grd_api_manager.h b/relational_store/frameworks/native/rdb/include/grd_api_manager.h
index e0944ee9a9af5c8bbe4336e257bdafeac8e943c6..2f7b9eee183fcbf1026a0cea4a3ce43e25310cec 100644
--- a/relational_store/frameworks/native/rdb/include/grd_api_manager.h
+++ b/relational_store/frameworks/native/rdb/include/grd_api_manager.h
@@ -35,7 +35,7 @@ typedef int (*DBSqlBindInt64)(GRD_SqlStmt *stmt, uint32_t idx, int64_t val);
 typedef int (*DBSqlBindDouble)(GRD_SqlStmt *stmt, uint32_t idx, double val);
 typedef int (*DBSqlBindNull)(GRD_SqlStmt *stmt, uint32_t idx);
 typedef int (*DBSqlBindFloatVector)(
-    GRD_SqlStmt *stmt, uint32_t idx, float *val, uint32_t dim, void (*freeFunc)(void *));
+    GRD_SqlStmt *stmt, uint32_t idx, const float *val, uint32_t dim, void (*freeFunc)(void *));
 
 typedef int (*DBSqlStep)(GRD_SqlStmt *stmt);
 typedef uint32_t (*DBSqlColCnt)(GRD_SqlStmt *stmt);
diff --git a/relational_store/frameworks/native/rdb/include/grd_type_export.h b/relational_store/frameworks/native/rdb/include/grd_type_export.h
index 6d4ba9b872caa1762e196c14abe223de71facaa3..80ad78a028954132360813ad5fbd27659be6c5b2 100644
--- a/relational_store/frameworks/native/rdb/include/grd_type_export.h
+++ b/relational_store/frameworks/native/rdb/include/grd_type_export.h
@@ -48,12 +48,12 @@ typedef struct GRD_SqlStmt GRD_SqlStmt;
 
 #define GRD_DOC_ID_DISPLAY 0x01
 typedef enum {
-    GRD_SQL_DATATYPE_INTEGER = 0,
-    GRD_SQL_DATATYPE_FLOAT,
-    GRD_SQL_DATATYPE_TEXT,
-    GRD_SQL_DATATYPE_BLOB,
-    GRD_SQL_DATATYPE_FLOATVECTOR,
-    GRD_SQL_DATATYPE_NULL,
+    GRD_DB_DATATYPE_INTEGER = 0,
+    GRD_DB_DATATYPE_FLOAT,
+    GRD_DB_DATATYPE_TEXT,
+    GRD_DB_DATATYPE_BLOB,
+    GRD_DB_DATATYPE_FLOATVECTOR,
+    GRD_DB_DATATYPE_NULL,
 } GRD_DbDataTypeE;
 
 typedef enum {
diff --git a/relational_store/frameworks/native/rdb/include/rd_connection.h b/relational_store/frameworks/native/rdb/include/rd_connection.h
index e3037fdff022c2ceb819b4e0e1d201453a2010d3..ec62e9d4c6a98fe3bcfa6c672a9e9c41014d53bf 100644
--- a/relational_store/frameworks/native/rdb/include/rd_connection.h
+++ b/relational_store/frameworks/native/rdb/include/rd_connection.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "rd_utils.h"
+#include "rdb_common.h"
 #include "connection.h"
 #include "rdb_store_config.h"
 #include "value_object.h"
@@ -33,8 +34,8 @@ class RdConnection : public Connection {
 public:
     static std::pair<int32_t, std::shared_ptr<Connection>> Create(const RdbStoreConfig& config, bool isWrite);
     static int32_t Repair(const RdbStoreConfig& config);
-    static void DeleteDbFile(const RdbStoreConfig& config);
-    explicit RdConnection(bool isWriteConnection);
+    static int32_t Delete(const RdbStoreConfig& config);
+    RdConnection(const RdbStoreConfig &config, bool isWriteConnection);
     ~RdConnection();
     int32_t OnInitialize() override;
     std::pair<int32_t, Stmt> CreateStatement(const std::string& sql, SConn conn) override;
@@ -53,8 +54,11 @@ public:
         const std::shared_ptr<DistributedRdb::RdbStoreObserver>& observer) override;
     int32_t Unsubscribe(const std::string& event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver>& observer) override;
-    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
-    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
+    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        bool isAsync, SlaveStatus &slaveStatus) override;
+    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        SlaveStatus &slaveStatus) override;
+    ExchangeStrategy GenerateExchangeStrategy(const SlaveStatus &status) override;
     
 private:
     static constexpr int MAX_VARIABLE_NUM = 500;
@@ -67,12 +71,13 @@ private:
     static constexpr uint32_t ITERS_COUNT = sizeof(ITERS) / sizeof(ITERS[0]);
     static const int32_t regCreator_;
     static const int32_t regRepairer_;
-    static const int32_t regFileDeleter_;
+    static const int32_t regDeleter_;
 
     int InnerOpen(const RdbStoreConfig &config);
     bool isWriter_ = false;
     GRD_DB *dbHandle_ = nullptr;
     std::string configStr_ = GRD_OPEN_CONFIG_STR;
+    const RdbStoreConfig config_;
 };
 
 } // namespace NativeRdb
diff --git a/relational_store/frameworks/native/rdb/include/rd_statement.h b/relational_store/frameworks/native/rdb/include/rd_statement.h
index b59ca34d48850656162e0e486ebef8583c4a5b6a..7b4ff685550e800ee351831385c42b48aa9880dd 100644
--- a/relational_store/frameworks/native/rdb/include/rd_statement.h
+++ b/relational_store/frameworks/native/rdb/include/rd_statement.h
@@ -24,6 +24,8 @@
 #include "statement.h"
 #include "value_object.h"
 #include "rd_connection.h"
+#include "rdb_store_config.h"
+
 namespace OHOS {
 namespace NativeRdb {
 class RdStatement final : public Statement {
@@ -33,6 +35,7 @@ public:
     int Finalize() override;
     int32_t Prepare(const std::string& sql) override;
     int32_t Bind(const std::vector<ValueObject>& args) override;
+    std::pair<int32_t, int32_t> Count() override;
     int32_t Step() override;
     int32_t Reset() override;
     int32_t Execute(const std::vector<ValueObject>& args) override;
@@ -54,8 +57,11 @@ private:
     int Prepare(GRD_DB *db, const std::string &sql);
     int InnerBindBlobTypeArgs(const ValueObject &bindArg, uint32_t index) const;
     int IsValid(int index) const;
+    void ReportDbCorruptedEvent(int errorCode);
 
     bool readOnly_ = false;
+    bool isStepInPrepare_ = false;
+    int stepCnt_ = 0;
     std::string sql_ = "";
     GRD_SqlStmt *stmtHandle_ = nullptr;
     GRD_DB *dbHandle_ = nullptr;
@@ -64,6 +70,7 @@ private:
 
     std::map<std::string, std::function<int32_t(const int &value)>> setPragmas_;
     std::map<std::string, std::function<int32_t(int &version)>> getPragmas_;
+    const RdbStoreConfig *config_ = nullptr;
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/include/rdb_security_manager.h b/relational_store/frameworks/native/rdb/include/rdb_security_manager.h
index e0d93beabc9c3cfe13ee427ac3f59d4355578376..375fc497d3d2bb20c9a14e1d56ded84c2631c7eb 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_security_manager.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_security_manager.h
@@ -21,17 +21,12 @@
 #include <unistd.h>
 
 #include <atomic>
-#include <chrono>
 #include <climits>
-#include <list>
-#include <map>
-#include <memory>
 #include <mutex>
 #include <random>
 #include <vector>
 
 #include "hks_type.h"
-#include "rdb_errno.h"
 
 namespace OHOS::NativeRdb {
 struct RdbSecretKeyData {
@@ -68,38 +63,53 @@ private:
 
 class RdbSecurityManager {
 public:
-    enum class KeyFileType {
-        PUB_KEY_FILE = 1,
-        PUB_KEY_FILE_NEW_KEY
+    enum KeyFileType : int32_t {
+        PUB_KEY_FILE = 0,
+        PUB_KEY_FILE_NEW_KEY,
+        PUB_KEY_FILE_BUTT
+    };
+    class KeyFiles {
+    public:
+        KeyFiles(const std::string &dbPath, bool openFile = true);
+        ~KeyFiles();
+        const std::string &GetKeyFile(KeyFileType type);
+        int32_t DestroyLock();
+        int32_t Lock();
+        int32_t Unlock();
+
+    private:
+        int32_t lockFd_ = -1;
+        std::string lock_;
+        std::string keys_[PUB_KEY_FILE_BUTT];
     };
-
-    RdbPassword GetRdbPassword(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType);
-    void DelRdbSecretDataFile(const std::string &dbPath);
-    void DelRdbSecretDataFile(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType);
     static RdbSecurityManager &GetInstance();
     int32_t Init(const std::string &bundleName);
-    void UpdateKeyFile(const std::string &dbPath);
-    bool IsKeyFileExists(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType);
+
+    RdbPassword GetRdbPassword(const std::string &dbPath, KeyFileType keyFileType);
+    void DelAllKeyFiles(const std::string &dbPath);
+    void DelKeyFile(const std::string &dbPath, KeyFileType keyFileType);
+    void ChangeKeyFile(const std::string &dbPath);
+    int32_t RestoreKeyFile(const std::string &dbPath, const std::vector<uint8_t> &key);
+    bool IsKeyFileExists(const std::string &dbPath, KeyFileType keyFileType);
 
 private:
     RdbSecurityManager();
     ~RdbSecurityManager();
 
+    bool HasRootKey();
     int GenerateRootKey(const std::vector<uint8_t> &rootKeyAlias);
     int32_t CheckRootKeyExists(std::vector<uint8_t> &rootKeyAlias);
-    bool HasRootKey();
     std::vector<uint8_t> EncryptWorkKey(std::vector<uint8_t> &key);
     bool DecryptWorkKey(std::vector<uint8_t> &source, std::vector<uint8_t> &key);
     std::vector<uint8_t> GenerateRootKeyAlias(const std::string &bundleName);
-    bool InitPath(const std::string &dbKeyDir);
-    std::pair<std::string, std::string> ConcatenateKeyPath(const std::string &dbPath);
+    static bool InitPath(const std::string &fileDir);
     std::vector<uint8_t> GenerateRandomNum(int32_t len);
-    bool SaveSecretKeyToFile(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType);
+    bool SaveSecretKeyToFile(const std::string &keyFile, const std::vector<uint8_t> &workey = {});
     bool SaveSecretKeyToDisk(const std::string &keyPath, RdbSecretKeyData &keyData);
-    RdbPassword LoadSecretKeyFromFile(const std::string &dbPath, KeyFileType keyFileType);
+    RdbPassword LoadSecretKeyFromFile(const std::string &keyFile);
     bool LoadSecretKeyFromDisk(const std::string &keyPath, RdbSecretKeyData &keyData);
+    bool IsKeyFileEmpty(const std::string &keyFile);
     static bool IsKeyExpired(const time_t &createTime) ;
-    std::string GetKeyPath(const std::string &dbPath, KeyFileType keyFileType);
     int32_t HksLoopUpdate(const struct HksBlob *handle, const struct HksParamSet *paramSet,
         const struct HksBlob *inData, struct HksBlob *outData);
     int32_t HksEncryptThreeStage(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet,
@@ -107,15 +117,16 @@ private:
     int32_t HksDecryptThreeStage(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet,
         const struct HksBlob *cipherText, struct HksBlob *plainText);
 
+    static constexpr char const *SUFFIX_KEY_LOCK = ".key_lock";
     static constexpr char const *SUFFIX_PUB_KEY = ".pub_key";
     static constexpr char const *SUFFIX_PUB_KEY_NEW = ".pub_key.new";
     static constexpr const char *RDB_ROOT_KEY_ALIAS_PREFIX = "DistributedDataRdb";
     static constexpr const char *RDB_HKS_BLOB_TYPE_NONCE = "Z5s0Bo571Koq";
     static constexpr const char *RDB_HKS_BLOB_TYPE_AAD = "RdbClientAAD";
-    static const uint32_t TIMES = 4;
-    static const uint32_t MAX_UPDATE_SIZE = 64;
-    static const uint32_t MAX_OUTDATA_SIZE = MAX_UPDATE_SIZE * TIMES;
-    static const uint8_t AEAD_LEN = 16;
+    static constexpr uint32_t TIMES = 4;
+    static constexpr uint32_t MAX_UPDATE_SIZE = 64;
+    static constexpr uint32_t MAX_OUTDATA_SIZE = MAX_UPDATE_SIZE * TIMES;
+    static constexpr uint8_t AEAD_LEN = 16;
     static constexpr int RDB_KEY_SIZE = 32;
 
     static constexpr int HOURS_PER_YEAR = (24 * 365);
diff --git a/relational_store/frameworks/native/rdb/include/rdb_service_proxy.h b/relational_store/frameworks/native/rdb/include/rdb_service_proxy.h
index 14a76de94724726f7ea176367fb66775b5b88a88..a2d1e9668a7642e8a52e91651fd5e863600faac4 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_service_proxy.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_service_proxy.h
@@ -71,12 +71,20 @@ public:
 
     int32_t Delete(const RdbSyncerParam &param) override;
 
-    int32_t NotifyDataChange(const RdbSyncerParam& param, const RdbChangedData &clientChangedData) override;
+    int32_t NotifyDataChange(const RdbSyncerParam& param, const RdbChangedData &clientChangedData,
+        const RdbNotifyConfig &rdbNotifyConfig) override;
+
+    int32_t SetSearchable(const RdbSyncerParam& param, bool isSearchable) override;
 
     std::pair<int32_t, std::shared_ptr<ResultSet>> QuerySharingResource(const RdbSyncerParam &param,
         const PredicatesMemo &predicates, const std::vector<std::string> &columns) override;
     int32_t Disable(const RdbSyncerParam& param) override;
     int32_t Enable(const RdbSyncerParam& param) override;
+    int32_t GetPassword(const RdbSyncerParam& param, std::vector<uint8_t> &key) override;
+
+    std::pair<int32_t, uint32_t> LockCloudContainer(const RdbSyncerParam& param) override;
+
+    int32_t UnlockCloudContainer(const RdbSyncerParam& param) override;
 
 private:
     using ChangeInfo = RdbStoreObserver::ChangeInfo;
@@ -97,9 +105,9 @@ private:
     int32_t DoSubscribe(const RdbSyncerParam& param, const SubscribeOption &option);
 
     int32_t DoUnSubscribe(const RdbSyncerParam& param);
-	
+
     int32_t DoRegister(const RdbSyncerParam &param);
-	
+
     int32_t DoUnRegister(const RdbSyncerParam &param);
 
     uint32_t GetSeqNum();
diff --git a/relational_store/frameworks/native/rdb/include/rdb_sql_statistic.h b/relational_store/frameworks/native/rdb/include/rdb_sql_statistic.h
index 2427cff7da75ba2b32014f2df1bdbc8ed5b55cf5..46252cf66289a197f3a4f32e69decddf6249faf0 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_sql_statistic.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_sql_statistic.h
@@ -19,11 +19,13 @@
 #include <chrono>
 #include <memory>
 
-#include "concurrent_map.h"
 #include "rdb_types.h"
 #include "rdb_visibility.h"
 
-namespace OHOS::DistributedRdb {
+namespace OHOS {
+template<typename _Key, typename _Tp>
+class ConcurrentMap;
+namespace DistributedRdb {
 class SqlStatistic  {
 public:
     enum Step : int32_t {
@@ -54,4 +56,5 @@ private:
     std::shared_ptr<SqlExecInfo> execInfo_;
 };
 }
+}
 #endif // OHOS_DISTRIBUTED_DATA_RELATIONAL_STORE_FRAMEWORKS_NATIVE_RDB_SQL_STATISTIC_H
diff --git a/relational_store/frameworks/native/rdb/include/rdb_store_impl.h b/relational_store/frameworks/native/rdb/include/rdb_store_impl.h
index 68a2d7eeb788cf55cebb21afd9167e2c58adde5d..69f247ae12a623c1d4d0769042510d0272c6108e 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_store_impl.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_store_impl.h
@@ -24,6 +24,7 @@
 #include <thread>
 
 #include "concurrent_map.h"
+#include "connection_pool.h"
 #include "data_ability_observer_stub.h"
 #include "dataobs_mgr_client.h"
 #include "rdb_errno.h"
@@ -32,10 +33,8 @@
 #include "rdb_store_config.h"
 #include "rdb_types.h"
 #include "refbase.h"
-#include "sqlite_connection_pool.h"
 #include "sqlite_statement.h"
 #include "value_object.h"
-#include "rd_statement.h"
 
 namespace OHOS {
 class ExecutorPool;
@@ -133,6 +132,7 @@ public:
     bool IsReadOnly() const override;
     bool IsMemoryRdb() const override;
     bool IsHoldingConnection() override;
+    bool IsSlaveDiffFromMaster() const override;
     int ConfigLocale(const std::string &localeStr);
     int Restore(const std::string &backupPath, const std::vector<uint8_t> &newKey) override;
     std::string GetName();
@@ -177,6 +177,8 @@ public:
 
     int Notify(const std::string &event) override;
 
+    int SetSearchable(bool isSearchable) override;
+
     ModifyTime GetModifyTime(const std::string& table, const std::string& columnName,
         std::vector<PRIKey>& keys) override;
 
@@ -186,11 +188,17 @@ public:
         const RdbStoreConfig &config, const std::string &attachName, int32_t waitTime = 2) override;
     std::pair<int32_t, int32_t> Detach(const std::string &attachName, int32_t waitTime = 2) override;
     int ModifyLockStatus(const AbsRdbPredicates &predicates, bool isLock) override;
-    void AfterOpen(const RdbStoreConfig &config);
     int32_t GetDbType() const override;
+    void AfterOpen(const RdbStoreConfig &config);
+    std::pair<int32_t, uint32_t> LockCloudContainer() override;
+    int32_t UnlockCloudContainer() override;
+    int InterruptBackup() override;
+    int32_t GetBackupStatus() const override;
+    int32_t ExchangeSlaverToMaster();
 
 protected:
     int InnerOpen();
+    void InitSyncerParam();
     const RdbStoreConfig config_;
     bool isOpen_ = false;
     bool isReadOnly_;
@@ -198,12 +206,11 @@ protected:
     bool isEncrypt_;
     int64_t vSchema_ = 0;
     std::string path_;
-    std::string orgPath_;
     std::string name_;
     std::string fileType_;
 
 private:
-    std::map<int64_t, std::shared_ptr<Connection>> trxConnMap_ = {};
+    ConcurrentMap<int64_t, std::shared_ptr<Connection>> trxConnMap_ = {};
     std::atomic<int64_t> newTrxId_ = 1;
     int ExecuteByTrxId(const std::string &sql, int64_t trxId, bool closeConnAfterExecute = false,
         const std::vector<ValueObject> &bindArgs = {});
@@ -229,6 +236,7 @@ private:
     int SubscribeLocalShared(const SubscribeOption& option, RdbStoreObserver *observer);
     int32_t SubscribeLocalDetail(const SubscribeOption& option, const std::shared_ptr<RdbStoreObserver> &observer);
     int SubscribeRemote(const SubscribeOption& option, RdbStoreObserver *observer);
+    static void UploadSchema(const DistributedRdb::RdbSyncerParam &param, uint32_t retry);
 
     int UnSubscribeLocal(const SubscribeOption& option, RdbStoreObserver *observer);
     int UnSubscribeLocalAll(const SubscribeOption& option);
@@ -243,7 +251,6 @@ private:
     std::pair<int32_t, Stmt> GetStatement(const std::string& sql, bool read = false) const;
     int AttachInner(const std::string &attachName,
         const std::string &dbPath, const std::vector<uint8_t> &key, int32_t waitTime);
-    std::string GetSecManagerName(const RdbStoreConfig &config);
     void RemoveDbFiles(std::string &path);
     int GetHashKeyForLockRow(const AbsRdbPredicates &predicates, std::vector<std::vector<uint8_t>> &hashKeys);
     int InsertWithConflictResolutionEntry(int64_t &outRowId, const std::string &table, const ValuesBucket &values,
@@ -255,7 +262,11 @@ private:
     int ExecuteSqlEntry(const std::string& sql, const std::vector<ValueObject>& bindArgs);
     std::pair<int32_t, ValueObject> ExecuteEntry(const std::string& sql, const std::vector<ValueObject>& bindArgs,
         int64_t trxId);
-    static void UploadSchema(const DistributedRdb::RdbSyncerParam &param, uint32_t retry);
+    int GetSlaveName(const std::string &dbName, std::string &backupFilePath);
+    bool TryGetMasterSlaveBackupPath(const std::string &srcPath, std::string &destPath, bool isRestore = false);
+    void NotifyDataChange();
+    int GetDestPath(const std::string &backupPath, std::string &destPath);
+    void ReportDbRestoreSuccessEvent();
 
     static constexpr char SCHEME_RDB[] = "rdb://";
     static constexpr uint32_t EXPANSION = 2;
@@ -264,7 +275,7 @@ private:
     static inline constexpr uint32_t MAX_RETRY_TIMES = 5;
     static constexpr const char *ROW_ID = "ROWID";
 
-    std::shared_ptr<SqliteConnectionPool> connectionPool_ = nullptr;
+    std::shared_ptr<ConnectionPool> connectionPool_ = nullptr;
     DistributedRdb::RdbSyncerParam syncerParam_;
 
     std::shared_ptr<ExecutorPool> pool_;
@@ -280,6 +291,7 @@ private:
     std::map<std::string, std::list<sptr<RdbStoreLocalSharedObserver>>> localSharedObservers_;
     ConcurrentMap<std::string, std::string> attachedInfo_;
     uint32_t rebuild_;
+    SlaveStatus slaveStatus_;
 };
 } // namespace OHOS::NativeRdb
 #endif
diff --git a/relational_store/frameworks/native/rdb/include/rdb_store_manager.h b/relational_store/frameworks/native/rdb/include/rdb_store_manager.h
index 42e967db866443fec0d71457a300fdadd83597c5..1d42e91b9b79bcb958f952db53ed20085cc02fe7 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_store_manager.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_store_manager.h
@@ -16,6 +16,7 @@
 #ifndef NATIVE_RDB_STORE_MANAGER_H
 #define NATIVE_RDB_STORE_MANAGER_H
 
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <string>
diff --git a/relational_store/frameworks/native/rdb/include/rdb_types_util.h b/relational_store/frameworks/native/rdb/include/rdb_types_util.h
index 6c231bdba294ed33d891b5202b4d1b67c102fd02..2788a592c4bb5e1572438bb7165e0fa6c46bb30e 100644
--- a/relational_store/frameworks/native/rdb/include/rdb_types_util.h
+++ b/relational_store/frameworks/native/rdb/include/rdb_types_util.h
@@ -26,6 +26,7 @@
 namespace OHOS::ITypesUtil {
 using SubOption = DistributedRdb::SubscribeOption;
 using SyncerParam = DistributedRdb::RdbSyncerParam;
+using NotifyConfig = DistributedRdb::RdbNotifyConfig;
 using Option = DistributedRdb::RdbService::Option;
 using RdbPredicates = DistributedRdb::PredicatesMemo;
 using RdbOperation = DistributedRdb::RdbPredicateOperation;
@@ -49,6 +50,10 @@ API_EXPORT bool Marshalling(const SyncerParam &input, MessageParcel &data);
 template<>
 API_EXPORT bool Unmarshalling(SyncerParam &output, MessageParcel &data);
 template<>
+API_EXPORT bool Marshalling(const NotifyConfig &input, MessageParcel &data);
+template<>
+API_EXPORT bool Unmarshalling(NotifyConfig &output, MessageParcel &data);
+template<>
 API_EXPORT bool Marshalling(const Option &input, MessageParcel &data);
 template<>
 API_EXPORT bool Unmarshalling(Option &output, MessageParcel &data);
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_connection.h b/relational_store/frameworks/native/rdb/include/sqlite_connection.h
index 03775c7590365a889e2ea02794747bf62500b0c3..1aacb6820bd31a50fa6d46dff9b401db8089bdb8 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_connection.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_connection.h
@@ -16,6 +16,7 @@
 #ifndef NATIVE_RDB_SQLITE_CONNECTION_H
 #define NATIVE_RDB_SQLITE_CONNECTION_H
 
+#include <atomic>
 #include <cstdint>
 #include <list>
 #include <memory>
@@ -27,6 +28,7 @@
 #include "rdb_store_config.h"
 #include "sqlite3sym.h"
 #include "sqlite_statement.h"
+#include "task_executor.h"
 #include "value_object.h"
 
 typedef struct ClientChangedData ClientChangedData;
@@ -40,7 +42,9 @@ using DataChangeCallback = std::function<void(ClientChangedData &clientChangedDa
 class SqliteConnection : public Connection {
 public:
     static std::pair<int32_t, std::shared_ptr<Connection>> Create(const RdbStoreConfig &config, bool isWrite);
-    static void DeleteDbFile(const RdbStoreConfig &config);
+    static int32_t Delete(const RdbStoreConfig &config);
+    static int32_t Repair(const RdbStoreConfig &config);
+    SqliteConnection(const RdbStoreConfig &config, bool isWriteConnection);
     ~SqliteConnection();
     int32_t OnInitialize() override;
     int TryCheckPoint() override;
@@ -59,24 +63,27 @@ public:
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) override;
     int32_t Unsubscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) override;
-    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
-    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
+    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        bool isAsync, SlaveStatus &slaveStatus) override;
+    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        SlaveStatus &slaveStatus) override;
+    ExchangeStrategy GenerateExchangeStrategy(const SlaveStatus &status) override;
 
 protected:
     std::pair<int32_t, ValueObject> ExecuteForValue(const std::string &sql,
         const std::vector<ValueObject> &bindArgs = std::vector<ValueObject>());
     int ExecuteSql(const std::string &sql, const std::vector<ValueObject> &bindArgs = std::vector<ValueObject>());
-    int ExecuteEncryptSql(const RdbStoreConfig &config, uint32_t iter);
-    void SetInTransaction(bool transaction);
 
 private:
     static constexpr const char *MERGE_ASSETS_FUNC = "merge_assets";
-    explicit SqliteConnection(bool isWriteConnection);
-    int InnerOpen(const RdbStoreConfig &config, uint32_t retry);
-    int Configure(const RdbStoreConfig &config, uint32_t retry, std::string &dbPath);
+    static constexpr const char *MERGE_ASSET_FUNC = "merge_asset";
+    int InnerOpen(const RdbStoreConfig &config);
+    int Configure(const RdbStoreConfig &config, std::string &dbPath);
     int SetPageSize(const RdbStoreConfig &config);
-    std::string GetSecManagerName(const RdbStoreConfig &config);
-    int SetEncryptKey(const RdbStoreConfig &config, uint32_t iter);
+    int SetEncrypt(const RdbStoreConfig &config);
+    int SetEncryptKey(const std::vector<uint8_t> &key, int32_t iter);
+    int SetServiceKey(const RdbStoreConfig &config, int32_t errCode);
+    int SetEncryptAgo(int32_t iter);
     int SetJournalMode(const RdbStoreConfig &config);
     int SetJournalSizeLimit(const RdbStoreConfig &config);
     int SetAutoCheckpoint(const RdbStoreConfig &config);
@@ -88,6 +95,7 @@ private:
 
     int RegDefaultFunctions(sqlite3 *dbHandle);
     static void MergeAssets(sqlite3_context *ctx, int argc, sqlite3_value **argv);
+    static void MergeAsset(sqlite3_context *ctx, int argc, sqlite3_value **argv);
     static void CompAssets(std::map<std::string, ValueObject::Asset> &oldAssets,
         std::map<std::string, ValueObject::Asset> &newAssets);
     static void MergeAsset(ValueObject::Asset &oldAsset, ValueObject::Asset &newAsset);
@@ -98,29 +106,38 @@ private:
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer);
     int32_t UnsubscribeLocalDetailAll(const std::string &event);
     int32_t OpenDatabase(const std::string &dbPath, int openFileFlags);
-    void ReadFile2Buffer(const char* fileName);
+    int LoadExtension(const RdbStoreConfig &config, sqlite3 *dbHandle);
+    RdbStoreConfig GetSlaveRdbStoreConfig(const RdbStoreConfig rdbConfig);
+    void ReportDbCorruptedEvent(int errCode, const std::string &checkResultInfo);
+    int CreateSlaveConnection(const RdbStoreConfig &config, bool isWrite, bool checkSlaveExist = true);
+    int ExchangeSlaverToMaster(bool isRestore, SlaveStatus &status);
+    bool IsRepairable();
+    std::pair<bool, int> ExchangeVerify(bool isRestore);
+    static std::pair<int32_t, std::shared_ptr<SqliteConnection>> InnerCreate(const RdbStoreConfig &config,
+        bool isWrite);
 
-    static constexpr uint32_t BUFFER_LEN = 16;
     static constexpr int DEFAULT_BUSY_TIMEOUT_MS = 2000;
+    static constexpr int BACKUP_PAGES_PRE_STEP = 12800; // 1024 * 4 * 12800 == 50m
+    static constexpr int BACKUP_PRE_WAIT_TIME = 10;
     static constexpr uint32_t NO_ITER = 0;
-    static constexpr uint32_t ITER_V1 = 5000;
-    static constexpr uint32_t ITERS[] = { NO_ITER, ITER_V1 };
-    static constexpr uint32_t ITERS_COUNT = sizeof(ITERS) / sizeof(ITERS[0]);
-    static const int32_t regCreater_;
-    static const int32_t regFileDeleter_;
+    static const int32_t regCreator_;
+    static const int32_t regRepairer_;
+    static const int32_t regDeleter_;
 
-    sqlite3 *dbHandle;
+    std::atomic<TaskExecutor::TaskId> backupId_ = TaskExecutor::INVALID_TASK_ID;
+    sqlite3 *dbHandle_;
     bool isWriter_;
-    bool isReadOnly;
+    bool isReadOnly_;
     bool isConfigured_ = false;
     bool hasClientObserver_ = false;
     JournalMode mode_ = JournalMode::MODE_WAL;
-    int openFlags;
     int maxVariableNumber_;
     std::mutex mutex_;
     std::string filePath;
+    std::shared_ptr<SqliteConnection> slaveConnection_;
     std::map<std::string, ScalarFunctionInfo> customScalarFunctions_;
-    std::map<std::string, std::list<std::shared_ptr<RdbStoreLocalDbObserver>>> rdbStoreLocalDbObservers_;
+    std::map<std::string, std::list<std::shared_ptr<RdbStoreLocalDbObserver>>> observers_;
+    const RdbStoreConfig config_;
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_errno.h b/relational_store/frameworks/native/rdb/include/sqlite_errno.h
index 90625e73ed3cc6467d41eea97ec94ab96371a0b1..03aab636d686327f49449ae98edb085e000f75c4 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_errno.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_errno.h
@@ -35,6 +35,7 @@ const static std::map<int, int> ERROR_CODE_MAPPINT_TABLE = {
     { SQLITE_IOERR, E_SQLITE_IOERR },
     { SQLITE_CORRUPT, E_SQLITE_CORRUPT },
     { SQLITE_FULL, E_SQLITE_FULL },
+    { SQLITE_SCHEMA, E_SQLITE_SCHEMA },
     { SQLITE_CANTOPEN, E_SQLITE_CANTOPEN },
     { SQLITE_TOOBIG, E_SQLITE_TOOBIG },
     { SQLITE_CONSTRAINT, E_SQLITE_CONSTRAINT },
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_global_config.h b/relational_store/frameworks/native/rdb/include/sqlite_global_config.h
index 00399d470bf38c3d71396d4670dc12a71fce38eb..f1171d1a14fe04ecc78834f359c2477b1ad038d9 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_global_config.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_global_config.h
@@ -30,8 +30,8 @@ public:
     static constexpr int SOFT_HEAP_LIMIT = 8 * 1024 * 1024; /* 8MB */
     static constexpr int DB_PAGE_SIZE = 4096;    /* default page size : 4k */
     static constexpr int DB_JOURNAL_SIZE = 1024 * 1024; /* default file size : 1M */
-    static constexpr int DB_WAL_SIZE_LIMIT_MIN = 20 * 1024 * 1024; /* default wal file maximum size : 20M */
-    static constexpr int DB_WAL_SIZE_LIMIT_MAX = 200 * 1024 * 1024; /* default wal file maximum size : 200M */
+    static constexpr uint32_t DB_WAL_SIZE_LIMIT_MIN = 20 * 1024 * 1024; /* default wal file maximum size : 20M */
+    static constexpr uint32_t DB_WAL_SIZE_LIMIT_MAX = 1024 * 1024 * 1024; /* default wal file maximum size : 1G */
     static constexpr int WAL_AUTO_CHECKPOINT = 100;  /* 100 pages */
     static constexpr int APP_DEFAULT_UMASK = 0002;
     static constexpr int SQLITE_MAX_COLUMN = 2000;
@@ -44,10 +44,8 @@ public:
     static constexpr char PRAGMA_JOUR_MODE_EXP[] = "PRAGMA journal_mode";
     static constexpr char PRAGMA_VERSION[] = "PRAGMA user_version";
     static constexpr char JOURNAL_MODE_WAL[] = "WAL";
-    static constexpr char JOURNAL_MODE_DELETE[] = "DELETE";
     static constexpr char DEFAULE_SYNC_MODE[] = "FULL";
     static constexpr char MEMORY_DB_PATH[] = ":memory:";
-    static constexpr char ENCRYPT_ALGO[] = "sha256";
     static constexpr char CODEC_HMAC_ALGO[] = "PRAGMA codec_hmac_algo=sha256";
     static constexpr char CODEC_REKEY_HMAC_ALGO[] = "PRAGMA codec_rekey_hmac_algo=sha256";
     static constexpr char CIPHER_DEFAULT_ALGO[] = "PRAGMA codec_cipher='aes-256-gcm'";
@@ -61,7 +59,6 @@ public:
     ~SqliteGlobalConfig();
     static void InitSqliteGlobalConfig();
     static void Log(const void *data, int err, const char *msg);
-    static int GetReadConnectionCount();
     static std::string GetMemoryDbPath();
     static int GetPageSize();
     static std::string GetSyncMode();
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_shared_result_set.h b/relational_store/frameworks/native/rdb/include/sqlite_shared_result_set.h
index 2faf9e0d0e10c54557e68de18441973327d95632..6dc8ca05d190e3d322ed5fe7448a80aad506c310 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_shared_result_set.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_shared_result_set.h
@@ -26,7 +26,7 @@
 #include "abs_shared_result_set.h"
 #include "connection.h"
 #include "shared_block.h"
-#include "sqlite_connection_pool.h"
+#include "connection_pool.h"
 #include "statement.h"
 #include "value_object.h"
 
@@ -34,7 +34,7 @@ namespace OHOS {
 namespace NativeRdb {
 class SqliteSharedResultSet : public AbsSharedResultSet {
 public:
-    SqliteSharedResultSet(std::shared_ptr<SqliteConnectionPool> pool, std::string path,
+    SqliteSharedResultSet(std::shared_ptr<ConnectionPool> pool, std::string path,
         std::string sql, const std::vector<ValueObject> &bindArgs);
     ~SqliteSharedResultSet() override;
     int Close() override;
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_sql_builder.h b/relational_store/frameworks/native/rdb/include/sqlite_sql_builder.h
index 16ad934d8730d67f350a4a3e75a58352c9038004..656dd27379a3664e2ddcbea3f1a2ede1dce58e2d 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_sql_builder.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_sql_builder.h
@@ -63,6 +63,8 @@ private:
         std::string &builder, const std::vector<std::string> &columns, const std::string &table = "");
 
     static constexpr const char *SHARING_RESOURCE = "sharing_resource";
+
+    static std::string HandleTable(const std::string &tableName);
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_statement.h b/relational_store/frameworks/native/rdb/include/sqlite_statement.h
index 127a5baaf00cabb030724d1da9cae99ce4108486..e4d8988398276f9971968c05ba97e4a8afb9cf74 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_statement.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_statement.h
@@ -23,6 +23,7 @@
 #include "sqlite3sym.h"
 #include "statement.h"
 #include "value_object.h"
+#include "rdb_store_config.h"
 
 namespace OHOS {
 namespace NativeRdb {
@@ -38,6 +39,7 @@ public:
     ~SqliteStatement();
     int Prepare(const std::string &sql) override;
     int Bind(const std::vector<ValueObject> &args) override;
+    std::pair<int32_t, int32_t> Count() override;
     int Step() override;
     int Reset() override;
     int Finalize() override;
@@ -81,7 +83,18 @@ private:
     int Prepare(sqlite3 *dbHandle, const std::string &sql);
     int BindArgs(const std::vector<ValueObject> &bindArgs);
     int IsValid(int index) const;
+    int InnerStep();
+    int InnerFinalize();
     ValueObject GetValueFromBlob(int32_t index, int32_t type) const;
+    void ReportDbCorruptedEvent(int errorCode);
+    void ReadFile2Buffer();
+    void PrintInfoForDbError(int errorCode);
+
+    static constexpr uint32_t BUFFER_LEN = 16;
+
+    static constexpr int MAX_RETRY_TIMES = 50;
+    // Interval of retrying query in millisecond
+    static constexpr int RETRY_INTERVAL = 1000;
 
     bool readOnly_;
     bool bound_ = false;
@@ -92,6 +105,8 @@ private:
     std::shared_ptr<Connection> conn_;
     std::string sql_;
     mutable std::vector<int32_t> types_;
+    std::shared_ptr<SqliteStatement> slave_;
+    const RdbStoreConfig *config_ = nullptr;
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_utils.h b/relational_store/frameworks/native/rdb/include/sqlite_utils.h
index 3b7dcccc07d4251c8a523b2fbc2142881b295372..22b2fbc61100ea14459033d0d6782105f83316f0 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_utils.h
+++ b/relational_store/frameworks/native/rdb/include/sqlite_utils.h
@@ -19,6 +19,8 @@
 #include <map>
 #include <string>
 
+#include "sqlite3sym.h"
+
 namespace OHOS {
 namespace NativeRdb {
 
@@ -37,6 +39,9 @@ public:
     static constexpr int STATEMENT_ERROR = 11;
     static constexpr int STATEMENT_OTHER = 99;
     static constexpr int CONFLICT_CLAUSE_COUNT = 6;
+    static constexpr int DISABLE_LOAD_EXTENSION = 0;
+    static constexpr int ENABLE_LOAD_EXTENSION = 1;
+    static constexpr int MAX_LOAD_EXTENSION_COUNT = 16;
     static constexpr const char* REP = "#_";
 
     static int GetSqlStatementType(const std::string &sql);
@@ -47,9 +52,14 @@ public:
     static std::string StrToUpper(std::string s);
     static void Replace(std::string &src, const std::string &rep, const std::string &dst);
     static bool DeleteFile(const std::string &filePath);
-    static int RenameFile(const std::string &srcFile, const std::string &destFile);
+    static bool RenameFile(const std::string &srcFile, const std::string &destFile);
+    static bool CopyFile(const std::string &srcFile, const std::string &destFile);
     static std::string Anonymous(const std::string &srcFile);
     static int GetFileSize(const std::string &fileName);
+    static bool IsSlaveDbName(const std::string &fileName);
+    static std::string GetSlavePath(const std::string& name);
+    static bool TryAccessSlaveLock(const std::string &dbPath, bool isDelete, bool needCreate,
+        bool isSlaveFailure = false);
 
 private:
     struct SqlType {
@@ -70,6 +80,7 @@ private:
         { "PRA", SqliteUtils::STATEMENT_PRAGMA },
         { "REP", SqliteUtils::STATEMENT_UPDATE },
         { "ROL", SqliteUtils::STATEMENT_ROLLBACK },
+        { "SAV", SqliteUtils::STATEMENT_BEGIN },
         { "SEL", SqliteUtils::STATEMENT_SELECT },
         { "UPD", SqliteUtils::STATEMENT_UPDATE }
     };
diff --git a/relational_store/frameworks/native/rdb/include/statement.h b/relational_store/frameworks/native/rdb/include/statement.h
index 78c0a6cd3d538befa12beacf8778966804a782d4..400bcff86611dcc33f62e005544349a27ca15bed 100644
--- a/relational_store/frameworks/native/rdb/include/statement.h
+++ b/relational_store/frameworks/native/rdb/include/statement.h
@@ -34,6 +34,7 @@ public:
     virtual ~Statement() = default;
     virtual int32_t Prepare(const std::string &sql) = 0;
     virtual int32_t Bind(const std::vector<ValueObject> &args = {}) = 0;
+    virtual std::pair<int32_t, int32_t> Count() = 0;
     virtual int32_t Step() = 0;
     virtual int32_t Reset() = 0;
     virtual int32_t Finalize() = 0;
@@ -56,6 +57,8 @@ public:
     {
         return 0;
     }
+
+    static constexpr int INVALID_COUNT = -1;
 };
 } // namespace OHOS::NativeRdb
 #endif // OHOS_DISTRIBUTED_DATA_RELATIONAL_STORE_FRAMEWORKS_NATIVE_RDB_INCLUDE_STATEMENT_H
diff --git a/relational_store/frameworks/native/rdb/include/step_result_set.h b/relational_store/frameworks/native/rdb/include/step_result_set.h
index 7c11cfc6d470dfe265ae255f0951626522a33a4a..ef09497f01821f135900dd33bb9b3945a6c1c714 100644
--- a/relational_store/frameworks/native/rdb/include/step_result_set.h
+++ b/relational_store/frameworks/native/rdb/include/step_result_set.h
@@ -23,14 +23,14 @@
 
 #include "abs_result_set.h"
 #include "connection.h"
-#include "sqlite_connection_pool.h"
+#include "connection_pool.h"
 #include "statement.h"
 
 namespace OHOS {
 namespace NativeRdb {
 class StepResultSet : public AbsResultSet {
 public:
-    StepResultSet(std::shared_ptr<SqliteConnectionPool> pool, const std::string &sql,
+    StepResultSet(std::shared_ptr<ConnectionPool> pool, const std::string &sql,
         const std::vector<ValueObject> &selectionArgs);
     ~StepResultSet() override;
     int GetColumnType(int columnIndex, ColumnType &columnType) override;
@@ -39,6 +39,7 @@ public:
     int GetSize(int columnIndex, size_t &size) override;
     int Get(int32_t col, ValueObject &value) override;
     int Close() override;
+    int GetRowCount(int &count) override;
 
 protected:
     std::pair<int, std::vector<std::string>> GetColumnNames() override;
@@ -58,6 +59,7 @@ private:
     static const int STEP_QUERY_RETRY_INTERVAL = 1000;
     static const int EMPTY_ROW_COUNT = 0;
 
+    bool isSupportCountRow_ = true;
     std::shared_ptr<Statement> sqliteStatement_;
     std::shared_ptr<Connection> conn_;
 
diff --git a/relational_store/frameworks/native/rdb/mock/include/connection.h b/relational_store/frameworks/native/rdb/mock/include/connection.h
index be4d4c823392b15ad1145a0cc5f54d0c4a41e13a..5ce759bd91a43139bd5994a45b4ecfcdab7a9f15 100644
--- a/relational_store/frameworks/native/rdb/mock/include/connection.h
+++ b/relational_store/frameworks/native/rdb/mock/include/connection.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <utility>
 
+#include "rdb_common.h"
 #include "rdb_types.h"
 #include "statement.h"
 namespace OHOS::NativeRdb {
@@ -34,13 +35,13 @@ public:
     using Notifier = std::function<void(const std::set<std::string> &tables)>;
     using Creator = std::pair<int32_t, SConn> (*)(const RdbStoreConfig &config, bool isWriter);
     using Repairer = int32_t (*)(const RdbStoreConfig &config);
-    using Deleter = void (*)(const RdbStoreConfig &config);
+    using Deleter = int32_t (*)(const RdbStoreConfig &config);
     static std::pair<int32_t, SConn> Create(const RdbStoreConfig &config, bool isWriter);
     static int32_t Repair(const RdbStoreConfig &config);
-    static void DeleteDbFile(const RdbStoreConfig &config);
+    static int32_t Delete(const RdbStoreConfig &config);
     static int32_t RegisterCreator(int32_t dbType, Creator creator);
     static int32_t RegisterRepairer(int32_t dbType, Repairer repairer);
-    static int32_t RegisterFileDeleter(int32_t dbType, Deleter deleter);
+    static int32_t RegisterDeleter(int32_t dbType, Deleter deleter);
 
     int32_t SetId(int32_t id);
     int32_t GetId() const;
@@ -58,13 +59,15 @@ public:
     virtual int32_t GetMaxVariable() const = 0;
     virtual int32_t GetJournalMode() = 0;
     virtual int32_t ClearCache() = 0;
-    
     virtual int32_t Subscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) = 0;
     virtual int32_t Unsubscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) = 0;
-    virtual int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) = 0;
-    virtual int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) = 0;
+    virtual int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        bool isAsync, SlaveStatus &slaveStatus) = 0;
+    virtual int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        SlaveStatus &slaveStatus) = 0;
+    virtual ExchangeStrategy GenerateExchangeStrategy(const SlaveStatus &status) = 0;
 
 private:
     int32_t id_ = 0;
diff --git a/relational_store/frameworks/native/rdb/include/sqlite_connection_pool.h b/relational_store/frameworks/native/rdb/mock/include/connection_pool.h
similarity index 85%
rename from relational_store/frameworks/native/rdb/include/sqlite_connection_pool.h
rename to relational_store/frameworks/native/rdb/mock/include/connection_pool.h
index 7d28876d0993a1aeb743a18c6e22ac2d458fc3c9..291b29a9e341b288c43ecbb4c58409f84b8f06bc 100644
--- a/relational_store/frameworks/native/rdb/include/sqlite_connection_pool.h
+++ b/relational_store/frameworks/native/rdb/mock/include/connection_pool.h
@@ -1,139 +1,139 @@
-/*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef NATIVE_RDB_SQLITE_CONNECTION_POOL_H
-#define NATIVE_RDB_SQLITE_CONNECTION_POOL_H
-
-#include <atomic>
-#include <condition_variable>
-#include <iostream>
-#include <iterator>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <sstream>
-#include <stack>
-#include <vector>
-
-#include "base_transaction.h"
-#include "connection.h"
-#include "rdb_common.h"
-#include "rdb_store_config.h"
-#include "rd_statement.h"
-namespace OHOS {
-namespace NativeRdb {
-class SqliteConnectionPool : public std::enable_shared_from_this<SqliteConnectionPool> {
-public:
-    using SharedConn = std::shared_ptr<Connection>;
-    using SharedConns = std::vector<SharedConn>;
-    static constexpr std::chrono::milliseconds INVALID_TIME = std::chrono::milliseconds(0);
-    static std::shared_ptr<SqliteConnectionPool> Create(const RdbStoreConfig &storeConfig, int &errCode);
-    ~SqliteConnectionPool();
-    static std::pair<RebuiltType, std::shared_ptr<SqliteConnectionPool>> HandleDataCorruption
-        (const RdbStoreConfig &storeConfig, int &errCode);
-    std::pair<int32_t, std::shared_ptr<Connection>> CreateConnection(bool isReadOnly);
-    SharedConn AcquireConnection(bool isReadOnly);
-    SharedConn Acquire(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
-    // this interface is only provided for resultSet
-    SharedConn AcquireRef(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
-    std::pair<SharedConn, SharedConns> AcquireAll(int32_t time);
-    std::pair<int32_t, SharedConn> DisableWal();
-    int32_t EnableWal();
-    int RestartReaders();
-    int ConfigLocale(const std::string &localeStr);
-    int ChangeDbFileForRestore(const std::string &newPath, const std::string &backupPath,
-        const std::vector<uint8_t> &newKey);
-    std::stack<BaseTransaction> &GetTransactionStack();
-    std::mutex &GetTransactionStackMutex();
-    int AcquireTransaction();
-    void ReleaseTransaction();
-    void CloseAllConnections();
-    bool IsInTransaction();
-    void SetInTransaction(bool isInTransaction);
-
-private:
-    struct ConnNode {
-        bool using_ = false;
-        int32_t tid_ = 0;
-        int32_t id_ = 0;
-        std::chrono::steady_clock::time_point time_ = std::chrono::steady_clock::now();
-        std::shared_ptr<Connection> connect_;
-
-        explicit ConnNode(std::shared_ptr<Connection> conn);
-        std::shared_ptr<Connection> GetConnect();
-        int64_t GetUsingTime() const;
-        bool IsWriter() const;
-        void Unused();
-    };
-
-    struct Container {
-        using Creator = std::function<std::pair<int32_t, std::shared_ptr<Connection>>()>;
-        static constexpr int32_t MAX_RIGHT = 0x4FFFFFFF;
-        bool disable_ = true;
-        int max_ = 0;
-        int total_ = 0;
-        int count_ = 0;
-        int32_t left_ = 0;
-        int32_t right_ = 0;
-        std::chrono::seconds timeout_;
-        std::list<std::shared_ptr<ConnNode>> nodes_;
-        std::list<std::weak_ptr<ConnNode>> details_;
-        std::mutex mutex_;
-        std::condition_variable cond_;
-        Creator creator_ = nullptr;
-        std::pair<int32_t, std::shared_ptr<ConnNode>> Initialize(Creator creator, int32_t max, int32_t timeout,
-            bool disable, bool acquire = false);
-        int32_t ConfigLocale(const std::string &locale);
-        std::shared_ptr<ConnNode> Acquire(std::chrono::milliseconds milliS);
-        std::list<std::shared_ptr<ConnNode>> AcquireAll(std::chrono::milliseconds milliS);
-
-        void Disable();
-        void Enable();
-        int32_t Release(std::shared_ptr<ConnNode> node);
-        int32_t Clear();
-        bool IsFull();
-        int32_t Dump(const char *header);
-
-    private:
-        int32_t ExtendNode();
-        int32_t RelDetails(std::shared_ptr<ConnNode> node);
-    };
-
-    explicit SqliteConnectionPool(const RdbStoreConfig &storeConfig);
-    std::pair<int32_t, std::shared_ptr<Connection>> Init(const RdbStoreConfig &config, bool needWriter = false);
-    int32_t GetMaxReaders(const RdbStoreConfig &config);
-    std::shared_ptr<Connection> Convert2AutoConn(std::shared_ptr<ConnNode> node);
-    void ReleaseNode(std::shared_ptr<ConnNode> node);
-
-    void RemoveDBFile();
-    void RemoveDBFile(const std::string &path);
-
-    static constexpr int LIMITATION = 1024;
-    const RdbStoreConfig &config_;
-    Container writers_;
-    Container readers_;
-    int32_t maxReader_ = 0;
-
-    std::stack<BaseTransaction> transactionStack_;
-    std::mutex transactionStackMutex_;
-    std::condition_variable transCondition_;
-    std::mutex transMutex_;
-    bool transactionUsed_;
-    std::atomic<bool> isInTransaction_ = false;
-};
-
-} // namespace NativeRdb
-} // namespace OHOS
-#endif
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NATIVE_RDB_SQLITE_CONNECTION_POOL_H
+#define NATIVE_RDB_SQLITE_CONNECTION_POOL_H
+
+#include <atomic>
+#include <condition_variable>
+#include <iostream>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <stack>
+#include <vector>
+
+#include "base_transaction.h"
+#include "connection.h"
+#include "rdb_common.h"
+#include "rdb_store_config.h"
+namespace OHOS {
+namespace NativeRdb {
+class ConnectionPool : public std::enable_shared_from_this<ConnectionPool> {
+public:
+    using SharedConn = std::shared_ptr<Connection>;
+    using SharedConns = std::vector<SharedConn>;
+    static constexpr std::chrono::milliseconds INVALID_TIME = std::chrono::milliseconds(0);
+    static std::shared_ptr<ConnectionPool> Create(const RdbStoreConfig &storeConfig, int &errCode);
+    ~ConnectionPool();
+    static std::pair<RebuiltType, std::shared_ptr<ConnectionPool>> HandleDataCorruption
+        (const RdbStoreConfig &storeConfig, int &errCode);
+    std::pair<int32_t, std::shared_ptr<Connection>> CreateConnection(bool isReadOnly);
+    SharedConn AcquireConnection(bool isReadOnly);
+    SharedConn Acquire(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
+    // this interface is only provided for resultSet
+    SharedConn AcquireRef(bool isReadOnly, std::chrono::milliseconds ms = INVALID_TIME);
+    std::pair<SharedConn, SharedConns> AcquireAll(int32_t time);
+    std::pair<int32_t, SharedConn> DisableWal();
+    int32_t EnableWal();
+    int RestartReaders();
+    int ConfigLocale(const std::string &localeStr);
+    int ChangeDbFileForRestore(const std::string &newPath, const std::string &backupPath,
+        const std::vector<uint8_t> &newKey, SlaveStatus &slaveStatus);
+    std::stack<BaseTransaction> &GetTransactionStack();
+    std::mutex &GetTransactionStackMutex();
+    int AcquireTransaction();
+    void ReleaseTransaction();
+    void CloseAllConnections();
+    bool IsInTransaction();
+    void SetInTransaction(bool isInTransaction);
+
+private:
+    struct ConnNode {
+        bool using_ = false;
+        int32_t tid_ = 0;
+        int32_t id_ = 0;
+        std::chrono::steady_clock::time_point time_ = std::chrono::steady_clock::now();
+        std::shared_ptr<Connection> connect_;
+
+        explicit ConnNode(std::shared_ptr<Connection> conn);
+        std::shared_ptr<Connection> GetConnect();
+        int64_t GetUsingTime() const;
+        bool IsWriter() const;
+        int32_t Unused();
+    };
+
+    struct Container {
+        using Creator = std::function<std::pair<int32_t, std::shared_ptr<Connection>>()>;
+        static constexpr int32_t MAX_RIGHT = 0x4FFFFFFF;
+        bool disable_ = true;
+        int max_ = 0;
+        int total_ = 0;
+        int count_ = 0;
+        int32_t left_ = 0;
+        int32_t right_ = 0;
+        std::chrono::seconds timeout_;
+        std::list<std::shared_ptr<ConnNode>> nodes_;
+        std::list<std::weak_ptr<ConnNode>> details_;
+        std::mutex mutex_;
+        std::condition_variable cond_;
+        Creator creator_ = nullptr;
+        std::pair<int32_t, std::shared_ptr<ConnNode>> Initialize(Creator creator, int32_t max, int32_t timeout,
+            bool disable, bool acquire = false);
+        int32_t ConfigLocale(const std::string &locale);
+        std::shared_ptr<ConnNode> Acquire(std::chrono::milliseconds milliS);
+        std::list<std::shared_ptr<ConnNode>> AcquireAll(std::chrono::milliseconds milliS);
+
+        void Disable();
+        void Enable();
+        int32_t Release(std::shared_ptr<ConnNode> node);
+        int32_t Clear();
+        bool IsFull();
+        int32_t Dump(const char *header);
+
+    private:
+        int32_t ExtendNode();
+        int32_t RelDetails(std::shared_ptr<ConnNode> node);
+    };
+
+    explicit ConnectionPool(const RdbStoreConfig &storeConfig);
+    std::pair<int32_t, std::shared_ptr<Connection>> Init(bool isAttach = false, bool needWriter = false);
+    int32_t GetMaxReaders(const RdbStoreConfig &config);
+    std::shared_ptr<Connection> Convert2AutoConn(std::shared_ptr<ConnNode> node);
+    void ReleaseNode(std::shared_ptr<ConnNode> node);
+    int RestoreByDbSqliteType(const std::string &newPath, const std::string &backupPath, SlaveStatus &slaveStatus);
+
+    static constexpr int LIMITATION = 1024;
+    static constexpr uint32_t ITER_V1 = 5000;
+    static constexpr uint32_t ITERS_COUNT = 2;
+    const RdbStoreConfig &config_;
+    RdbStoreConfig attachConfig_;
+    Container writers_;
+    Container readers_;
+    int32_t maxReader_ = 0;
+
+    std::stack<BaseTransaction> transactionStack_;
+    std::mutex transactionStackMutex_;
+    std::condition_variable transCondition_;
+    std::mutex transMutex_;
+    bool transactionUsed_;
+    std::atomic<bool> isInTransaction_ = false;
+};
+
+} // namespace NativeRdb
+} // namespace OHOS
+#endif
diff --git a/relational_store/frameworks/native/rdb/mock/include/rdb_store_impl.h b/relational_store/frameworks/native/rdb/mock/include/rdb_store_impl.h
index c6b265045ea93633e50cc07adf810592a7f8d3cc..6c41bc5da8be7f7c34846b67047ee4e1a88b8696 100644
--- a/relational_store/frameworks/native/rdb/mock/include/rdb_store_impl.h
+++ b/relational_store/frameworks/native/rdb/mock/include/rdb_store_impl.h
@@ -25,11 +25,10 @@
 
 #include "abs_shared_result_set.h"
 #include "concurrent_map.h"
+#include "connection_pool.h"
 #include "rdb_store.h"
 #include "rdb_store_config.h"
-#include "sqlite_connection_pool.h"
 #include "sqlite_statement.h"
-#include "rd_statement.h"
 
 namespace OHOS::NativeRdb {
 class RdbStoreImpl : public RdbStore {
@@ -83,6 +82,7 @@ public:
     bool IsReadOnly() const override;
     bool IsMemoryRdb() const override;
     bool IsHoldingConnection() override;
+    bool IsSlaveDiffFromMaster() const override;
     int ConfigLocale(const std::string &localeStr);
     int Restore(const std::string &backupPath, const std::vector<uint8_t> &newKey) override;
     std::string GetName();
@@ -102,9 +102,13 @@ public:
     std::pair<int32_t, int32_t> Attach(
         const RdbStoreConfig &config, const std::string &attachName, int32_t waitTime = 2) override;
     std::pair<int32_t, int32_t> Detach(const std::string &attachName, int32_t waitTime = 2) override;
+    int InterruptBackup() override;
+    int32_t GetBackupStatus() const override;
+    int32_t ExchangeSlaverToMaster();
 
 protected:
     int InnerOpen();
+    void InitSyncerParam();
     const RdbStoreConfig config_;
     bool isOpen_ = false;
     bool isReadOnly_;
@@ -112,12 +116,11 @@ protected:
     bool isEncrypt_;
     int64_t vSchema_ = 0;
     std::string path_;
-    std::string orgPath_;
     std::string name_;
     std::string fileType_;
 
 private:
-    std::map<int64_t, std::shared_ptr<Connection>> trxConnMap_ = {};
+    ConcurrentMap<int64_t, std::shared_ptr<Connection>> trxConnMap_ = {};
     std::atomic<int64_t> newTrxId_ = 1;
     int ExecuteByTrxId(const std::string &sql, int64_t trxId, bool closeConnAfterExecute = false,
         const std::vector<ValueObject> &bindArgs = {});
@@ -151,15 +154,22 @@ private:
     int ExecuteSqlEntry(const std::string& sql, const std::vector<ValueObject>& bindArgs);
     std::pair<int32_t, ValueObject> ExecuteEntry(const std::string& sql, const std::vector<ValueObject>& bindArgs,
         int64_t trxId);
+    int GetSlaveName(const std::string &dbName, std::string &backupFilePath);
+    bool TryGetMasterSlaveBackupPath(const std::string &srcPath, std::string &destPath, bool isRestore = false);
+    int GetDestPath(const std::string &backupPath, std::string &destPath);
+    void ReportDbRestoreSuccessEvent();
     static constexpr char SCHEME_RDB[] = "rdb://";
     static constexpr uint32_t EXPANSION = 2;
     static constexpr uint32_t AUTO_SYNC_MAX_INTERVAL = 20000;
     static inline constexpr uint32_t INTERVAL = 10;
     static constexpr const char *ROW_ID = "ROWID";
 
-    std::shared_ptr<SqliteConnectionPool> connectionPool_;
+    std::set<std::string> cloudTables_;
+    DistributedRdb::RdbSyncerParam syncerParam_;
+    std::shared_ptr<ConnectionPool> connectionPool_;
     ConcurrentMap<std::string, std::string> attachedInfo_;
     uint32_t rebuild_;
+    SlaveStatus slaveStatus_;
 };
 } // namespace OHOS::NativeRdb
 #endif
diff --git a/relational_store/frameworks/native/rdb/mock/include/sqlite_connection.h b/relational_store/frameworks/native/rdb/mock/include/sqlite_connection.h
index d1afa01a18601b302e05421f86282cd2e938f3f5..af5498537d99274736603e66ec640a6a0d5cfb78 100644
--- a/relational_store/frameworks/native/rdb/mock/include/sqlite_connection.h
+++ b/relational_store/frameworks/native/rdb/mock/include/sqlite_connection.h
@@ -16,6 +16,7 @@
 #ifndef NATIVE_RDB_SQLITE_CONNECTION_H
 #define NATIVE_RDB_SQLITE_CONNECTION_H
 
+#include <atomic>
 #include <cstdint>
 #include <list>
 #include <memory>
@@ -27,6 +28,7 @@
 #include "rdb_store_config.h"
 #include "sqlite3sym.h"
 #include "sqlite_statement.h"
+#include "task_executor.h"
 #include "value_object.h"
 
 typedef struct ClientChangedData ClientChangedData;
@@ -40,7 +42,9 @@ using DataChangeCallback = std::function<void(ClientChangedData &clientChangedDa
 class SqliteConnection : public Connection {
 public:
     static std::pair<int32_t, std::shared_ptr<Connection>> Create(const RdbStoreConfig &config, bool isWrite);
-    static void DeleteDbFile(const RdbStoreConfig &config);
+    static int32_t Delete(const RdbStoreConfig &config);
+    static int32_t Repair(const RdbStoreConfig &config);
+    SqliteConnection(const RdbStoreConfig &config, bool isWriteConnection);
     ~SqliteConnection();
     int32_t OnInitialize() override;
     int TryCheckPoint() override;
@@ -54,27 +58,32 @@ public:
     int SubscribeTableChanges(const Notifier &notifier) override;
     int GetMaxVariable() const override;
     int32_t GetDBType() const override;
-    int ClearCache() override;
+    int32_t ClearCache() override;
     int32_t Subscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) override;
     int32_t Unsubscribe(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer) override;
+    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        bool isAsync, SlaveStatus &slaveStatus) override;
+    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+        SlaveStatus &slaveStatus) override;
+    ExchangeStrategy GenerateExchangeStrategy(const SlaveStatus &status) override;
 
 protected:
     std::pair<int32_t, ValueObject> ExecuteForValue(const std::string &sql,
         const std::vector<ValueObject> &bindArgs = std::vector<ValueObject>());
     int ExecuteSql(const std::string &sql, const std::vector<ValueObject> &bindArgs = std::vector<ValueObject>());
-    int ExecuteEncryptSql(const RdbStoreConfig &config, uint32_t iter);
-    void SetInTransaction(bool transaction);
 
 private:
     static constexpr const char *MERGE_ASSETS_FUNC = "merge_assets";
-    explicit SqliteConnection(bool isWriteConnection);
-    int InnerOpen(const RdbStoreConfig &config, uint32_t retry);
-    int Configure(const RdbStoreConfig &config, uint32_t retry, std::string &dbPath);
+    static constexpr const char *MERGE_ASSET_FUNC = "merge_asset";
+    int InnerOpen(const RdbStoreConfig &config);
+    int Configure(const RdbStoreConfig &config, std::string &dbPath);
     int SetPageSize(const RdbStoreConfig &config);
-    std::string GetSecManagerName(const RdbStoreConfig &config);
-    int SetEncryptKey(const RdbStoreConfig &config, uint32_t iter);
+    int SetEncrypt(const RdbStoreConfig &config);
+    int SetEncryptKey(const std::vector<uint8_t> &key, int32_t iter);
+    int SetServiceKey(const RdbStoreConfig &config, int32_t errCode);
+    int SetEncryptAgo(int32_t iter);
     int SetJournalMode(const RdbStoreConfig &config);
     int SetJournalSizeLimit(const RdbStoreConfig &config);
     int SetAutoCheckpoint(const RdbStoreConfig &config);
@@ -86,6 +95,7 @@ private:
 
     int RegDefaultFunctions(sqlite3 *dbHandle);
     static void MergeAssets(sqlite3_context *ctx, int argc, sqlite3_value **argv);
+    static void MergeAsset(sqlite3_context *ctx, int argc, sqlite3_value **argv);
     static void CompAssets(std::map<std::string, ValueObject::Asset> &oldAssets,
         std::map<std::string, ValueObject::Asset> &newAssets);
     static void MergeAsset(ValueObject::Asset &oldAsset, ValueObject::Asset &newAsset);
@@ -95,32 +105,40 @@ private:
     int32_t UnsubscribeLocalDetail(const std::string &event,
         const std::shared_ptr<DistributedRdb::RdbStoreObserver> &observer);
     int32_t UnsubscribeLocalDetailAll(const std::string &event);
-    int32_t Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
-    int32_t Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey) override;
     int32_t OpenDatabase(const std::string &dbPath, int openFileFlags);
-    void ReadFile2Buffer(const char* fileName);
+    void ReadFile2Buffer();
+    int LoadExtension(const RdbStoreConfig &config, sqlite3 *dbHandle);
+    RdbStoreConfig GetSlaveRdbStoreConfig(const RdbStoreConfig rdbConfig);
+    void ReportDbCorruptedEvent(int errCode, const std::string &checkResultInfo);
+    int CreateSlaveConnection(const RdbStoreConfig &config, bool isWrite, bool checkSlaveExist = false);
+    int ExchangeSlaverToMaster(bool isRestore, SlaveStatus &status);
+    bool IsRepairable();
+    std::pair<bool, int> ExchangeVerify(bool isRestore);
+    static std::pair<int32_t, std::shared_ptr<SqliteConnection>> InnerCreate(const RdbStoreConfig &config,
+        bool isWrite);
 
-    static constexpr uint32_t BUFFER_LEN = 16;
     static constexpr int DEFAULT_BUSY_TIMEOUT_MS = 2000;
+    static constexpr int BACKUP_PAGES_PRE_STEP = 12800; // 1024 * 4 * 12800 == 50m
+    static constexpr int BACKUP_PRE_WAIT_TIME = 10;
     static constexpr uint32_t NO_ITER = 0;
-    static constexpr uint32_t ITER_V1 = 5000;
-    static constexpr uint32_t ITERS[] = { NO_ITER, ITER_V1 };
-    static constexpr uint32_t ITERS_COUNT = sizeof(ITERS) / sizeof(ITERS[0]);
-    static const int32_t regCreater_;
-    static const int32_t regFileDeleter_;
+    static const int32_t regCreator_;
+    static const int32_t regRepairer_;
+    static const int32_t regDeleter_;
 
-    sqlite3 *dbHandle;
+    std::atomic<TaskExecutor::TaskId> backupId_ = TaskExecutor::INVALID_TASK_ID;
+    sqlite3 *dbHandle_;
     bool isWriter_;
-    bool isReadOnly;
+    bool isReadOnly_;
     bool isConfigured_ = false;
     bool hasClientObserver_ = false;
     JournalMode mode_ = JournalMode::MODE_WAL;
-    int openFlags;
     int maxVariableNumber_;
     std::mutex mutex_;
     std::string filePath;
+    std::shared_ptr<SqliteConnection> slaveConnection_;
     std::map<std::string, ScalarFunctionInfo> customScalarFunctions_;
-    std::map<std::string, std::list<std::shared_ptr<RdbStoreLocalDbObserver>>> rdbStoreLocalDbObservers_;
+    std::map<std::string, std::list<std::shared_ptr<RdbStoreLocalDbObserver>>> observers_;
+    const RdbStoreConfig config_;
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/mock/include/step_result_set.h b/relational_store/frameworks/native/rdb/mock/include/step_result_set.h
index 2a30908fe6c13acd97a077ac562e9a642a0bac75..8ba7776c3add0cb256a34cc1ad181ff5d82efed8 100644
--- a/relational_store/frameworks/native/rdb/mock/include/step_result_set.h
+++ b/relational_store/frameworks/native/rdb/mock/include/step_result_set.h
@@ -23,14 +23,14 @@
 
 #include "abs_result_set.h"
 #include "connection.h"
-#include "sqlite_connection_pool.h"
+#include "connection_pool.h"
 #include "statement.h"
 
 namespace OHOS {
 namespace NativeRdb {
 class StepResultSet : public AbsResultSet {
 public:
-    StepResultSet(std::shared_ptr<SqliteConnectionPool> pool, const std::string& sql,
+    StepResultSet(std::shared_ptr<ConnectionPool> pool, const std::string& sql,
         const std::vector<ValueObject>& selectionArgs);
     ~StepResultSet() override;
     int GetColumnType(int columnIndex, ColumnType &columnType) override;
@@ -39,6 +39,7 @@ public:
     int GetSize(int columnIndex, size_t &size) override;
     int Get(int32_t col, ValueObject &value) override;
     int Close() override;
+    int GetRowCount(int &count) override;
 
 protected:
     std::pair<int, std::vector<std::string>> GetColumnNames() override;
@@ -58,6 +59,7 @@ private:
     static const int STEP_QUERY_RETRY_INTERVAL = 1000;
     static const int EMPTY_ROW_COUNT = 0;
 
+    bool isSupportCountRow_ = true;
     std::shared_ptr<Statement> sqliteStatement_;
     std::shared_ptr<Connection> conn_;
 
diff --git a/relational_store/frameworks/native/rdb/mock/src/rdb_fault_hiview_reporter.cpp b/relational_store/frameworks/native/rdb/mock/src/rdb_fault_hiview_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d00deecb1c3fa813597249ae343bdaf127e61228
--- /dev/null
+++ b/relational_store/frameworks/native/rdb/mock/src/rdb_fault_hiview_reporter.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "rdb_fault_hiview_reporter.h"
+
+namespace OHOS::NativeRdb {
+
+void RdbFaultHiViewReporter::ReportRdbCorruptedFault(RdbCorruptedEvent &eventInfo)
+{
+    (void)eventInfo;
+}
+
+std::string RdbFaultHiViewReporter::GetFileStatInfo(const struct stat &fileStat)
+{
+    (void)fileStat;
+    return "";
+}
+
+std::string RdbFaultHiViewReporter::GetDateInfo(time_t time)
+{
+    (void)time;
+    return "";
+}
+
+} // namespace OHOS::NativeRdb
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/mock/src/rdb_radar_reporter.cpp b/relational_store/frameworks/native/rdb/mock/src/rdb_radar_reporter.cpp
index 192ee48b0778d2c226a02bb56100c7ef7b49a017..fe87ca494fda9267a20e656bf7d1c043a7be1921 100644
--- a/relational_store/frameworks/native/rdb/mock/src/rdb_radar_reporter.cpp
+++ b/relational_store/frameworks/native/rdb/mock/src/rdb_radar_reporter.cpp
@@ -18,11 +18,11 @@
 
 namespace OHOS::NativeRdb {
 
-
-bool RdbRadar::hasHostPkg_ = false;
 std::string RdbRadar::hostPkg_{ "" };
+std::mutex RdbRadar::mutex_;
 
-RdbRadar::RdbRadar(Scene scene, const char* funcName, std::string bundleName) : scene_(scene), funcName_(funcName)
+RdbRadar::RdbRadar(Scene scene, const char *funcName, std::string bundleName)
+    : scene_(scene), funcName_(funcName), bundleName_(bundleName)
 {
 }
 
@@ -47,7 +47,8 @@ void RdbRadar::LocalReport(int bizSence, const char* funcName, int state, int er
     (void)funcName_;
 }
 
-void RdbRadar::GetHostPkgInfo(std::string bundleName)
+std::string RdbRadar::GetHostPkgInfo()
 {
+    return "";
 }
 }
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/src/abs_predicates.cpp b/relational_store/frameworks/native/rdb/src/abs_predicates.cpp
index 6aafe344f803c79c09d060ba5c1bc740d9d805bc..2f25b6be538321bbe1295337f513d8b22f9da95b 100644
--- a/relational_store/frameworks/native/rdb/src/abs_predicates.cpp
+++ b/relational_store/frameworks/native/rdb/src/abs_predicates.cpp
@@ -112,7 +112,7 @@ AbsPredicates *AbsPredicates::BeginWrap()
 AbsPredicates *AbsPredicates::EndWrap()
 {
     if (!isNeedAnd) {
-        LOG_WARN("fail to add EndWrap.");
+        LOG_WARN("Fail to add EndWrap.");
         return this;
     }
     whereClause += " ) ";
@@ -122,7 +122,7 @@ AbsPredicates *AbsPredicates::EndWrap()
 AbsPredicates *AbsPredicates::Or()
 {
     if (!isNeedAnd) {
-        LOG_WARN("fail to add Or.");
+        LOG_WARN("Fail to add Or.");
         return this;
     }
     whereClause += " OR ";
@@ -469,10 +469,6 @@ AbsPredicates *AbsPredicates::In(const std::string &field, const std::vector<Val
     if (!chekParaFlag) {
         return this;
     }
-    if (values.empty()) {
-        LOG_WARN("in() fails because values can't be null.");
-        return this;
-    }
 
     CheckIsNeedAnd();
 
@@ -498,10 +494,6 @@ AbsPredicates *AbsPredicates::NotIn(const std::string &field, const std::vector<
     if (!chekParaFlag) {
         return this;
     }
-    if (values.empty()) {
-        LOG_WARN("fails as values is null.");
-        return this;
-    }
     CheckIsNeedAnd();
     std::vector<std::string> replaceValues(values.size(), "?");
     bindArgs.insert(bindArgs.end(), values.begin(), values.end());
diff --git a/relational_store/frameworks/native/rdb/src/abs_rdb_predicates.cpp b/relational_store/frameworks/native/rdb/src/abs_rdb_predicates.cpp
index 04fc3c6212a54319cf3975f3796c6953bee2c126..11c2c2982af5636ba173f8d884f94a2f70d37c25 100644
--- a/relational_store/frameworks/native/rdb/src/abs_rdb_predicates.cpp
+++ b/relational_store/frameworks/native/rdb/src/abs_rdb_predicates.cpp
@@ -27,7 +27,7 @@ AbsRdbPredicates::AbsRdbPredicates(const std::string &tableName)
 {
     if (tableName.empty()) {
         tableName_ = "";
-        LOG_DEBUG("no tableName specified.");
+        LOG_DEBUG("No tableName specified.");
         return;
     }
     tableName_ = std::move(tableName);
@@ -38,7 +38,7 @@ AbsRdbPredicates::AbsRdbPredicates(const std::vector<std::string> &tables)
 {
     if (tables.empty()) {
         tableName_ = "";
-        LOG_DEBUG("no tableName specified.");
+        LOG_DEBUG("No tableName specified.");
         return;
     }
     tableName_ = *(tables.begin());
diff --git a/relational_store/frameworks/native/rdb/src/abs_result_set.cpp b/relational_store/frameworks/native/rdb/src/abs_result_set.cpp
index 9bca24ceefbd4c69740f024ea0d9ffbe300fa730..f2af3b70b217fad75a79f55752892ba97da1891e 100644
--- a/relational_store/frameworks/native/rdb/src/abs_result_set.cpp
+++ b/relational_store/frameworks/native/rdb/src/abs_result_set.cpp
@@ -74,7 +74,7 @@ void RowEntity::Clear(int32_t size)
     indexs_.resize(size);
 }
 
-AbsResultSet::AbsResultSet() : rowPos_(INIT_POS), isClosed_(false)
+AbsResultSet::AbsResultSet() : rowPos_(INIT_POS), isClosed_(false), lastErr_(E_OK)
 {
 }
 
@@ -87,12 +87,16 @@ AbsResultSet::~AbsResultSet()
 int AbsResultSet::GetRowCount(int &count)
 {
     count = rowCount_;
+    if (lastErr_ != E_OK) {
+        LOG_ERROR("ResultSet has lastErr %{public}d", lastErr_);
+        return lastErr_;
+    }
     if (rowCount_ != NO_COUNT) {
         return E_OK;
     }
 
     if (isClosed_) {
-        LOG_ERROR("fail, result set E_ALREADY_CLOSED");
+        LOG_ERROR("fail, result set E_ALREADY_CLOSED.");
         return E_ALREADY_CLOSED;
     }
 
@@ -225,6 +229,9 @@ int AbsResultSet::GetDouble(int columnIndex, double& value)
 
 int AbsResultSet::IsColumnNull(int columnIndex, bool &isNull)
 {
+    if (lastErr_ != E_OK) {
+        return lastErr_;
+    }
     ColumnType columnType = ColumnType::TYPE_NULL;
     int errCode = GetColumnType(columnIndex, columnType);
     if (errCode != E_OK) {
diff --git a/relational_store/frameworks/native/rdb/src/abs_shared_result_set.cpp b/relational_store/frameworks/native/rdb/src/abs_shared_result_set.cpp
index 125ad9226dee18b8eb013684f0ce520ed6d26cb9..f98ac5112773a4b970d8e8cb87b600b62ea79d2b 100644
--- a/relational_store/frameworks/native/rdb/src/abs_shared_result_set.cpp
+++ b/relational_store/frameworks/native/rdb/src/abs_shared_result_set.cpp
@@ -32,8 +32,7 @@
 namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
-using Block = AppDataFwk::SharedBlock;
-
+using SharedBlock = AppDataFwk::SharedBlock;
 AbsSharedResultSet::AbsSharedResultSet(std::string name) : sharedBlock_(nullptr), sharedBlockName_(std::move(name))
 {
 }
@@ -60,15 +59,19 @@ int32_t AbsSharedResultSet::OnGo(int oldRowIndex, int newRowIndex)
 /**
  * Get current shared block
  */
-std::shared_ptr<AppDataFwk::SharedBlock> AbsSharedResultSet::GetBlock()
+std::shared_ptr<SharedBlock> AbsSharedResultSet::GetBlock()
 {
     std::lock_guard<decltype(globalMtx_)> lockGuard(globalMtx_);
-    if (sharedBlock_ != nullptr || isClosed_) {
+    if (sharedBlock_ != nullptr || isClosed_ || lowMem_) {
         return sharedBlock_;
     }
-    AppDataFwk::SharedBlock *block = nullptr;
-    AppDataFwk::SharedBlock::Create(sharedBlockName_, DEFAULT_BLOCK_SIZE, block);
-    sharedBlock_ = std::shared_ptr<AppDataFwk::SharedBlock>(block);
+    SharedBlock *block = nullptr;
+    auto errcode = SharedBlock::Create(sharedBlockName_, DEFAULT_BLOCK_SIZE, block);
+    if (errcode != SharedBlock::SHARED_BLOCK_OK) {
+        lowMem_ = true;
+        return nullptr;
+    }
+    sharedBlock_ = std::shared_ptr<SharedBlock>(block);
     return sharedBlock_;
 }
 
@@ -79,7 +82,7 @@ int AbsSharedResultSet::GetColumnType(int columnIndex, ColumnType &columnType)
     if (errorCode != E_OK) {
         return errorCode;
     }
-    Block::CellUnit* cellUnit = block->GetCellUnit(block->GetBlockPos(), (uint32_t)columnIndex);
+    SharedBlock::CellUnit* cellUnit = block->GetCellUnit(block->GetBlockPos(), (uint32_t)columnIndex);
     if (!cellUnit) {
         LOG_ERROR("AbsSharedResultSet::GetColumnType cellUnit is null!");
         return E_ERROR;
@@ -117,7 +120,7 @@ int AbsSharedResultSet::GoToRow(int position)
 
     if (position >= rowCnt || position < 0) {
         rowPos_ = (position >= rowCnt && rowCnt != 0) ? rowCnt : rowPos_;
-        LOG_ERROR("position[%{public}d] rowCnt[%{public}d] rowPos[%{public}d]!", position, rowCnt, rowPos_);
+        LOG_DEBUG("position[%{public}d] rowCnt[%{public}d] rowPos[%{public}d]!", position, rowCnt, rowPos_);
         return E_ROW_OUT_RANGE;
     }
 
@@ -150,20 +153,19 @@ int AbsSharedResultSet::Get(int32_t col, ValueObject& value)
         LOG_ERROR("cellUnit is null, col is %{public}d!", col);
         return E_ERROR;
     }
-
     switch (cellUnit->type) {
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_NULL:
+        case SharedBlock::CELL_UNIT_TYPE_NULL:
             break;
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_INTEGER:
+        case SharedBlock::CELL_UNIT_TYPE_INTEGER:
             value = cellUnit->cell.longValue;
             break;
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_FLOAT:
+        case SharedBlock::CELL_UNIT_TYPE_FLOAT:
             value = cellUnit->cell.doubleValue;
             break;
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING:
+        case SharedBlock::CELL_UNIT_TYPE_STRING:
             value = cellUnit->GetString(block.get());
             break;
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_BLOB:
+        case SharedBlock::CELL_UNIT_TYPE_BLOB:
             value = cellUnit->GetBlob(block.get());
             break;
         default:
@@ -188,9 +190,9 @@ int AbsSharedResultSet::GetSize(int columnIndex, size_t &size)
     }
 
     int type = cellUnit->type;
-    if (type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_STRING
-        || type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_BLOB
-        || type == AppDataFwk::SharedBlock::CELL_UNIT_TYPE_NULL) {
+    if (type == SharedBlock::CELL_UNIT_TYPE_STRING
+        || type == SharedBlock::CELL_UNIT_TYPE_BLOB
+        || type == SharedBlock::CELL_UNIT_TYPE_NULL) {
         size = cellUnit->cell.stringOrBlobValue.size;
         return E_OK;
     }
@@ -211,11 +213,11 @@ int AbsSharedResultSet::Close()
 /**
  * Allocates a new shared block to an {@link AbsSharedResultSet}
  */
-void AbsSharedResultSet::SetBlock(AppDataFwk::SharedBlock *block)
+void AbsSharedResultSet::SetBlock(SharedBlock *block)
 {
     std::lock_guard<decltype(globalMtx_)> lockGuard(globalMtx_);
     if (sharedBlock_.get() != block) {
-        sharedBlock_ = std::shared_ptr<AppDataFwk::SharedBlock>(block);
+        sharedBlock_ = std::shared_ptr<SharedBlock>(block);
     }
 }
 
@@ -249,7 +251,7 @@ void AbsSharedResultSet::Finalize()
     Close();
 }
 
-int AbsSharedResultSet::GetCustomerValue(int index, ValueObject& value, AppDataFwk::SharedBlock *block)
+int AbsSharedResultSet::GetCustomerValue(int index, ValueObject& value, SharedBlock *block)
 {
     auto *cellUnit = block->GetCellUnit(block->GetBlockPos(), index);
     if (cellUnit == nullptr) {
@@ -260,25 +262,25 @@ int AbsSharedResultSet::GetCustomerValue(int index, ValueObject& value, AppDataF
     size_t size = cellUnit->cell.stringOrBlobValue.size;
     auto data = cellUnit->GetRawData(block);
     switch (cellUnit->type) {
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_ASSET: {
+        case SharedBlock::CELL_UNIT_TYPE_ASSET: {
             ValueObject::Asset asset;
             RawDataParser::ParserRawData(data, size, asset);
             value = std::move(asset);
             break;
         }
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_ASSETS: {
+        case SharedBlock::CELL_UNIT_TYPE_ASSETS: {
             ValueObject::Assets assets;
             RawDataParser::ParserRawData(data, size, assets);
             value = std::move(assets);
             break;
         }
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_FLOATS: {
+        case SharedBlock::CELL_UNIT_TYPE_FLOATS: {
             ValueObject::FloatVector floats;
             RawDataParser::ParserRawData(data, size, floats);
             value = std::move(floats);
             break;
         }
-        case AppDataFwk::SharedBlock::CELL_UNIT_TYPE_BIGINT: {
+        case SharedBlock::CELL_UNIT_TYPE_BIGINT: {
             ValueObject::BigInt bigInt;
             RawDataParser::ParserRawData(data, size, bigInt);
             value = std::move(bigInt);
diff --git a/relational_store/frameworks/native/rdb/src/connection.cpp b/relational_store/frameworks/native/rdb/src/connection.cpp
index 48d5c3743c9c776a26a360e96a810c2038b72722..1e851370de7bccbdd56072af282bbb8418149a22 100644
--- a/relational_store/frameworks/native/rdb/src/connection.cpp
+++ b/relational_store/frameworks/native/rdb/src/connection.cpp
@@ -27,9 +27,10 @@ std::pair<int, std::shared_ptr<Connection>> Connection::Create(const RdbStoreCon
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
         return { E_INVALID_ARGS, nullptr };
     }
+
     auto creator = g_creators[dbType];
     if (creator == nullptr) {
-        return { E_ERROR, nullptr };
+        return { E_NOT_SUPPORT, nullptr };
     }
 
     return creator(config, isWriter);
@@ -41,26 +42,28 @@ int32_t Connection::Repair(const RdbStoreConfig &config)
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
         return E_INVALID_ARGS;
     }
+
     auto repairer = g_repairers[dbType];
     if (repairer == nullptr) {
-        return E_ERROR;
+        return E_NOT_SUPPORT;
     }
 
     return repairer(config);
 }
 
-void Connection::DeleteDbFile(const RdbStoreConfig &config)
+int32_t Connection::Delete(const RdbStoreConfig &config)
 {
     auto dbType = config.GetDBType();
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
-        return;
+        return E_INVALID_ARGS;
     }
+
     auto deleter = g_fileDeleter[dbType];
     if (deleter == nullptr) {
-        return;
+        return E_NOT_SUPPORT;
     }
-
-    deleter(config);
+    
+    return deleter(config);
 }
 
 int32_t Connection::RegisterCreator(int32_t dbType, Creator creator)
@@ -68,10 +71,11 @@ int32_t Connection::RegisterCreator(int32_t dbType, Creator creator)
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
         return E_INVALID_ARGS;
     }
+
     if (g_creators[dbType] != nullptr) {
         return E_OK;
     }
-
+    
     g_creators[dbType] = creator;
     return E_OK;
 }
@@ -81,6 +85,7 @@ int32_t Connection::RegisterRepairer(int32_t dbType, Repairer repairer)
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
         return E_INVALID_ARGS;
     }
+
     if (g_repairers[dbType] != nullptr) {
         return E_OK;
     }
@@ -89,11 +94,12 @@ int32_t Connection::RegisterRepairer(int32_t dbType, Repairer repairer)
     return E_OK;
 }
 
-int32_t Connection::RegisterFileDeleter(int32_t dbType, Deleter deleter)
+int32_t Connection::RegisterDeleter(int32_t dbType, Deleter deleter)
 {
     if (dbType < static_cast<int32_t>(DB_SQLITE) || dbType >= static_cast<int32_t>(DB_BUTT)) {
         return E_INVALID_ARGS;
     }
+
     if (g_fileDeleter[dbType] != nullptr) {
         return E_OK;
     }
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_connection_pool.cpp b/relational_store/frameworks/native/rdb/src/connection_pool.cpp
similarity index 76%
rename from relational_store/frameworks/native/rdb/src/sqlite_connection_pool.cpp
rename to relational_store/frameworks/native/rdb/src/connection_pool.cpp
index dd73bac231b606520e1fb04d92d325800d98606c..1e07a7ac811264e1e7380e2aec04caf2c2203da2 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_connection_pool.cpp
+++ b/relational_store/frameworks/native/rdb/src/connection_pool.cpp
@@ -12,8 +12,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#define LOG_TAG "SqliteConnectionPool"
-#include "sqlite_connection_pool.h"
+#define LOG_TAG "ConnectionPool"
+#include "connection_pool.h"
 
 #include <base_transaction.h>
 
@@ -35,7 +35,7 @@ namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
 using Conn = Connection;
-using ConnPool = SqliteConnectionPool;
+using ConnPool = ConnectionPool;
 using SharedConn = std::shared_ptr<Connection>;
 using SharedConns = std::vector<std::shared_ptr<Connection>>;
 using SqlStatistic = DistributedRdb::SqlStatistic;
@@ -45,56 +45,67 @@ std::shared_ptr<ConnPool> ConnPool::Create(const RdbStoreConfig &storeConfig, in
 {
     std::shared_ptr<ConnPool> pool(new (std::nothrow) ConnPool(storeConfig));
     if (pool == nullptr) {
-        LOG_ERROR("ConnPool::Create new failed, pool is nullptr");
+        LOG_ERROR("ConnPool::Create new failed, pool is nullptr.");
         errCode = E_ERROR;
         return nullptr;
     }
     std::shared_ptr<Connection> conn;
-    std::tie(errCode, conn) = pool->Init(storeConfig);
+    for (uint32_t retry = 0; retry < ITERS_COUNT; ++retry) {
+        std::tie(errCode, conn) = pool->Init();
+        if (errCode == E_OK || errCode != E_SQLITE_CORRUPT) {
+            break;
+        }
+        storeConfig.SetIter(ITER_V1);
+    }
     return errCode == E_OK ? pool : nullptr;
 }
 
-std::pair<RebuiltType, std::shared_ptr<SqliteConnectionPool>> ConnPool::HandleDataCorruption
+std::pair<RebuiltType, std::shared_ptr<ConnectionPool>> ConnPool::HandleDataCorruption
     (const RdbStoreConfig &storeConfig, int &errCode)
 {
-    std::pair<RebuiltType, std::shared_ptr<SqliteConnectionPool>> result;
-    auto &[rebuiltTpye, pool] = result;
+    std::pair<RebuiltType, std::shared_ptr<ConnectionPool>> result;
+    auto &[rebuiltType, pool] = result;
 
     errCode = Connection::Repair(storeConfig);
     if (errCode == E_OK) {
-        rebuiltTpye = RebuiltType::REPAIRED;
+        rebuiltType = RebuiltType::REPAIRED;
     } else {
-        Connection::DeleteDbFile(storeConfig);
-        rebuiltTpye = RebuiltType::REBUILT;
+        Connection::Delete(storeConfig);
+        rebuiltType = RebuiltType::REBUILT;
     }
     pool = Create(storeConfig, errCode);
     if (errCode != E_OK) {
         LOG_WARN("failed, type %{public}d db %{public}s encrypt %{public}d error %{public}d, errno",
-            rebuiltTpye, storeConfig.GetName().c_str(), storeConfig.IsEncrypt(), errCode, errno);
+            static_cast<uint32_t>(rebuiltType), storeConfig.GetName().c_str(), storeConfig.IsEncrypt(), errCode, errno);
     }
 
     return result;
 }
 
-ConnPool::SqliteConnectionPool(const RdbStoreConfig &storeConfig)
-    : config_(storeConfig), writers_(), readers_(), transactionStack_(), transactionUsed_(false)
+ConnPool::ConnectionPool(const RdbStoreConfig &storeConfig)
+    : config_(storeConfig), attachConfig_(storeConfig), writers_(), readers_(), transactionStack_(),
+      transactionUsed_(false)
 {
+    attachConfig_.SetJournalMode(JournalMode::MODE_TRUNCATE);
 }
 
-std::pair<int32_t, std::shared_ptr<Connection>> ConnPool::Init(const RdbStoreConfig &config, bool needWriter)
+std::pair<int32_t, std::shared_ptr<Connection>> ConnPool::Init(bool isAttach, bool needWriter)
 {
-    if (config_.IsEncrypt()) {
-        config_.Initialize();
-    }
-
+    const RdbStoreConfig &config = isAttach ? attachConfig_ : config_;
     std::pair<int32_t, std::shared_ptr<Connection>> result;
     auto &[errCode, conn] = result;
+    errCode = config.Initialize();
+    if (errCode != E_OK) {
+        return result;
+    }
+
     if (config.GetRoleType() == OWNER && !config.IsReadOnly()) {
         // write connect count is 1
         std::shared_ptr<ConnPool::ConnNode> node;
         std::tie(errCode, node) = writers_.Initialize(
-            [this]() {
-                return Connection::Create(config_, true);
+            [this, isAttach]() {
+                const RdbStoreConfig &config = isAttach ? attachConfig_ : config_;
+                return Connection::Create(config, true);
             },
             1, config.GetWriteTime(), true, needWriter);
         conn = Convert2AutoConn(node);
@@ -103,22 +114,22 @@ std::pair<int32_t, std::shared_ptr<Connection>> ConnPool::Init(const RdbStoreCon
         }
     }
 
-    config_.ChangeEncryptKey();
     maxReader_ = GetMaxReaders(config);
     // max read connect count is 64
     if (maxReader_ > 64) {
         return { E_ARGS_READ_CON_OVERLOAD, nullptr };
     }
     auto [ret, node] = readers_.Initialize(
-        [this]() {
-            return Connection::Create(config_, false);
+        [this, isAttach]() {
+            const RdbStoreConfig &config = isAttach ? attachConfig_ : config_;
+            return Connection::Create(config, false);
         },
         maxReader_, config.GetReadTime(), maxReader_ == 0);
     errCode = ret;
     return result;
 }
 
-ConnPool::~SqliteConnectionPool()
+ConnPool::~ConnectionPool()
 {
     CloseAllConnections();
 }
@@ -187,7 +198,11 @@ std::pair<SharedConn, SharedConns> ConnPool::AcquireAll(int32_t time)
     auto &[writer, readers] = result;
     auto interval = duration_cast<milliseconds>(seconds(time));
     auto start = steady_clock::now();
-    writer = Convert2AutoConn(writers_.AcquireAll(interval).front());
+    auto writerNodes = writers_.AcquireAll(interval);
+    if (writerNodes.empty()) {
+        return {};
+    }
+    writer = Convert2AutoConn(writerNodes.front());
 
     auto usedTime = duration_cast<milliseconds>(steady_clock::now() - start);
     if (writer == nullptr || usedTime >= interval) {
@@ -254,7 +269,10 @@ void ConnPool::ReleaseNode(std::shared_ptr<ConnNode> node)
     if (node == nullptr) {
         return;
     }
-    node->Unused();
+    auto errCode = node->Unused();
+    if (errCode == E_WAL_SIZE_OVER_LIMIT) {
+        readers_.Dump("WAL Over Limit");
+    }
     if (node->IsWriter()) {
         writers_.Release(node);
     } else {
@@ -311,45 +329,75 @@ int ConnPool::ConfigLocale(const std::string &localeStr)
  * Rename the backed up database.
  */
 int ConnPool::ChangeDbFileForRestore(const std::string &newPath, const std::string &backupPath,
-    const std::vector<uint8_t> &newKey)
+    const std::vector<uint8_t> &newKey, SlaveStatus &slaveStatus)
 {
     if (!writers_.IsFull() || config_.GetPath() == backupPath || newPath == backupPath) {
         LOG_ERROR("Connection pool is busy now!");
         return E_ERROR;
     }
-
     if (config_.GetDBType() == DB_VECTOR) {
         CloseAllConnections();
         auto [retVal, connection] = CreateConnection(false);
 
         if (connection == nullptr) {
-            LOG_ERROR("Get null connection");
+            LOG_ERROR("Get null connection.");
             return retVal;
         }
-
-        retVal = connection->Restore(backupPath, {});
+        retVal = connection->Restore(backupPath, {}, slaveStatus);
         if (retVal != E_OK) {
-            LOG_ERROR("RdDbRestore error");
+            LOG_ERROR("RdDbRestore error.");
             return retVal;
         }
         CloseAllConnections();
-    } else {
-        CloseAllConnections();
-        RemoveDBFile();
+        auto [errCode, node] = Init();
+        return errCode;
+    }
+    return RestoreByDbSqliteType(newPath, backupPath, slaveStatus);
+}
 
-        if (config_.GetPath() != newPath) {
-            RemoveDBFile(newPath);
+int ConnPool::RestoreByDbSqliteType(const std::string &newPath, const std::string &backupPath, SlaveStatus &slaveStatus)
+{
+    int ret = E_OK;
+    if (SqliteUtils::IsSlaveDbName(backupPath) && config_.GetHaMode() != HAMode::SINGLE) {
+        auto connection = AcquireConnection(false);
+        if (connection == nullptr) {
+            return E_DATABASE_BUSY;
         }
-
-        auto retVal = SqliteUtils::RenameFile(backupPath, newPath);
-        if (retVal != E_OK) {
-            LOG_ERROR("RenameFile filed error:%{public}d, errno:%{public}d, path:%{public}s",
-                retVal, errno, newPath.c_str());
-            return retVal;
+        ret = connection->Restore(backupPath, {}, slaveStatus);
+        if (ret == E_SQLITE_CORRUPT && config_.GetAllowRebuild()) {
+            LOG_WARN("corrupt, rebuild:%{public}s", SqliteUtils::Anonymous(backupPath).c_str());
+            CloseAllConnections();
+            Connection::Delete(config_);
+            auto [errCode, node] = Init();
+            if (errCode != E_OK) {
+                LOG_ERROR("init failed:%{public}d", errCode);
+                return errCode;
+            }
+            auto newConn = AcquireConnection(false);
+            if (newConn == nullptr) {
+                return E_DATABASE_BUSY;
+            }
+            ret = newConn->Restore(backupPath, {}, slaveStatus);
+            if (ret != E_OK) {
+                LOG_ERROR("restore failed:%{public}d, %{public}s", ret, SqliteUtils::Anonymous(backupPath).c_str());
+            }
         }
+        return ret;
     }
-    auto [errCode, node] = Init(config_);
-    return errCode;
+    CloseAllConnections();
+    Connection::Delete(config_);
+
+    if (config_.GetPath() != newPath) {
+        RdbStoreConfig config(newPath);
+        config.SetPath(newPath);
+        Connection::Delete(config);
+    }
+
+    if (!SqliteUtils::CopyFile(backupPath, newPath)) {
+        ret = E_ERROR;
+    }
+    auto [errCode, node] = Init();
+    return ret == E_OK ? errCode : ret;
 }
 
 std::stack<BaseTransaction> &ConnPool::GetTransactionStack()
@@ -364,14 +412,12 @@ std::mutex &ConnPool::GetTransactionStackMutex()
 
 std::pair<int32_t, std::shared_ptr<Conn>> ConnPool::DisableWal()
 {
-    RdbStoreConfig config = config_;
-    config.SetJournalMode(JournalMode::MODE_TRUNCATE);
-    return Init(config, true);
+    return Init(true, true);
 }
 
 int ConnPool::EnableWal()
 {
-    auto [errCode, node] = Init(config_);
+    auto [errCode, node] = Init();
     return errCode;
 }
 
@@ -392,14 +438,16 @@ int64_t ConnPool::ConnNode::GetUsingTime() const
     return std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
 }
 
-void ConnPool::ConnNode::Unused()
+int32_t ConnPool::ConnNode::Unused()
 {
+    int32_t errCode = E_OK;
     tid_ = 0;
     time_ = std::chrono::steady_clock::now();
     if (connect_ != nullptr) {
         connect_->ClearCache();
-        connect_->TryCheckPoint();
+        errCode = connect_->TryCheckPoint();
     }
+    return errCode;
 }
 
 bool ConnPool::ConnNode::IsWriter() const
@@ -458,8 +506,8 @@ int32_t ConnPool::Container::ConfigLocale(const std::string &locale)
 
 std::shared_ptr<ConnPool::ConnNode> ConnPool::Container::Acquire(std::chrono::milliseconds milliS)
 {
-    auto interval = (milliS == INVALID_TIME) ? timeout_ : milliS;
     std::unique_lock<decltype(mutex_)> lock(mutex_);
+    auto interval = (milliS == INVALID_TIME) ? timeout_ : milliS;
     if (max_ == 0) {
         return nullptr;
     }
@@ -471,10 +519,16 @@ std::shared_ptr<ConnPool::ConnNode> ConnPool::Container::Acquire(std::chrono::mi
         if (disable_) {
             return false;
         }
-
         return ExtendNode() == E_OK;
     };
     if (cond_.wait_for(lock, interval, waiter)) {
+        if (nodes_.empty()) {
+            LOG_ERROR(
+                "nodes is empty.count %{public}d max %{public}d total %{public}d left %{public}d right%{public}d",
+                count_, max_, total_, left_, right_);
+            count_ = 0;
+            return nullptr;
+        }
         auto node = nodes_.back();
         nodes_.pop_back();
         count_--;
@@ -577,7 +631,7 @@ int32_t ConnPool::Container::Release(std::shared_ptr<ConnNode> node)
     return E_OK;
 }
 
-int32_t SqliteConnectionPool::Container::RelDetails(std::shared_ptr<ConnNode> node)
+int32_t ConnectionPool::Container::RelDetails(std::shared_ptr<ConnNode> node)
 {
     for (auto it = details_.begin(); it != details_.end();) {
         auto detailNode = it->lock();
@@ -622,6 +676,8 @@ int32_t ConnPool::Container::Dump(const char *header)
 {
     std::string info;
     std::vector<std::shared_ptr<ConnNode>> details;
+        std::string title = " M_T_C[" + std::to_string(max_) + ","+ std::to_string(total_) +","
+            + std::to_string(count_) + "]";
     {
         std::unique_lock<decltype(mutex_)> lock(mutex_);
         details.reserve(details_.size());
@@ -644,26 +700,12 @@ int32_t ConnPool::Container::Dump(const char *header)
             .append(">");
         // 256 represent that limit to info length
         if (info.size() > 256) {
-            LOG_WARN("%{public}s: %{public}s", header, info.c_str());
+            LOG_WARN("%{public}s %{public}s: %{public}s", header, title.c_str(), info.c_str());
             info.clear();
         }
     }
-    LOG_WARN("%{public}s: %{public}s", header, info.c_str());
+    LOG_WARN("%{public}s %{public}s: %{public}s", header, title.c_str(), info.c_str());
     return 0;
 }
-
-void ConnPool::RemoveDBFile()
-{
-    RemoveDBFile(config_.GetPath());
-}
-
-void ConnPool::RemoveDBFile(const std::string &path)
-{
-    SqliteUtils::DeleteFile(path);
-    SqliteUtils::DeleteFile(path + "-shm");
-    SqliteUtils::DeleteFile(path + "-wal");
-    SqliteUtils::DeleteFile(path + "-journal");
-}
-
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/delay_notify.cpp b/relational_store/frameworks/native/rdb/src/delay_notify.cpp
index 0876995b548bc93829f7f92a50dd8e9cc517f68e..785bcb70ab269f8d2815703ab401a9cafa472416 100644
--- a/relational_store/frameworks/native/rdb/src/delay_notify.cpp
+++ b/relational_store/frameworks/native/rdb/src/delay_notify.cpp
@@ -30,27 +30,31 @@ DelayNotify::~DelayNotify()
         pool_->Remove(delaySyncTaskId_);
     }
     if (task_ != nullptr && changedData_.tableData.size() > 0) {
-        pool_->Schedule(std::chrono::milliseconds(AUTO_SYNC_INTERVAL), [task = task_, changedData = changedData_]() {
-            auto errCode = task(changedData);
-            if (errCode != 0) {
-                LOG_ERROR("NotifyDataChange is failed, err is %{public}d.", errCode);
-            }
-        });
+        DistributedRdb::RdbNotifyConfig rdbNotifyConfig;
+        rdbNotifyConfig.delay_ = 0;
+        rdbNotifyConfig.isFull_ = isFull_;
+        auto errCode = task_(changedData_, rdbNotifyConfig);
+        if (errCode != 0) {
+            LOG_ERROR("NotifyDataChange is failed, err is %{public}d.", errCode);
+        }
     }
 }
 
-void DelayNotify::UpdateNotify(const DistributedRdb::RdbChangedData &changedData)
+void DelayNotify::UpdateNotify(const DistributedRdb::RdbChangedData &changedData, bool isFull)
 {
     LOG_DEBUG("Update changed data.");
-    std::lock_guard<std::mutex> lock(mutex_);
-    for (auto& [k, v] : changedData.tableData) {
-        if (!v.isTrackedDataChange) {
-            continue;
-        }
-        auto it = changedData_.tableData.find(k);
-        if (it == changedData_.tableData.end()) {
-            changedData_.tableData.insert_or_assign(k, v);
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        for (auto& [k, v] : changedData.tableData) {
+            if (!v.isTrackedDataChange) {
+                continue;
+            }
+            auto it = changedData_.tableData.find(k);
+            if (it == changedData_.tableData.end()) {
+                changedData_.tableData.insert_or_assign(k, v);
+            }
         }
+        isFull_ |= isFull;
     }
     StartTimer();
 }
@@ -70,15 +74,48 @@ void DelayNotify::SetTask(Task task)
 
 void DelayNotify::StartTimer()
 {
-    if (pool_ == nullptr) {
-        return;
+    DistributedRdb::RdbChangedData changedData;
+    bool needExecTask = false;
+    bool isFull = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        changedData.tableData = changedData_.tableData;
+        isFull = isFull_;
+        if (pool_ == nullptr) {
+            return;
+        }
+
+        if (delaySyncTaskId_ == Executor::INVALID_TASK_ID) {
+            delaySyncTaskId_ = pool_->Schedule(std::chrono::milliseconds(autoSyncInterval_),
+                [this]() { ExecuteTask(); });
+        } else {
+            delaySyncTaskId_ =
+                pool_->Reset(delaySyncTaskId_, std::chrono::milliseconds(autoSyncInterval_));
+        }
+
+        if (autoSyncInterval_ == AUTO_SYNC_INTERVAL || changedData.tableData.empty()) {
+            return;
+        }
+
+        if (!isInitialized_) {
+            needExecTask = true;
+            lastTimePoint_ = std::chrono::steady_clock::now();
+            isInitialized_ = true;
+        } else {
+            Time curTime = std::chrono::steady_clock::now();
+            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(curTime - lastTimePoint_);
+            if (duration >= std::chrono::milliseconds(MAX_NOTIFY_INTERVAL)) {
+                needExecTask = true;
+                lastTimePoint_ = std::chrono::steady_clock::now();
+            }
+        }
     }
-    if (delaySyncTaskId_ == Executor::INVALID_TASK_ID) {
-        delaySyncTaskId_ = pool_->Schedule(std::chrono::milliseconds(autoSyncInterval_),
-            [this]() { ExecuteTask(); });
-    } else {
-        delaySyncTaskId_ =
-            pool_->Reset(delaySyncTaskId_, std::chrono::milliseconds(autoSyncInterval_));
+
+    if (needExecTask) {
+        DistributedRdb::RdbNotifyConfig rdbNotifyConfig;
+        rdbNotifyConfig.delay_ = SERVICE_INTERVAL;
+        rdbNotifyConfig.isFull_ = isFull;
+        task_(changedData, rdbNotifyConfig);
     }
 }
 
@@ -94,14 +131,20 @@ void DelayNotify::ExecuteTask()
 {
     LOG_DEBUG("Notify data change.");
     DistributedRdb::RdbChangedData changedData;
+    bool isFull = false;
     {
         std::lock_guard<std::mutex> lock(mutex_);
         changedData.tableData = std::move(changedData_.tableData);
+        isFull = isFull_;
         RestoreDefaultSyncInterval();
         StopTimer();
+        isFull_ = false;
     }
-    if (task_ != nullptr && changedData.tableData.size() > 0) {
-        int errCode = task_(changedData);
+    if (task_ != nullptr && (changedData.tableData.size() > 0 || isFull)) {
+        DistributedRdb::RdbNotifyConfig rdbNotifyConfig;
+        rdbNotifyConfig.delay_ = 0;
+        rdbNotifyConfig.isFull_ = isFull;
+        int errCode = task_(changedData, rdbNotifyConfig);
         if (errCode != 0) {
             LOG_ERROR("NotifyDataChange is failed, err is %{public}d.", errCode);
             std::lock_guard<std::mutex> lock(mutex_);
diff --git a/relational_store/frameworks/native/rdb/src/grd_api_manager.cpp b/relational_store/frameworks/native/rdb/src/grd_api_manager.cpp
index e952ffe2bc1b22b358fece8ef9422d85f51700bf..ed1af348d979007b269f68b99674a935e106a1f8 100644
--- a/relational_store/frameworks/native/rdb/src/grd_api_manager.cpp
+++ b/relational_store/frameworks/native/rdb/src/grd_api_manager.cpp
@@ -67,7 +67,7 @@ GRD_APIInfo GetApiInfoInstance()
 {
     GRD_APIInfo GRD_TempApiStruct;
 #ifndef _WIN32
-    g_library = dlopen("libgaussdb_rd_vector.z.so", RTLD_LAZY);
+    g_library = dlopen("libarkdata_db_core.z.so", RTLD_LAZY);
     if (g_library != nullptr) {
         GRD_DBApiInitEnhance(GRD_TempApiStruct);
     } else {
diff --git a/relational_store/frameworks/native/rdb/src/raw_data_parser.cpp b/relational_store/frameworks/native/rdb/src/raw_data_parser.cpp
index f4d0faf4cb8b3bebabfe5ec1f51b19c1298ba1f3..44b0a361b4b1acccea9374a8514e75859e820eb6 100644
--- a/relational_store/frameworks/native/rdb/src/raw_data_parser.cpp
+++ b/relational_store/frameworks/native/rdb/src/raw_data_parser.cpp
@@ -138,7 +138,13 @@ size_t RawDataParser::ParserRawData(const uint8_t* data, size_t length, BigInteg
     if (sizeof(BIG_INT) > length - used) {
         return 0;
     }
-    auto magic = Endian::LeToH(*(reinterpret_cast<decltype(&BIG_INT)>(data)));
+    std::vector<uint8_t> copiedData;
+    const uint8_t *alignData = data;
+    if ((reinterpret_cast<uintptr_t>(data) & (sizeof(uintptr_t) - 1)) != 0) {
+        copiedData.assign(data, data + length);
+        alignData = copiedData.data();
+    }
+    auto magic = Endian::LeToH(*(reinterpret_cast<decltype(&BIG_INT)>(alignData)));
     used += sizeof(BIG_INT);
     if (magic != BIG_INT) {
         return 0;
@@ -147,19 +153,20 @@ size_t RawDataParser::ParserRawData(const uint8_t* data, size_t length, BigInteg
     if (sizeof(uint32_t) > length - used) {
         return 0;
     }
-    uint32_t sign = Endian::LeToH(*(reinterpret_cast<const uint32_t *>(data + used)));
+
+    uint32_t sign = Endian::LeToH(*(reinterpret_cast<const uint32_t *>(alignData + used)));
     used += sizeof(uint32_t);
 
     if (sizeof(uint64_t) > length - used) {
         return 0;
     }
-    uint64_t count = Endian::LeToH(*(reinterpret_cast<const uint64_t *>(data + used)));
+    uint64_t count = Endian::LeToH(*(reinterpret_cast<const uint64_t *>(alignData + used)));
     used += sizeof(uint64_t);
 
     if (sizeof(uint64_t) * count > length - used) {
         return 0;
     }
-    const uint64_t *temp = (reinterpret_cast<const uint64_t *>(data + used));
+    const uint64_t *temp = (reinterpret_cast<const uint64_t *>(alignData + used));
     std::vector<uint64_t> trueFrom(temp, temp + count);
     used += sizeof(uint64_t) * count;
     for (size_t i = 0; i < trueFrom.size(); ++i) {
@@ -175,7 +182,13 @@ size_t RawDataParser::ParserRawData(const uint8_t* data, size_t length, RawDataP
     if (sizeof(FLOUT32_ARRAY) > length - used) {
         return 0;
     }
-    auto magic = Endian::LeToH(*(reinterpret_cast<decltype(&FLOUT32_ARRAY)>(data)));
+    std::vector<uint8_t> copiedData;
+    const uint8_t *alignData = data;
+    if ((reinterpret_cast<uintptr_t>(data) & (sizeof(uintptr_t) - 1)) != 0) {
+        copiedData.assign(data, data + length);
+        alignData = copiedData.data();
+    }
+    auto magic = Endian::LeToH(*(reinterpret_cast<decltype(&FLOUT32_ARRAY)>(alignData)));
     used += sizeof(FLOUT32_ARRAY);
     if (magic != FLOUT32_ARRAY) {
         return 0;
@@ -185,13 +198,13 @@ size_t RawDataParser::ParserRawData(const uint8_t* data, size_t length, RawDataP
         return 0;
     }
 
-    uint32_t count = Endian::LeToH(*(reinterpret_cast<const uint32_t *>(data + used)));
+    uint32_t count = Endian::LeToH(*(reinterpret_cast<const uint32_t *>(alignData + used)));
     used += sizeof(uint32_t);
 
     if (sizeof(float) * count > length - used) {
         return 0;
     }
-    auto values = reinterpret_cast<const float *>(data + used);
+    auto values = reinterpret_cast<const float *>(alignData + used);
     floats.assign(values, values + count);
     used += sizeof(float) * count;
     return used;
diff --git a/relational_store/frameworks/native/rdb/src/rd_connection.cpp b/relational_store/frameworks/native/rdb/src/rd_connection.cpp
index 0b6fdb25c71f0363254a8d9c01b94f07aef40b9a..35502a7891e3ffc6ba8b8990616203da37c22d0f 100644
--- a/relational_store/frameworks/native/rdb/src/rd_connection.cpp
+++ b/relational_store/frameworks/native/rdb/src/rd_connection.cpp
@@ -24,18 +24,19 @@ namespace NativeRdb {
 using namespace OHOS::Rdb;
 __attribute__((used))
 const int32_t RdConnection::regCreator_ = Connection::RegisterCreator(DB_VECTOR, RdConnection::Create);
+__attribute__((used))
 const int32_t RdConnection::regRepairer_ = Connection::RegisterRepairer(DB_VECTOR, RdConnection::Repair);
-const int32_t RdConnection::regFileDeleter_ =
-    Connection::RegisterFileDeleter(DB_VECTOR, RdConnection::DeleteDbFile);
+__attribute__((used))
+const int32_t RdConnection::regDeleter_ = Connection::RegisterDeleter(DB_VECTOR, RdConnection::Delete);
 
 std::pair<int32_t, std::shared_ptr<Connection>> RdConnection::Create(const RdbStoreConfig& config, bool isWrite)
 {
     std::pair<int32_t, std::shared_ptr<Connection>> result;
     auto& [errCode, conn] = result;
     for (size_t i = 0; i < ITERS_COUNT; i++) {
-        std::shared_ptr<RdConnection> connection = std::make_shared<RdConnection>(isWrite);
+        std::shared_ptr<RdConnection> connection = std::make_shared<RdConnection>(config, isWrite);
         if (connection == nullptr) {
-            LOG_ERROR("SqliteConnection::Open new failed, connection is nullptr");
+            LOG_ERROR("SqliteConnection::Open new failed, connection is nullptr.");
             return result;
         }
         errCode = connection->InnerOpen(config);
@@ -52,17 +53,17 @@ int32_t RdConnection::Repair(const RdbStoreConfig& config)
     std::string dbPath = "";
     auto errCode = SqliteGlobalConfig::GetDbPath(config, dbPath);
     if (errCode != E_OK) {
-        LOG_ERROR("Can not get db path");
+        LOG_ERROR("Can not get db path.");
         return errCode;
     }
     errCode = RdUtils::RdDbRepair(dbPath.c_str(), GRD_OPEN_CONFIG_STR);
     if (errCode != E_OK) {
-        LOG_ERROR("Fail to repair db");
+        LOG_ERROR("Fail to repair db.");
     }
     return errCode;
 }
 
-static std::vector<std::string> rdPostFixes = {
+static constexpr const char *RD_POST_FIXES[] = {
     "",
     ".redo",
     ".undo",
@@ -72,18 +73,21 @@ static std::vector<std::string> rdPostFixes = {
     ".map",
 };
 
-void RdConnection::DeleteDbFile(const RdbStoreConfig& config)
+int32_t RdConnection::Delete(const RdbStoreConfig &config)
 {
     auto path = config.GetPath();
-    for (std::string &postFix : rdPostFixes) {
+    for (auto postFix : RD_POST_FIXES) {
         std::string shmFilePath = path + postFix;
         if (access(shmFilePath.c_str(), F_OK) == 0) {
             remove(shmFilePath.c_str());
         }
     }
+    return E_OK;
 }
 
-RdConnection::RdConnection(bool isWriter) : isWriter_(isWriter) {}
+RdConnection::RdConnection(const RdbStoreConfig &config, bool isWriter) : isWriter_(isWriter), config_(config)
+{
+}
 
 RdConnection::~RdConnection()
 {
@@ -101,12 +105,12 @@ int RdConnection::InnerOpen(const RdbStoreConfig &config)
     std::string dbPath = "";
     auto errCode = SqliteGlobalConfig::GetDbPath(config, dbPath);
     if (errCode != E_OK) {
-        LOG_ERROR("Can not get db path");
+        LOG_ERROR("Can not get db path.");
         return errCode;
     }
     errCode = RdUtils::RdDbOpen(dbPath.c_str(), configStr_.c_str(), GRD_DB_OPEN_CREATE, &dbHandle_);
     if (errCode != E_OK) {
-        LOG_ERROR("Can not open rd db");
+        LOG_ERROR("Can not open rd db.");
         return errCode;
     }
     return errCode;
@@ -121,6 +125,7 @@ std::pair<int32_t, RdConnection::Stmt> RdConnection::CreateStatement(const std::
 {
     auto stmt = std::make_shared<RdStatement>();
     stmt->conn_ = conn;
+    stmt->config_ = &config_;
     stmt->setPragmas_["user_version"] = ([this](const int &value) -> int32_t {
         return RdUtils::RdDbSetVersion(dbHandle_, GRD_CONFIG_USER_VERSION, value);
     });
@@ -201,7 +206,8 @@ int32_t RdConnection::Unsubscribe(const std::string& event,
     return E_NOT_SUPPORT;
 }
 
-int32_t RdConnection::Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey)
+int32_t RdConnection::Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+    bool isAsync, SlaveStatus &slaveStatus)
 {
     uint32_t size = destEncryptKey.size();
     if (size != 0) {
@@ -210,7 +216,8 @@ int32_t RdConnection::Backup(const std::string &databasePath, const std::vector<
     return RdUtils::RdDbBackup(dbHandle_, databasePath.c_str(), nullptr, 0);
 }
 
-int32_t RdConnection::Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey)
+int32_t RdConnection::Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+    SlaveStatus &slaveStatus)
 {
     uint32_t size = destEncryptKey.size();
     if (size != 0) {
@@ -219,5 +226,9 @@ int32_t RdConnection::Restore(const std::string &databasePath, const std::vector
     return RdUtils::RdDbRestore(dbHandle_, databasePath.c_str(), nullptr, 0);
 }
 
+ExchangeStrategy RdConnection::GenerateExchangeStrategy(const SlaveStatus &status)
+{
+    return ExchangeStrategy::NOT_HANDLE;
+}
 } // namespace NativeRdb
 } // namespace OHOS
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/src/rd_statement.cpp b/relational_store/frameworks/native/rdb/src/rd_statement.cpp
index 1895e71c35c7cd6ec7b0ff6781f2d5c5b403c2a2..5be71f5f0899322f88c8c9f4234d3e542e83f19c 100644
--- a/relational_store/frameworks/native/rdb/src/rd_statement.cpp
+++ b/relational_store/frameworks/native/rdb/src/rd_statement.cpp
@@ -22,10 +22,12 @@
 #include "logger.h"
 #include "raw_data_parser.h"
 #include "rdb_errno.h"
-#include "rd_utils.h"
 #include "rd_connection.h"
+#include "rd_utils.h"
 #include "sqlite_global_config.h"
 #include "sqlite_utils.h"
+#include "rdb_fault_hiview_reporter.h"
+#include "sqlite_global_config.h"
 
 namespace OHOS {
 namespace NativeRdb {
@@ -125,6 +127,9 @@ int RdStatement::Prepare(GRD_DB *db, const std::string &newSql)
     GRD_SqlStmt *tmpStmt = nullptr;
     int ret = RdUtils::RdSqlPrepare(db, newSql.c_str(), newSql.length(), &tmpStmt, nullptr);
     if (ret != E_OK) {
+        if (ret == E_SQLITE_CORRUPT) {
+            ReportDbCorruptedEvent(ret);
+        }
         if (tmpStmt != nullptr) {
             (void)RdUtils::RdSqlFinalize(tmpStmt);
         }
@@ -134,16 +139,17 @@ int RdStatement::Prepare(GRD_DB *db, const std::string &newSql)
     Finalize(); // Finalize original stmt
     sql_ = newSql;
     stmtHandle_ = tmpStmt;
+    columnCount_ = RdUtils::RdSqlColCnt(tmpStmt);
     readOnly_ = SqliteUtils::GetSqlStatementType(newSql) == SqliteUtils::STATEMENT_SELECT;
     if (readOnly_) {
+        isStepInPrepare_ = true;
         ret = Step();
         if (ret != E_OK && ret != E_NO_MORE_ROWS) {
             return ret;
         }
         GetProperties();
-        ret = Reset();
-        if (ret != E_OK) {
-            return ret;
+        if (ret == E_NO_MORE_ROWS) {
+            Reset();
         }
     }
     return E_OK;
@@ -163,6 +169,7 @@ int RdStatement::Finalize()
     sql_ = "";
     columnCount_ = 0;
     readOnly_ = false;
+    config_ = nullptr;
     return E_OK;
 }
 
@@ -222,11 +229,7 @@ int RdStatement::IsValid(int index) const
         LOG_ERROR("statement already close.");
         return E_ALREADY_CLOSED;
     }
-    if (index < 0) {
-        LOG_ERROR("invalid index %{public}d", index);
-        return E_INVALID_ARGS;
-    }
-    if (index >= columnCount_) {
+    if (index < 0 || index >= columnCount_) {
         LOG_ERROR("index (%{public}d) >= columnCount (%{public}d)", index, columnCount_);
         return E_COLUMN_OUT_RANGE;
     }
@@ -277,12 +280,26 @@ int32_t RdStatement::Bind(const std::vector<ValueObject>& args)
     return E_OK;
 }
 
+std::pair<int32_t, int32_t> RdStatement::Count()
+{
+    return { E_NOT_SUPPORT, INVALID_COUNT };
+}
+
 int32_t RdStatement::Step()
 {
     if (stmtHandle_ == nullptr) {
         return E_OK;
     }
-    return RdUtils::RdSqlStep(stmtHandle_);
+    if (isStepInPrepare_ && stepCnt_ == 1) {
+        stepCnt_++;
+        return E_OK;
+    }
+    int ret = RdUtils::RdSqlStep(stmtHandle_);
+    if (ret == E_SQLITE_CORRUPT) {
+        ReportDbCorruptedEvent(ret);
+    }
+    stepCnt_++;
+    return ret;
 }
 
 int32_t RdStatement::Reset()
@@ -290,6 +307,8 @@ int32_t RdStatement::Reset()
     if (stmtHandle_ == nullptr) {
         return E_OK;
     }
+    stepCnt_ = 0;
+    isStepInPrepare_ = false;
     return RdUtils::RdSqlReset(stmtHandle_);
 }
 
@@ -473,5 +492,33 @@ void RdStatement::GetProperties()
     columnCount_ = RdUtils::RdSqlColCnt(stmtHandle_);
 }
 
+void RdStatement::ReportDbCorruptedEvent(int errorCode)
+{
+    if (config_ == nullptr) {
+        return;
+    }
+    RdbCorruptedEvent eventInfo;
+    eventInfo.bundleName = config_->GetBundleName();
+    eventInfo.moduleName = config_->GetModuleName();
+    eventInfo.storeType = "RDB";
+    eventInfo.storeName = config_->GetName();
+    eventInfo.securityLevel = static_cast<uint32_t>(config_->GetSecurityLevel());
+    eventInfo.pathArea = static_cast<uint32_t>(config_->GetArea());
+    eventInfo.encryptStatus = static_cast<uint32_t>(config_->IsEncrypt());
+    eventInfo.integrityCheck = static_cast<uint32_t>(config_->GetIntegrityCheck());
+    eventInfo.errorCode = static_cast<uint32_t>(errorCode);
+    eventInfo.systemErrorNo = errno;
+    eventInfo.errorOccurTime = time(nullptr);
+    std::string dbPath;
+    if (SqliteGlobalConfig::GetDbPath(*config_, dbPath) == E_OK && access(dbPath.c_str(), F_OK) == 0) {
+        eventInfo.dbFileStatRet = stat(dbPath.c_str(), &eventInfo.dbFileStat);
+        std::string walPath = dbPath + "-wal";
+        eventInfo.walFileStatRet = stat(walPath.c_str(), &eventInfo.walFileStat);
+    } else {
+        eventInfo.dbFileStatRet = -1;
+        eventInfo.walFileStatRet = -1;
+    }
+    RdbFaultHiViewReporter::ReportRdbCorruptedFault(eventInfo);
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/rd_utils.cpp b/relational_store/frameworks/native/rdb/src/rd_utils.cpp
index e5c60772b422489b41382bc22896205c5da5429f..6c0a69d8a8c7e8b9b5d5a9ca08cf24db7600b95f 100644
--- a/relational_store/frameworks/native/rdb/src/rd_utils.cpp
+++ b/relational_store/frameworks/native/rdb/src/rd_utils.cpp
@@ -58,15 +58,15 @@ int RdUtils::TransferGrdErrno(int err)
 ColumnType RdUtils::TransferGrdTypeToColType(int grdColType)
 {
     switch (grdColType) {
-        case GRD_SQL_DATATYPE_INTEGER:
+        case GRD_DB_DATATYPE_INTEGER:
             return ColumnType::TYPE_INTEGER;
-        case GRD_SQL_DATATYPE_FLOAT:
+        case GRD_DB_DATATYPE_FLOAT:
             return ColumnType::TYPE_FLOAT;
-        case GRD_SQL_DATATYPE_TEXT:
+        case GRD_DB_DATATYPE_TEXT:
             return ColumnType::TYPE_STRING;
-        case GRD_SQL_DATATYPE_BLOB:
+        case GRD_DB_DATATYPE_BLOB:
             return ColumnType::TYPE_BLOB;
-        case GRD_SQL_DATATYPE_FLOATVECTOR:
+        case GRD_DB_DATATYPE_FLOATVECTOR:
             return ColumnType::TYPE_FLOAT32_ARRAY;
         default:
             break;
@@ -486,7 +486,7 @@ int RdUtils::RdDbSetVersion(GRD_DB *db, GRD_ConfigTypeE type, int version)
         return TransferGrdErrno(GRD_INNER_ERR);
     }
     GRD_DbValueT value;
-    value.type = GRD_SQL_DATATYPE_INTEGER;
+    value.type = GRD_DB_DATATYPE_INTEGER;
     value.value.longValue = version;
     return TransferGrdErrno(GRD_KVApiInfo.DBSetConfigApi(db, type, value));
 }
diff --git a/relational_store/frameworks/native/rdb/src/rdb_helper.cpp b/relational_store/frameworks/native/rdb/src/rdb_helper.cpp
index be61323d75f7584aa549bf907dd544618714ce76..0ced846d308c2e0314d1f705b7f6b111c78879ab 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_helper.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_helper.cpp
@@ -17,12 +17,13 @@
 
 #include "logger.h"
 #include "rdb_errno.h"
+#include "rdb_security_manager.h"
 #include "rdb_store_manager.h"
 #include "rdb_trace.h"
 #include "sqlite_global_config.h"
+#include "sqlite_utils.h"
 #include "unistd.h"
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-#include "rdb_security_manager.h"
 #include "security_policy.h"
 #endif
 
@@ -44,13 +45,6 @@ void RdbHelper::ClearCache()
     RdbStoreManager::GetInstance().Clear();
 }
 
-static void DeleteRdbKeyFiles(const std::string &dbFileName)
-{
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-    RdbSecurityManager::GetInstance().DelRdbSecretDataFile(dbFileName);
-#endif
-}
-
 static std::vector<std::string> rdPostFixes = {
     "",
     ".redo",
@@ -84,6 +78,7 @@ int RdbHelper::DeleteRdbStore(const std::string &dbFileName)
         return E_INVALID_FILE_PATH;
     }
     if (access(dbFileName.c_str(), F_OK) != 0) {
+        LOG_ERROR("Store to delete doesn't exist, path %{public}s", dbFileName.c_str());
         return E_OK; // not not exist
     }
     RdbStoreManager::GetInstance().Delete(dbFileName);
@@ -120,8 +115,30 @@ int RdbHelper::DeleteRdbStore(const std::string &dbFileName)
             errCode = E_REMOVE_FILE;
         }
     }
-    DeleteRdbKeyFiles(dbFileName);
-
+    RdbSecurityManager::GetInstance().DelAllKeyFiles(dbFileName);
+    LOG_INFO("Delete rdb store ret %{public}d, path %{public}s", errCode, dbFileName.c_str());
+    DeleteRdbStore(SqliteUtils::GetSlavePath(dbFileName));
+    return errCode;
+}
+int RdbHelper::DeleteRdbStore(const RdbStoreConfig &config)
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
+    auto dbFile = config.GetPath();
+    if (dbFile.empty()) {
+        return E_INVALID_FILE_PATH;
+    }
+    if (access(dbFile.c_str(), F_OK) != 0) {
+        LOG_ERROR("not exist, path %{public}s", dbFile.c_str());
+        return E_OK; // not not exist
+    }
+    RdbStoreManager::GetInstance().Delete(dbFile);
+    auto errCode = Connection::Delete(config);
+    if (errCode != E_OK) {
+        LOG_ERROR("delete the db file err = %{public}d", errno);
+        return E_REMOVE_FILE;
+    }
+    RdbSecurityManager::GetInstance().DelAllKeyFiles(dbFile);
+    LOG_INFO("Delete rdb store ret %{public}d, path %{public}s", errCode, dbFile.c_str());
     return errCode;
 }
 } // namespace NativeRdb
diff --git a/relational_store/frameworks/native/rdb/src/rdb_manager_impl.cpp b/relational_store/frameworks/native/rdb/src/rdb_manager_impl.cpp
index a13dab6fbd588e8f36f13101608b4672a285ab60..804016ed0c1cae96b6d5ac0481bef76183344573 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_manager_impl.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_manager_impl.cpp
@@ -42,17 +42,17 @@ std::shared_ptr<RdbStoreDataServiceProxy> RdbManagerImpl::GetDistributedDataMana
 {
     auto manager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (manager == nullptr) {
-        LOG_ERROR("get system ability manager failed");
+        LOG_ERROR("get system ability manager failed.");
         return nullptr;
     }
     auto dataMgr = manager->CheckSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
     if (dataMgr == nullptr) {
-        LOG_ERROR("get distributed data manager failed");
+        LOG_ERROR("get distributed data manager failed.");
         return nullptr;
     }
     sptr<RdbStoreDataServiceProxy> dataService = new (std::nothrow) RdbStoreDataServiceProxy(dataMgr);
     if (dataService == nullptr) {
-        LOG_ERROR("new RdbStoreDataServiceProxy failed");
+        LOG_ERROR("new RdbStoreDataServiceProxy failed.");
         return nullptr;
     }
 
@@ -67,11 +67,11 @@ static void LinkToDeath(const sptr<IRemoteObject>& remote)
     sptr<RdbManagerImpl::ServiceDeathRecipient> deathRecipient =
         new(std::nothrow) RdbManagerImpl::ServiceDeathRecipient(&manager);
     if (deathRecipient == nullptr) {
-        LOG_ERROR("new ServiceDeathRecipient failed");
+        LOG_ERROR("new ServiceDeathRecipient failed.");
         return;
     }
     if (!remote->AddDeathRecipient(deathRecipient)) {
-        LOG_ERROR("add death recipient failed");
+        LOG_ERROR("add death recipient failed.");
     }
 }
 
@@ -81,7 +81,7 @@ RdbManagerImpl::RdbManagerImpl()
 
 RdbManagerImpl::~RdbManagerImpl()
 {
-    LOG_INFO("destroy");
+    LOG_INFO("destroy.");
 }
 
 RdbManagerImpl& RdbManagerImpl::GetInstance()
@@ -105,13 +105,13 @@ std::pair<int32_t, std::shared_ptr<RdbService>> RdbManagerImpl::GetRdbService(co
         distributedDataMgr_ = GetDistributedDataManager(param.bundleName_);
     }
     if (distributedDataMgr_ == nullptr) {
-        LOG_ERROR("get distributed data manager failed");
+        LOG_ERROR("get distributed data manager failed.");
         return { E_SERVICE_NOT_FOUND, nullptr };
     }
 
     auto remote = distributedDataMgr_->GetFeatureInterface(DistributedRdb::RdbService::SERVICE_NAME);
     if (remote == nullptr) {
-        LOG_ERROR("get rdb service failed");
+        LOG_ERROR("get rdb service failed.");
         return { E_NOT_SUPPORT, nullptr };
     }
 
@@ -125,7 +125,7 @@ std::pair<int32_t, std::shared_ptr<RdbService>> RdbManagerImpl::GetRdbService(co
     }
 
     if (rdbService == nullptr || rdbService->InitNotifier(param) != RDB_OK) {
-        LOG_ERROR("init notifier failed");
+        LOG_ERROR("init notifier failed.");
         return { E_ERROR, nullptr };
     }
 
@@ -139,7 +139,7 @@ std::pair<int32_t, std::shared_ptr<RdbService>> RdbManagerImpl::GetRdbService(co
 
 void RdbManagerImpl::OnRemoteDied()
 {
-    LOG_INFO("rdb service has dead!!");
+    LOG_INFO("rdb service has dead!");
     if (rdbService_ == nullptr) {
         ResetServiceHandle();
         return;
@@ -177,12 +177,12 @@ sptr<IRemoteObject> RdbStoreDataServiceProxy::GetFeatureInterface(const std::str
     LOG_DEBUG("%{public}s", name.c_str());
     MessageParcel data;
     if (!data.WriteInterfaceToken(RdbStoreDataServiceProxy::GetDescriptor())) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return nullptr;
     }
 
     if (!ITypesUtil::Marshal(data, name)) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return nullptr;
     }
 
@@ -197,7 +197,7 @@ sptr<IRemoteObject> RdbStoreDataServiceProxy::GetFeatureInterface(const std::str
 
     sptr<IRemoteObject> remoteObject;
     if (!ITypesUtil::Unmarshal(reply, remoteObject)) {
-        LOG_ERROR("remote object is nullptr");
+        LOG_ERROR("remote object is nullptr.");
         return nullptr;
     }
     return remoteObject;
@@ -207,12 +207,12 @@ int32_t RdbStoreDataServiceProxy::RegisterDeathObserver(const std::string &bundl
 {
     MessageParcel data;
     if (!data.WriteInterfaceToken(RdbStoreDataServiceProxy::GetDescriptor())) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return E_ERROR;
     }
 
     if (!ITypesUtil::Marshal(data, bundleName, observer)) {
-        LOG_ERROR("write descriptor failed");
+        LOG_ERROR("write descriptor failed.");
         return E_ERROR;
     }
 
diff --git a/relational_store/frameworks/native/rdb/src/rdb_notifier_stub.cpp b/relational_store/frameworks/native/rdb/src/rdb_notifier_stub.cpp
index be604f337e20a4876a53e7315c995678e35a6f53..129386202c38708bc995e61ffb5c5c82f1e9f44e 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_notifier_stub.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_notifier_stub.cpp
@@ -39,7 +39,7 @@ bool RdbNotifierStub::CheckInterfaceToken(MessageParcel& data)
     auto localDescriptor = GetDescriptor();
     auto remoteDescriptor = data.ReadInterfaceToken();
     if (remoteDescriptor != localDescriptor) {
-        LOG_ERROR("interface token is not equal");
+        LOG_ERROR("interface token is not equal.");
         return false;
     }
     return true;
@@ -65,7 +65,7 @@ int32_t RdbNotifierStub::OnCompleteInner(MessageParcel &data, MessageParcel &rep
     uint32_t seqNum = 0;
     Details result;
     if (!ITypesUtil::Unmarshal(data, seqNum, result)) {
-        LOG_ERROR("read sync result failed");
+        LOG_ERROR("read sync result failed.");
         return RDB_ERROR;
     }
     return OnComplete(seqNum, std::move(result));
@@ -101,7 +101,7 @@ int32_t RdbNotifierStub::OnChangeInner(MessageParcel &data, MessageParcel &reply
     PrimaryFields primaries;
     ChangeInfo changeInfo;
     if (!ITypesUtil::Unmarshal(data, origin, primaries, changeInfo)) {
-        LOG_ERROR("read sync result failed");
+        LOG_ERROR("read sync result failed.");
         return RDB_ERROR;
     }
     return OnChange(origin, primaries, std::move(changeInfo));
@@ -112,7 +112,7 @@ int32_t RdbNotifierStub::OnAutoSyncCompleteInner(MessageParcel &data, MessagePar
     std::string storeName;
     Details result;
     if (!ITypesUtil::Unmarshal(data, storeName, result)) {
-        LOG_ERROR("read sync result failed");
+        LOG_ERROR("read sync result failed.");
         return RDB_ERROR;
     }
     return OnComplete(storeName, std::move(result));
diff --git a/relational_store/frameworks/native/rdb/src/rdb_security_manager.cpp b/relational_store/frameworks/native/rdb/src/rdb_security_manager.cpp
index 8c8d4d55ca1788c2e74c32d770cf08b0d0a67129..69899af64ef563ab6f45f1ed72db776d2d92dad1 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_security_manager.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_security_manager.cpp
@@ -12,20 +12,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#define LOG_TAG "RdbPassword"
+#define LOG_TAG "RdbSecurityManager"
 #include "rdb_security_manager.h"
 
+#include <fcntl.h>
 #include <securec.h>
-
 #include <string>
+#include <sys/file.h>
+#include <sys/stat.h>
 #include <unistd.h>
-#include <utility>
 
 #include "directory_ex.h"
 #include "file_ex.h"
 #include "hks_api.h"
 #include "hks_param.h"
 #include "logger.h"
+#include "rdb_errno.h"
 #include "rdb_platform.h"
 #include "rdb_sql_utils.h"
 #include "sqlite_utils.h"
@@ -175,14 +177,14 @@ std::vector<uint8_t> RdbSecurityManager::GenerateRandomNum(int32_t len)
     return key;
 }
 
-bool RdbSecurityManager::SaveSecretKeyToFile(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType)
+bool RdbSecurityManager::SaveSecretKeyToFile(const std::string &keyFile, const std::vector<uint8_t> &workey)
 {
-    LOG_INFO("SaveSecretKeyToFile begin.");
+    LOG_INFO("begin keyFile%{public}s.", SqliteUtils::Anonymous(keyFile).c_str());
     if (!HasRootKey()) {
         LOG_ERROR("Root key not exists!");
         return false;
     }
-    std::vector<uint8_t> key = GenerateRandomNum(RDB_KEY_SIZE);
+    std::vector<uint8_t> key = workey.empty() ? GenerateRandomNum(RDB_KEY_SIZE) : workey;
     RdbSecretKeyData keyData;
     keyData.timeValue = std::chrono::system_clock::to_time_t(std::chrono::system_clock::system_clock::now());
     keyData.distributed = 0;
@@ -195,17 +197,12 @@ bool RdbSecurityManager::SaveSecretKeyToFile(const std::string &dbPath, RdbSecur
     }
 
     key.assign(key.size(), 0);
-    if (!RdbSecurityManager::InitPath(StringUtils::ExtractFilePath(dbPath) + std::string("key/"))) {
-        LOG_ERROR("InitPath err.");
-        return false;
-    }
-
-    return SaveSecretKeyToDisk(GetKeyPath(dbPath, keyFileType), keyData);
+    return SaveSecretKeyToDisk(keyFile, keyData);
 }
 
 bool RdbSecurityManager::SaveSecretKeyToDisk(const std::string &keyPath, RdbSecretKeyData &keyData)
 {
-    LOG_INFO("SaveSecretKeyToDisk begin.");
+    LOG_INFO("begin keyPath:%{public}s.", SqliteUtils::Anonymous(keyPath).c_str());
     std::vector<uint8_t> distributedInByte = { &keyData.distributed, &keyData.distributed + sizeof(uint8_t) };
     std::vector<uint8_t> timeInByte = { reinterpret_cast<uint8_t *>(&keyData.timeValue),
         reinterpret_cast<uint8_t *>(&keyData.timeValue) + sizeof(time_t) };
@@ -215,14 +212,12 @@ bool RdbSecurityManager::SaveSecretKeyToDisk(const std::string &keyPath, RdbSecr
     secretKeyInChar.insert(secretKeyInChar.end(), timeInByte.begin(), timeInByte.end());
     secretKeyInChar.insert(secretKeyInChar.end(), keyData.secretKey.begin(), keyData.secretKey.end());
 
-    std::lock_guard<std::mutex> lock(mutex_);
-    bool ret = SaveBufferToFile(keyPath, secretKeyInChar);
-    if (!ret) {
-        LOG_ERROR("SaveBufferToFile failed!");
-        return false;
+    bool ret;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        ret = SaveBufferToFile(keyPath, secretKeyInChar);
     }
-
-    return true;
+    return ret;
 }
 
 int RdbSecurityManager::GenerateRootKey(const std::vector<uint8_t> &rootKeyAlias)
@@ -434,30 +429,29 @@ int32_t RdbSecurityManager::CheckRootKeyExists(std::vector<uint8_t> &rootKeyAlia
     return ret;
 }
 
-bool RdbSecurityManager::InitPath(const std::string &dbKeyDir)
+bool RdbSecurityManager::InitPath(const std::string &fileDir)
 {
     constexpr mode_t DEFAULT_UMASK = 0002;
-    if (access(dbKeyDir.c_str(), F_OK) == 0) {
+    if (access(fileDir.c_str(), F_OK) == 0) {
         return true;
     }
     umask(DEFAULT_UMASK);
-    if (MkDir(dbKeyDir, (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0 && errno != EEXIST) {
-        LOG_ERROR("mkdir error:%{public}d, dbDir:%{public}s", errno, SqliteUtils::Anonymous(dbKeyDir).c_str());
+    if (MkDir(fileDir, (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0 && errno != EEXIST) {
+        LOG_ERROR("mkdir error:%{public}d, dbDir:%{public}s", errno, SqliteUtils::Anonymous(fileDir).c_str());
         return false;
     }
     return true;
 }
 
-RdbPassword RdbSecurityManager::LoadSecretKeyFromFile(const std::string &dbPath, KeyFileType keyFileType)
+RdbPassword RdbSecurityManager::LoadSecretKeyFromFile(const std::string &keyFile)
 {
-    std::string keyPath = GetKeyPath(dbPath, keyFileType);
-    if (!(access(keyPath.c_str(), F_OK) == 0)) {
-        LOG_ERROR("Key file not exists.");
+    if (access(keyFile.c_str(), F_OK) != 0) {
+        LOG_ERROR("Not exists. errno:%{public}d, file:%{public}s", errno, SqliteUtils::Anonymous(keyFile).c_str());
         return {};
     }
 
     RdbSecretKeyData keyData;
-    if (!LoadSecretKeyFromDisk(keyPath, keyData)) {
+    if (!LoadSecretKeyFromDisk(keyFile, keyData)) {
         LOG_ERROR("Load key failed.");
         return {};
     }
@@ -477,7 +471,7 @@ RdbPassword RdbSecurityManager::LoadSecretKeyFromFile(const std::string &dbPath,
 
 bool RdbSecurityManager::LoadSecretKeyFromDisk(const std::string &keyPath, RdbSecretKeyData &keyData)
 {
-    LOG_DEBUG("LoadSecretKeyFromDisk begin.");
+    LOG_DEBUG("begin keyPath:%{public}s.", SqliteUtils::Anonymous(keyPath).c_str());
     std::vector<char> content;
     {
         std::lock_guard<std::mutex> lock(mutex_);
@@ -506,16 +500,20 @@ bool RdbSecurityManager::LoadSecretKeyFromDisk(const std::string &keyPath, RdbSe
     return true;
 }
 
-RdbPassword RdbSecurityManager::GetRdbPassword(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType)
+RdbPassword RdbSecurityManager::GetRdbPassword(const std::string &dbPath, KeyFileType keyFileType)
 {
-    if (!IsKeyFileExists(dbPath, keyFileType)) {
-        if (!SaveSecretKeyToFile(dbPath, keyFileType)) {
-            LOG_ERROR("Failed to save key.");
+    KeyFiles keyFiles(dbPath);
+    keyFiles.Lock();
+    auto &keyFile = keyFiles.GetKeyFile(keyFileType);
+    if (IsKeyFileEmpty(keyFile)) {
+        if (!SaveSecretKeyToFile(keyFile)) {
+            keyFiles.Unlock();
+            LOG_ERROR("Failed to save key type:%{public}d err:%{public}d.", keyFileType, errno);
             return {};
         }
     }
-
-    return LoadSecretKeyFromFile(dbPath, keyFileType);
+    keyFiles.Unlock();
+    return LoadSecretKeyFromFile(keyFile);
 }
 
 std::vector<uint8_t> RdbSecurityManager::GenerateRootKeyAlias(const std::string &bundlename)
@@ -526,13 +524,33 @@ std::vector<uint8_t> RdbSecurityManager::GenerateRootKeyAlias(const std::string
     return rootKeyAlias;
 }
 
-void RdbSecurityManager::DelRdbSecretDataFile(const std::string &dbPath)
+void RdbSecurityManager::DelAllKeyFiles(const std::string &dbPath)
 {
     LOG_INFO("Delete all key files begin.");
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto keyPaths = ConcatenateKeyPath(dbPath);
-    SqliteUtils::DeleteFile(keyPaths.first);
-    SqliteUtils::DeleteFile(keyPaths.second);
+    const std::string dbKeyDir = StringUtils::ExtractFilePath(dbPath) + "key/";
+    if (access(dbKeyDir.c_str(), F_OK) != 0) {
+        return;
+    }
+    KeyFiles keyFiles(dbPath);
+    keyFiles.Lock();
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        SqliteUtils::DeleteFile(keyFiles.GetKeyFile(PUB_KEY_FILE));
+        SqliteUtils::DeleteFile(keyFiles.GetKeyFile(PUB_KEY_FILE_NEW_KEY));
+    }
+    keyFiles.Unlock();
+    keyFiles.DestroyLock();
+}
+
+void RdbSecurityManager::DelKeyFile(const std::string &dbPath, KeyFileType keyFileType)
+{
+    KeyFiles keyFiles(dbPath);
+    keyFiles.Lock();
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        SqliteUtils::DeleteFile(keyFiles.GetKeyFile(keyFileType));
+    }
+    keyFiles.Unlock();
 }
 
 bool RdbSecurityManager::IsKeyExpired(const time_t &createTime)
@@ -557,48 +575,139 @@ static std::string RemoveSuffix(const std::string &name)
     return { name, 0, pos };
 }
 
-std::pair<std::string, std::string> RdbSecurityManager::ConcatenateKeyPath(const std::string &dbPath)
+bool RdbSecurityManager::IsKeyFileExists(const std::string &dbPath, KeyFileType keyFileType)
 {
-    const std::string dbName = RemoveSuffix(StringUtils::ExtractFileName(dbPath));
-    const std::string dbKeyDir = StringUtils::ExtractFilePath(dbPath) + "key/";
-    const std::string keyPath = dbKeyDir + dbName + RdbSecurityManager::SUFFIX_PUB_KEY;
-    const std::string newKeyPath = dbKeyDir + dbName + RdbSecurityManager::SUFFIX_PUB_KEY_NEW;
-    return std::make_pair(keyPath, newKeyPath);
+    KeyFiles keyFiles(dbPath, false);
+    return (access(keyFiles.GetKeyFile(keyFileType).c_str(), F_OK) == 0);
 }
 
-bool RdbSecurityManager::IsKeyFileExists(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType)
+void RdbSecurityManager::ChangeKeyFile(const std::string &dbPath)
 {
-    return (access(GetKeyPath(dbPath, keyFileType).c_str(), F_OK) == 0);
+    KeyFiles keyFiles(dbPath);
+    keyFiles.Lock();
+    auto &reKeyFile = keyFiles.GetKeyFile(PUB_KEY_FILE_NEW_KEY);
+    auto &keyFile = keyFiles.GetKeyFile(PUB_KEY_FILE);
+    SqliteUtils::RenameFile(reKeyFile, keyFile);
+    keyFiles.Unlock();
+}
+
+bool RdbSecurityManager::HasRootKey()
+{
+    return hasRootKey_;
+}
+
+bool RdbSecurityManager::IsKeyFileEmpty(const std::string &keyFile)
+{
+    if (access(keyFile.c_str(), F_OK) != 0) {
+        return true;
+    }
+    struct stat fileInfo;
+    auto errCode = stat(keyFile.c_str(), &fileInfo);
+    if (errCode == 0 && fileInfo.st_size == 0) {
+        return true;
+    }
+    return false;
 }
 
-std::string RdbSecurityManager::GetKeyPath(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType)
+int32_t RdbSecurityManager::RestoreKeyFile(const std::string &dbPath, const std::vector<uint8_t> &key)
 {
-    auto keyPaths = ConcatenateKeyPath(dbPath);
-    if (keyFileType == KeyFileType::PUB_KEY_FILE) {
-        return keyPaths.first;
-    } else {
-        return keyPaths.second;
+    KeyFiles keyFiles(dbPath);
+    keyFiles.Lock();
+    auto &keyFile = keyFiles.GetKeyFile(PUB_KEY_FILE);
+    auto &reKeyFile = keyFiles.GetKeyFile(PUB_KEY_FILE_NEW_KEY);
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        SqliteUtils::DeleteFile(keyFile);
+        SqliteUtils::DeleteFile(reKeyFile);
+    }
+    if (!SaveSecretKeyToFile(keyFile, key)) {
+        LOG_ERROR("failed, save key err:%{public}d, file:%{public}s.", errno, SqliteUtils::Anonymous(keyFile).c_str());
     }
+    keyFiles.Unlock();
+    return E_OK;
 }
 
-void RdbSecurityManager::DelRdbSecretDataFile(const std::string &dbPath, RdbSecurityManager::KeyFileType keyFileType)
+RdbSecurityManager::KeyFiles::KeyFiles(const std::string &dbPath, bool openFile)
 {
-    std::string keyPath = GetKeyPath(dbPath, keyFileType);
-    SqliteUtils::DeleteFile(keyPath);
+    const std::string dbKeyDir = StringUtils::ExtractFilePath(dbPath) + "key/";
+    if (!InitPath(dbKeyDir)) {
+        LOG_ERROR(
+            "dbKeyDir failed, errno:%{public}d, dir:%{public}s.", errno, SqliteUtils::Anonymous(dbKeyDir).c_str());
+    }
+    const std::string lockDir = StringUtils::ExtractFilePath(dbPath) + "lock/";
+    if (!InitPath(lockDir)) {
+        LOG_ERROR("lockDir failed, errno:%{public}d, dir:%{public}s.", errno, SqliteUtils::Anonymous(lockDir).c_str());
+    }
+    const std::string dbName = RemoveSuffix(StringUtils::ExtractFileName(dbPath));
+    lock_ = lockDir + dbName + SUFFIX_KEY_LOCK;
+    keys_[PUB_KEY_FILE] = dbKeyDir + dbName + SUFFIX_PUB_KEY;
+    keys_[PUB_KEY_FILE_NEW_KEY] = dbKeyDir + dbName + SUFFIX_PUB_KEY_NEW;
+    if (!openFile) {
+        return;
+    }
+    lockFd_ = open(lock_.c_str(), O_RDONLY | O_CREAT, S_IRWXU | S_IRWXG);
+    if (lockFd_ < 0) {
+        LOG_WARN("open failed, errno:%{public}d, file:%{public}s.", errno, SqliteUtils::Anonymous(lock_).c_str());
+    }
 }
 
-void RdbSecurityManager::UpdateKeyFile(const std::string &dbPath)
+RdbSecurityManager::KeyFiles::~KeyFiles()
 {
-    auto keyPaths = ConcatenateKeyPath(dbPath);
-    if (SqliteUtils::RenameFile(keyPaths.second, keyPaths.first) != E_OK) {
-        LOG_ERROR("Rename key file failed.");
+    if (lockFd_ < 0) {
         return;
     }
+    close(lockFd_);
+    lockFd_ = -1;
 }
 
-bool RdbSecurityManager::HasRootKey()
+const std::string &RdbSecurityManager::KeyFiles::GetKeyFile(KeyFileType type)
 {
-    return hasRootKey_;
+    if (type == PUB_KEY_FILE) {
+        return keys_[PUB_KEY_FILE];
+    }
+    return keys_[PUB_KEY_FILE_NEW_KEY];
+}
+
+int32_t RdbSecurityManager::KeyFiles::Lock()
+{
+    if (lockFd_ < 0) {
+        return E_INVALID_FILE_PATH;
+    }
+    int32_t errCode;
+    do {
+        errCode = flock(lockFd_, LOCK_EX);
+    } while (errCode < 0 && errno == EINTR);
+    if (errCode < 0) {
+        LOG_WARN("lock failed, errno:%{public}d, dir:%{public}s.", errno, SqliteUtils::Anonymous(lock_).c_str());
+        return E_ERROR;
+    }
+    return E_OK;
+}
+
+int32_t RdbSecurityManager::KeyFiles::Unlock()
+{
+    if (lockFd_ < 0) {
+        return E_INVALID_FILE_PATH;
+    }
+    int32_t errCode;
+    do {
+        errCode = flock(lockFd_, LOCK_UN);
+    } while (errCode < 0 && errno == EINTR);
+    if (errCode < 0) {
+        LOG_WARN("unlock failed, errno:%{public}d, dir:%{public}s.", errno, SqliteUtils::Anonymous(lock_).c_str());
+        return E_ERROR;
+    }
+    return E_OK;
+}
+
+int32_t RdbSecurityManager::KeyFiles::DestroyLock()
+{
+    if (lockFd_ >= 0) {
+        close(lockFd_);
+        lockFd_ = -1;
+    }
+    SqliteUtils::DeleteFile(lock_);
+    return E_OK;
 }
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/rdb_service_proxy.cpp b/relational_store/frameworks/native/rdb/src/rdb_service_proxy.cpp
index 83879ac3970aa36bfb893fb2155942ebd5bb0928..b829100906dec038b5a9825638f40895128b478d 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_service_proxy.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_service_proxy.cpp
@@ -74,13 +74,13 @@ int32_t RdbServiceProxy::InitNotifier(const RdbSyncerParam &param)
             OnDataChange(origin, primaries, std::move(changeInfo));
         });
     if (notifier_ == nullptr) {
-        LOG_ERROR("create notifier failed");
+        LOG_ERROR("create notifier failed.");
         return RDB_ERROR;
     }
 
     if (InitNotifier(param, notifier_->AsObject()) != RDB_OK) {
         notifier_ = nullptr;
-        LOG_ERROR("init notifier error");
+        LOG_ERROR("init notifier error.");
         return RDB_ERROR;
     }
 
@@ -121,7 +121,7 @@ std::pair<int32_t, Details> RdbServiceProxy::DoSync(const RdbSyncerParam& param,
     }
 
     if (!ITypesUtil::Unmarshal(reply, details)) {
-        LOG_ERROR("read result failed");
+        LOG_ERROR("read result failed.");
         status = RDB_ERROR;
         return result;
     }
@@ -133,10 +133,10 @@ int32_t RdbServiceProxy::DoSync(const RdbSyncerParam &param, const Option &optio
 {
     auto [status, details] = DoSync(param, option, predicates);
     if (status != RDB_OK) {
-        LOG_INFO("failed");
+        LOG_INFO("failed.");
         return RDB_ERROR;
     }
-    LOG_INFO("success");
+    LOG_INFO("success.");
     if (async != nullptr) {
         async(std::move(details));
     }
@@ -215,7 +215,7 @@ int32_t RdbServiceProxy::Subscribe(const RdbSyncerParam &param, const SubscribeO
         return RDB_ERROR;
     }
     if (option.mode < SubscribeMode::REMOTE || option.mode >= SUBSCRIBE_MODE_MAX) {
-        LOG_ERROR("subscribe mode invalid");
+        LOG_ERROR("subscribe mode invalid.");
         return RDB_ERROR;
     }
     if (DoSubscribe(param, option) != RDB_OK) {
@@ -251,7 +251,7 @@ int32_t RdbServiceProxy::UnSubscribe(const RdbSyncerParam &param, const Subscrib
                                      RdbStoreObserver *observer)
 {
     if (observer == nullptr) {
-        LOG_ERROR("observer is null");
+        LOG_ERROR("observer is null.");
         return RDB_ERROR;
     }
     if (DoUnSubscribe(param) != RDB_OK) {
@@ -296,7 +296,7 @@ std::pair<int32_t, std::shared_ptr<RdbServiceProxy::ResultSet>> RdbServiceProxy:
 
     sptr<IRemoteObject> remote = reply.ReadRemoteObject();
     if (remote == nullptr) {
-        LOG_ERROR("read remote object is null");
+        LOG_ERROR("read remote object is null.");
         return { RDB_ERROR, nullptr };
     }
     sptr<NativeRdb::ResultSetProxy> instance = new NativeRdb::ResultSetProxy(remote);
@@ -331,7 +331,7 @@ int32_t RdbServiceProxy::BeforeOpen(RdbSyncerParam &param)
         return status;
     }
     if (!ITypesUtil::Unmarshal(reply, param)) {
-        LOG_ERROR("read result failed");
+        LOG_ERROR("read result failed.");
         status = RDB_ERROR;
     }
     return status;
@@ -498,11 +498,25 @@ void RdbServiceProxy::OnSyncComplete(const std::string &storeName, Details &&res
     });
 }
 
-int32_t RdbServiceProxy::NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData)
+int32_t RdbServiceProxy::SetSearchable(const RdbSyncerParam& param, bool isSearchable)
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_SET_SEARCHABLE),
+        reply, param, isSearchable);
+    if (status != RDB_OK) {
+        LOG_ERROR("RdbServiceProxy SetSearchable fail, status:%{public}d, "
+                  "bundleName:%{public}s, storeName:%{public}s",
+            status, param.bundleName_.c_str(), SqliteUtils::Anonymous(param.storeName_).c_str());
+    }
+    return status;
+}
+
+int32_t RdbServiceProxy::NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData,
+    const RdbNotifyConfig &rdbNotifyConfig)
 {
     MessageParcel reply;
     int32_t status = IPC_SEND(static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_NOTIFY_DATA_CHANGE),
-        reply, param, rdbChangedData);
+        reply, param, rdbChangedData, rdbNotifyConfig);
     if (status != RDB_OK) {
         LOG_ERROR("RdbServiceProxy NotifyDataChange fail, status:%{public}d, "
                   "bundleName:%{public}s, storeName:%{public}s",
@@ -532,4 +546,50 @@ int32_t RdbServiceProxy::Enable(const RdbSyncerParam& param)
     }
     return status;
 }
+
+int32_t RdbServiceProxy::GetPassword(const RdbSyncerParam &param, std::vector<uint8_t> &key)
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_GET_PASSWORD), reply, param);
+    if (status != RDB_OK) {
+        LOG_ERROR("fail, status:%{public}d, bundleName:%{public}s, storeName:%{public}s", status,
+            param.bundleName_.c_str(), SqliteUtils::Anonymous(param.storeName_).c_str());
+        return status;
+    }
+    if (!ITypesUtil::Unmarshal(reply, key)) {
+        LOG_ERROR("unmarshal key failed.");
+        status = RDB_ERROR;
+    }
+    return status;
+}
+
+std::pair<int32_t, uint32_t> RdbServiceProxy::LockCloudContainer(const RdbSyncerParam& param)
+{
+    MessageParcel reply;
+    uint32_t expiredTime = 0;
+    int32_t status = IPC_SEND(static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_LOCK_CLOUD_CONTAINER), reply,
+        param, expiredTime);
+    if (status != RDB_OK) {
+        LOG_ERROR("fail, status:%{public}d, bundleName:%{public}s, storeName:%{public}s", status,
+            param.bundleName_.c_str(), SqliteUtils::Anonymous(param.storeName_).c_str());
+        return { status, expiredTime };
+    }
+    if (!ITypesUtil::Unmarshal(reply, expiredTime)) {
+        LOG_ERROR("Unmarshal failed");
+        status = RDB_ERROR;
+    }
+    return { status, expiredTime };
+}
+
+int32_t RdbServiceProxy::UnlockCloudContainer(const RdbSyncerParam& param)
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_UNLOCK_CLOUD_CONTAINER),
+        reply, param);
+    if (status != RDB_OK) {
+        LOG_ERROR("fail, status:%{public}d, bundleName:%{public}s, storeName:%{public}s", status,
+            param.bundleName_.c_str(), SqliteUtils::Anonymous(param.storeName_).c_str());
+    }
+    return status;
+}
 } // namespace OHOS::DistributedRdb
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/src/rdb_sql_statistic.cpp b/relational_store/frameworks/native/rdb/src/rdb_sql_statistic.cpp
index 75281f5c992a2bffa7ad0e9b02670ec3dccc4bd6..94dbe863bd201a5e368b72585262a05c06225a4e 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_sql_statistic.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_sql_statistic.cpp
@@ -16,12 +16,14 @@
 #define LOG_TAG "RdbSqlStatistic"
 
 #include "rdb_sql_statistic.h"
-#include "task_executor.h"
-#include "rdb_errno.h"
-#include "rdb_platform.h"
-#include "logger.h"
+
 #include <thread>
 
+#include "concurrent_map.h"
+#include "logger.h"
+#include "rdb_errno.h"
+#include "rdb_platform.h"
+#include "task_executor.h"
 namespace OHOS::DistributedRdb {
 using namespace OHOS::Rdb;
 using namespace OHOS::NativeRdb;
diff --git a/relational_store/frameworks/native/rdb/src/rdb_store_config.cpp b/relational_store/frameworks/native/rdb/src/rdb_store_config.cpp
index 30b22bfee90490214ce5cf102e2628559009a374..22db48a1dea32f62054a66e98bc6cfc47e8ed388 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_store_config.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_store_config.cpp
@@ -18,6 +18,7 @@
 #include "logger.h"
 #include "rdb_errno.h"
 #include "rdb_security_manager.h"
+#include "string_utils.h"
 
 namespace OHOS::NativeRdb {
 using namespace OHOS::Rdb;
@@ -26,21 +27,12 @@ RdbStoreConfig::RdbStoreConfig(const std::string &name, StorageMode storageMode,
     const std::vector<uint8_t> &encryptKey, const std::string &journalMode, const std::string &syncMode,
     const std::string &databaseFileType, SecurityLevel securityLevel, bool isCreateNecessary, bool autoCheck,
     int journalSize, int pageSize, const std::string &encryptAlgo)
-    : readOnly(isReadOnly),
-      isCreateNecessary_(isCreateNecessary),
-      autoCheck_(autoCheck),
-      journalSize(journalSize),
-      pageSize(pageSize),
-      securityLevel(securityLevel),
-      storageMode(storageMode),
-      name(name),
-      path(name),
-      journalMode(journalMode),
-      syncMode(syncMode),
-      databaseFileType(databaseFileType),
-      encryptAlgo(encryptAlgo),
+    : readOnly_(isReadOnly), isCreateNecessary_(isCreateNecessary), autoCheck_(autoCheck), journalSize_(journalSize),
+      pageSize_(pageSize), securityLevel_(securityLevel), storageMode_(storageMode), path_(name),
+      journalMode_(journalMode), syncMode_(syncMode), databaseFileType(databaseFileType), encryptAlgo_(encryptAlgo),
       encryptKey_(encryptKey)
 {
+    name_ = StringUtils::ExtractFileName(name);
 }
 
 RdbStoreConfig::~RdbStoreConfig()
@@ -53,7 +45,7 @@ RdbStoreConfig::~RdbStoreConfig()
  */
 std::string RdbStoreConfig::GetName() const
 {
-    return name;
+    return name_;
 }
 
 /**
@@ -61,7 +53,7 @@ std::string RdbStoreConfig::GetName() const
  */
 std::string RdbStoreConfig::GetPath() const
 {
-    return path;
+    return path_;
 }
 
 /**
@@ -69,7 +61,7 @@ std::string RdbStoreConfig::GetPath() const
  */
 StorageMode RdbStoreConfig::GetStorageMode() const
 {
-    return storageMode;
+    return storageMode_;
 }
 
 /**
@@ -77,7 +69,7 @@ StorageMode RdbStoreConfig::GetStorageMode() const
  */
 std::string RdbStoreConfig::GetJournalMode() const
 {
-    return journalMode;
+    return journalMode_;
 }
 
 /**
@@ -85,7 +77,7 @@ std::string RdbStoreConfig::GetJournalMode() const
  */
 std::string RdbStoreConfig::GetSyncMode() const
 {
-    return syncMode;
+    return syncMode_;
 }
 
 /**
@@ -93,7 +85,7 @@ std::string RdbStoreConfig::GetSyncMode() const
  */
 bool RdbStoreConfig::IsReadOnly() const
 {
-    return readOnly;
+    return readOnly_;
 }
 
 /**
@@ -114,7 +106,7 @@ std::string RdbStoreConfig::GetDatabaseFileType() const
 
 void RdbStoreConfig::SetName(std::string name)
 {
-    this->name = std::move(name);
+    this->name_ = std::move(name);
 }
 
 /**
@@ -122,7 +114,12 @@ void RdbStoreConfig::SetName(std::string name)
  */
 void RdbStoreConfig::SetJournalMode(JournalMode journalMode)
 {
-    this->journalMode = GetJournalModeValue(journalMode);
+    this->journalMode_ = GetJournalModeValue(journalMode);
+}
+
+void RdbStoreConfig::SetJournalMode(const std::string &journalMode)
+{
+    this->journalMode_ = journalMode;
 }
 
 void RdbStoreConfig::SetDatabaseFileType(DatabaseFileType type)
@@ -135,12 +132,12 @@ void RdbStoreConfig::SetDatabaseFileType(DatabaseFileType type)
  */
 void RdbStoreConfig::SetPath(std::string path)
 {
-    this->path = std::move(path);
+    this->path_ = std::move(path);
 }
 
 void RdbStoreConfig::SetStorageMode(StorageMode storageMode)
 {
-    this->storageMode = storageMode;
+    this->storageMode_ = storageMode;
 }
 
 bool RdbStoreConfig::IsAutoCheck() const
@@ -153,39 +150,38 @@ void RdbStoreConfig::SetAutoCheck(bool autoCheck)
 }
 int RdbStoreConfig::GetJournalSize() const
 {
-    return journalSize;
+    return journalSize_;
 }
 void RdbStoreConfig::SetJournalSize(int journalSize)
 {
-    this->journalSize = journalSize;
+    this->journalSize_ = journalSize;
 }
 int RdbStoreConfig::GetPageSize() const
 {
-    return pageSize;
+    return pageSize_;
 }
 void RdbStoreConfig::SetPageSize(int pageSize)
 {
-    this->pageSize = pageSize;
+    this->pageSize_ = pageSize;
 }
 const std::string RdbStoreConfig::GetEncryptAlgo() const
 {
-    return encryptAlgo;
+    return encryptAlgo_;
 }
 void RdbStoreConfig::SetEncryptAlgo(const std::string &encryptAlgo)
 {
-    this->encryptAlgo = encryptAlgo;
+    this->encryptAlgo_ = encryptAlgo;
 }
 
 void RdbStoreConfig::SetReadOnly(bool readOnly)
 {
-    this->readOnly = readOnly;
+    this->readOnly_ = readOnly;
 }
 
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 int RdbStoreConfig::SetDistributedType(DistributedType type)
 {
     if (type != DistributedType::RDB_DEVICE_COLLABORATION) {
-        LOG_ERROR("type is invalid");
+        LOG_ERROR("type is invalid.");
         return E_ERROR;
     }
     distributedType_ = type;
@@ -196,12 +192,11 @@ DistributedType RdbStoreConfig::GetDistributedType() const
 {
     return distributedType_;
 }
-#endif
 
 int RdbStoreConfig::SetBundleName(const std::string &bundleName)
 {
     if (bundleName.empty()) {
-        LOG_ERROR("bundleName is empty");
+        LOG_ERROR("bundleName is empty.");
         return E_ERROR;
     }
     bundleName_ = bundleName;
@@ -299,12 +294,12 @@ std::string RdbStoreConfig::GetDatabaseFileTypeValue(DatabaseFileType databaseFi
 
 void RdbStoreConfig::SetSecurityLevel(SecurityLevel sl)
 {
-    securityLevel = sl;
+    securityLevel_ = sl;
 }
 
 SecurityLevel RdbStoreConfig::GetSecurityLevel() const
 {
-    return securityLevel;
+    return securityLevel_;
 }
 
 void RdbStoreConfig::SetEncryptStatus(const bool status)
@@ -314,7 +309,7 @@ void RdbStoreConfig::SetEncryptStatus(const bool status)
 
 bool RdbStoreConfig::IsEncrypt() const
 {
-    return this->isEncrypt_;
+    return isEncrypt_ || !encryptKey_.empty();
 }
 
 bool RdbStoreConfig::IsCreateNecessary() const
@@ -342,6 +337,19 @@ void RdbStoreConfig::SetEncryptKey(const std::vector<uint8_t> &encryptKey)
     encryptKey_ = encryptKey;
 }
 
+void RdbStoreConfig::RestoreEncryptKey(const std::vector<uint8_t> &encryptKey) const
+{
+    RdbSecurityManager::GetInstance().RestoreKeyFile(GetPath(), encryptKey);
+    encryptKey_.assign(encryptKey_.size(), 0);
+    newEncryptKey_.assign(newEncryptKey_.size(), 0);
+    encryptKey_ = encryptKey;
+}
+
+void RdbStoreConfig::SetNewEncryptKey(const std::vector<uint8_t> newEncryptKey)
+{
+    newEncryptKey_ = newEncryptKey;
+}
+
 std::vector<uint8_t> RdbStoreConfig::GetEncryptKey() const
 {
     return encryptKey_;
@@ -349,12 +357,14 @@ std::vector<uint8_t> RdbStoreConfig::GetEncryptKey() const
 
 void RdbStoreConfig::ChangeEncryptKey() const
 {
-    if (encryptKey_.size() == newEncryptKey_.size()) {
-        encryptKey_.assign(encryptKey_.size(), 0);
-        encryptKey_.assign(newEncryptKey_.data(), newEncryptKey_.data() + newEncryptKey_.size());
-        newEncryptKey_.assign(newEncryptKey_.size(), 0);
-        newEncryptKey_.resize(0);
+    RdbSecurityManager::GetInstance().ChangeKeyFile(GetPath());
+    if (newEncryptKey_.empty()) {
+        return;
     }
+    encryptKey_.assign(encryptKey_.size(), 0);
+    encryptKey_.assign(newEncryptKey_.data(), newEncryptKey_.data() + newEncryptKey_.size());
+    newEncryptKey_.assign(newEncryptKey_.size(), 0);
+    newEncryptKey_.resize(0);
 }
 
 std::vector<uint8_t> RdbStoreConfig::GetNewEncryptKey() const
@@ -362,44 +372,44 @@ std::vector<uint8_t> RdbStoreConfig::GetNewEncryptKey() const
     return newEncryptKey_;
 }
 
-void RdbStoreConfig::Initialize() const
+int32_t RdbStoreConfig::Initialize() const
 {
-    GenerateEncryptedKey();
+    return GenerateEncryptedKey();
 }
 
-void RdbStoreConfig::GenerateEncryptedKey() const
+int32_t RdbStoreConfig::GenerateEncryptedKey() const
 {
     if (!isEncrypt_) {
-        return;
+        return E_OK;
     }
 
     auto name = bundleName_;
     if (name.empty()) {
-        name = std::string(path).substr(0, path.rfind("/") + 1);
+        name = std::string(path_).substr(0, path_.rfind("/") + 1);
     }
+    using KeyFileType = RdbSecurityManager::KeyFileType;
     auto errCode = RdbSecurityManager::GetInstance().Init(name);
     if (errCode != E_OK) {
         LOG_ERROR("generate root encrypt key failed, bundleName_:%{public}s", bundleName_.c_str());
-        return;
+        return errCode;
     }
-    auto rdbPwd = RdbSecurityManager::GetInstance().GetRdbPassword(path, RdbSecurityManager::KeyFileType::PUB_KEY_FILE);
-    if (!rdbPwd.IsValid()) {
-        LOG_ERROR("key is inValid, bundleName_:%{public}s", bundleName_.c_str());
-        return;
+    auto rdbPwd = RdbSecurityManager::GetInstance().GetRdbPassword(path_, KeyFileType::PUB_KEY_FILE);
+    if (rdbPwd.IsValid()) {
+        encryptKey_ = std::vector<uint8_t>(rdbPwd.GetData(), rdbPwd.GetData() + rdbPwd.GetSize());
     }
-    encryptKey_ = std::vector<uint8_t>(rdbPwd.GetData(), rdbPwd.GetData() + rdbPwd.GetSize());
     rdbPwd.Clear();
-
-    if (rdbPwd.isKeyExpired) {
-        auto rdbNewPwd = RdbSecurityManager::GetInstance().GetRdbPassword(path,
-            RdbSecurityManager::KeyFileType::PUB_KEY_FILE_NEW_KEY);
-        if (!rdbNewPwd.IsValid()) {
-            LOG_ERROR("key is inValid, bundleName_:%{public}s", bundleName_.c_str());
-            return;
+    if ((rdbPwd.isKeyExpired && autoRekey_) ||
+        RdbSecurityManager::GetInstance().IsKeyFileExists(path_, KeyFileType::PUB_KEY_FILE_NEW_KEY)) {
+        auto rdbNewPwd = RdbSecurityManager::GetInstance().GetRdbPassword(path_, KeyFileType::PUB_KEY_FILE_NEW_KEY);
+        if (rdbNewPwd.IsValid()) {
+            newEncryptKey_ = std::vector<uint8_t>(rdbNewPwd.GetData(), rdbNewPwd.GetData() + rdbNewPwd.GetSize());
         }
-        newEncryptKey_ = std::vector<uint8_t>(rdbNewPwd.GetData(), rdbNewPwd.GetData() + rdbNewPwd.GetSize());
         rdbPwd.Clear();
     }
+    if (encryptKey_.empty() && newEncryptKey_.empty()) {
+        LOG_WARN("key is inValid, bundleName_:%{public}s", bundleName_.c_str());
+    }
+    return E_OK;
 }
 
 void RdbStoreConfig::ClearEncryptKey()
@@ -413,6 +423,11 @@ void RdbStoreConfig::SetScalarFunction(const std::string &functionName, int argc
     customScalarFunctions.try_emplace(functionName, ScalarFunctionInfo(function, argc));
 }
 
+void RdbStoreConfig::SetScalarFunctions(const std::map<std::string, ScalarFunctionInfo> functions)
+{
+    customScalarFunctions = functions;
+}
+
 std::map<std::string, ScalarFunctionInfo> RdbStoreConfig::GetScalarFunctions() const
 {
     return customScalarFunctions;
@@ -528,4 +543,49 @@ bool RdbStoreConfig::GetAllowRebuild() const
 {
     return allowRebuilt_;
 }
+
+void RdbStoreConfig::SetIntegrityCheck(IntegrityCheck checkType)
+{
+    checkType_ = checkType;
+}
+
+IntegrityCheck RdbStoreConfig::GetIntegrityCheck() const
+{
+    return checkType_;
+}
+
+void RdbStoreConfig::SetPluginLibs(const std::vector<std::string> &pluginLibs)
+{
+    pluginLibs_ = pluginLibs;
+}
+
+std::vector<std::string> RdbStoreConfig::GetPluginLibs() const
+{
+    return pluginLibs_;
+}
+
+int32_t RdbStoreConfig::GetIter() const
+{
+    return iter_;
+}
+
+void RdbStoreConfig::SetIter(int32_t iter) const
+{
+    iter_ = iter;
+}
+
+int32_t RdbStoreConfig::GetHaMode() const
+{
+    return haMode_;
+}
+
+void RdbStoreConfig::SetHaMode(int32_t haMode)
+{
+    haMode_ = haMode;
+}
+
+void RdbStoreConfig::EnableRekey(bool enable)
+{
+    autoRekey_ = enable;
+}
 } // namespace OHOS::NativeRdb
diff --git a/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp b/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp
index c22b097257e04e7bfbae523c5c35953a872274a1..e55701ff786153599827149a914c896d52230375 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_store_impl.cpp
@@ -45,7 +45,7 @@
 #include "traits.h"
 
 #include "directory_ex.h"
-
+#include "rdb_fault_hiview_reporter.h"
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 #include "delay_notify.h"
 #include "raw_data_parser.h"
@@ -68,6 +68,7 @@ namespace OHOS::NativeRdb {
 using namespace OHOS::Rdb;
 using namespace std::chrono;
 using SqlStatistic = DistributedRdb::SqlStatistic;
+using RdbNotifyConfig = DistributedRdb::RdbNotifyConfig;
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 using RdbMgr = DistributedRdb::RdbManagerImpl;
 #endif
@@ -76,11 +77,8 @@ static constexpr const char *BEGIN_TRANSACTION_SQL = "begin;";
 static constexpr const char *COMMIT_TRANSACTION_SQL = "commit;";
 static constexpr const char *ROLLBACK_TRANSACTION_SQL = "rollback;";
 
-int RdbStoreImpl::InnerOpen()
+void RdbStoreImpl::InitSyncerParam()
 {
-    LOG_DEBUG("open %{public}s.", SqliteUtils::Anonymous(path_).c_str());
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-    pool_ = TaskExecutor::GetInstance().GetExecutor();
     syncerParam_.bundleName_ = config_.GetBundleName();
     syncerParam_.hapName_ = config_.GetModuleName();
     syncerParam_.storeName_ = config_.GetName();
@@ -92,8 +90,16 @@ int RdbStoreImpl::InnerOpen()
     syncerParam_.isAutoClean_ = config_.GetAutoClean();
     syncerParam_.isSearchable_ = config_.IsSearchable();
     syncerParam_.password_ = {};
-
+    syncerParam_.haMode_ = config_.GetHaMode();
     syncerParam_.roleType_ = config_.GetRoleType();
+}
+
+int RdbStoreImpl::InnerOpen()
+{
+    LOG_DEBUG("open %{public}s.", SqliteUtils::Anonymous(path_).c_str());
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+    pool_ = TaskExecutor::GetInstance().GetExecutor();
+
     if (config_.GetRoleType() == OWNER) {
         AfterOpen(config_);
     }
@@ -108,14 +114,6 @@ int RdbStoreImpl::InnerOpen()
 }
 
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-std::string RdbStoreImpl::GetSecManagerName(const RdbStoreConfig &config)
-{
-    auto name = config.GetBundleName();
-    if (name.empty()) {
-        return std::string(config.GetPath()).substr(0, config.GetPath().rfind("/") + 1);
-    }
-    return name;
-}
 
 void RdbStoreImpl::AfterOpen(const RdbStoreConfig &config)
 {
@@ -242,7 +240,7 @@ RdbStore::ModifyTime RdbStoreImpl::GetModifyTime(const std::string &table, const
         tmp[columnName] = value;
         auto hashKey = DistributedDB::RelationalStoreManager::CalcPrimaryKeyHash(tmp);
         if (hashKey.empty()) {
-            LOG_DEBUG("hash key fail");
+            LOG_DEBUG("hash key fail.");
             continue;
         }
         hashKeys.emplace_back(ValueObject(hashKey));
@@ -293,9 +291,6 @@ int RdbStoreImpl::CleanDirtyData(const std::string &table, uint64_t cursor)
     if ((config_.GetRoleType() == VISITOR) || (config_.GetDBType() == DB_VECTOR) || (config_.IsReadOnly())) {
         return E_NOT_SUPPORT;
     }
-    if (table.empty()) {
-        return E_INVALID_ARGS;
-    }
     auto connection = connectionPool_->AcquireConnection(false);
     if (connection == nullptr) {
         return E_DATABASE_BUSY;
@@ -306,23 +301,35 @@ int RdbStoreImpl::CleanDirtyData(const std::string &table, uint64_t cursor)
 #endif
 
 RdbStoreImpl::RdbStoreImpl(const RdbStoreConfig &config)
-    : config_(config), isOpen_(false), isReadOnly_(config.IsReadOnly()),
-      isMemoryRdb_(config.IsMemoryRdb()), isEncrypt_(config.IsEncrypt()), path_(config.GetPath()),
-      orgPath_(config.GetPath()), name_(config.GetName()), fileType_(config.GetDatabaseFileType()),
-      connectionPool_(nullptr), rebuild_(RebuiltType::NONE)
+    : config_(config), isOpen_(false), isReadOnly_(config.IsReadOnly()), isMemoryRdb_(config.IsMemoryRdb()),
+      isEncrypt_(config.IsEncrypt()), path_(config.GetPath()), name_(config.GetName()),
+      fileType_(config.GetDatabaseFileType()), connectionPool_(nullptr), rebuild_(RebuiltType::NONE),
+      slaveStatus_(SlaveStatus::UNDEFINED)
 {
 }
 
 RdbStoreImpl::RdbStoreImpl(const RdbStoreConfig &config, int &errCode)
     : config_(config), isReadOnly_(config.IsReadOnly()), isMemoryRdb_(config.IsMemoryRdb()),
       isEncrypt_(config.IsEncrypt()), name_(config.GetName()), fileType_(config.GetDatabaseFileType()),
-      rebuild_(RebuiltType::NONE)
+      rebuild_(RebuiltType::NONE), slaveStatus_(SlaveStatus::UNDEFINED)
 {
     path_ = (config.GetRoleType() == VISITOR) ? config.GetVisitorDir() : config.GetPath();
-    connectionPool_ = SqliteConnectionPool::Create(config_, errCode);
+    connectionPool_ = ConnectionPool::Create(config_, errCode);
+    InitSyncerParam();
     if (connectionPool_ == nullptr && errCode == E_SQLITE_CORRUPT && config.GetAllowRebuild() && !config.IsReadOnly()) {
         LOG_ERROR("database corrupt, rebuild database %{public}s", name_.c_str());
-        std::tie(rebuild_, connectionPool_) = SqliteConnectionPool::HandleDataCorruption(config_, errCode);
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+        auto [err, service] = RdbMgr::GetInstance().GetRdbService(syncerParam_);
+        if (service != nullptr) {
+            service->Disable(syncerParam_);
+        }
+#endif
+        std::tie(rebuild_, connectionPool_) = ConnectionPool::HandleDataCorruption(config_, errCode);
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+        if (service != nullptr) {
+            service->Enable(syncerParam_);
+        }
+#endif
     }
     if (connectionPool_ == nullptr || errCode != E_OK) {
         connectionPool_ = nullptr;
@@ -344,6 +351,8 @@ void RdbStoreImpl::RemoveDbFiles(std::string &path)
     SqliteUtils::DeleteFile(path + "-shm");
     SqliteUtils::DeleteFile(path + "-wal");
     SqliteUtils::DeleteFile(path + "-journal");
+    SqliteUtils::DeleteFile(path + "-slaveFailure");
+    SqliteUtils::DeleteFile(path + "-syncInterrupt");
 }
 
 const RdbStoreConfig &RdbStoreImpl::GetConfig()
@@ -497,6 +506,7 @@ int RdbStoreImpl::InsertWithConflictResolutionEntry(int64_t &outRowId, const std
         if (val.GetType() == ValueObject::TYPE_ASSET || val.GetType() == ValueObject::TYPE_ASSETS) {
             SetAssetStatus(val, AssetValue::STATUS_INSERT);
         }
+
         bindArgs.push_back(val);  // columnValue
         split = ",";
     }
@@ -603,10 +613,12 @@ int RdbStoreImpl::UpdateWithConflictResolutionEntry(int &changedRows, const std:
     const char *split = "";
     for (auto &[key, val] : values.values_) {
         sql.append(split);
-        if (val.GetType() != ValueObject::TYPE_ASSETS) {
-            sql.append(key).append("=?"); // columnName
-        } else {
+        if (val.GetType() == ValueObject::TYPE_ASSETS) {
             sql.append(key).append("=merge_assets(").append(key).append(", ?)"); // columnName
+        } else if (val.GetType() == ValueObject::TYPE_ASSET) {
+            sql.append(key).append("=merge_asset(").append(key).append(", ?)"); // columnName
+        } else {
+            sql.append(key).append("=?"); // columnName
         }
         tmpBindArgs.push_back(val); // columnValue
         split = ",";
@@ -786,6 +798,18 @@ std::shared_ptr<AbsSharedResultSet> RdbStoreImpl::QuerySql(const std::string &sq
     }
     return std::make_shared<SqliteSharedResultSet>(connectionPool_, path_, sql, bindArgs);
 }
+
+void RdbStoreImpl::NotifyDataChange()
+{
+    int errCode = RegisterDataChangeCallback();
+    if (errCode != E_OK) {
+        LOG_ERROR("RegisterDataChangeCallback is failed, err is %{public}d.", errCode);
+    }
+    DistributedRdb::RdbChangedData rdbChangedData;
+    if (delayNotifier_ != nullptr) {
+        delayNotifier_->UpdateNotify(rdbChangedData, true);
+    }
+}
 #endif
 
 #if defined(WINDOWS_PLATFORM) || defined(MAC_PLATFORM) || defined(ANDROID_PLATFORM) || defined(IOS_PLATFORM)
@@ -1041,6 +1065,19 @@ int RdbStoreImpl::GetDataBasePath(const std::string &databasePath, std::string &
     return E_OK;
 }
 
+int RdbStoreImpl::GetSlaveName(const std::string &path, std::string &backupFilePath)
+{
+    std::string suffix(".db");
+    std::string slaveSuffix("_slave.db");
+    auto pos = path.find(suffix);
+    if (pos == std::string::npos) {
+        backupFilePath = path + slaveSuffix;
+    } else {
+        backupFilePath = std::string(path, 0, pos) + slaveSuffix;
+    }
+    return E_OK;
+}
+
 int RdbStoreImpl::ExecuteSqlInner(const std::string &sql, const std::vector<ValueObject> &bindArgs)
 {
     auto [errCode, statement] = BeginExecuteSql(sql);
@@ -1060,29 +1097,47 @@ int RdbStoreImpl::ExecuteSqlInner(const std::string &sql, const std::vector<Valu
  */
 int RdbStoreImpl::Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey)
 {
+    LOG_INFO("Backup db: %{public}s.", config_.GetName().c_str());
     if ((config_.GetRoleType() == VISITOR)) {
         return E_NOT_SUPPORT;
     }
     std::string backupFilePath;
+    if (TryGetMasterSlaveBackupPath(databasePath, backupFilePath)) {
+        return InnerBackup(backupFilePath, destEncryptKey);
+    }
+
     int ret = GetDataBasePath(databasePath, backupFilePath);
     if (ret != E_OK) {
         return ret;
     }
-    std::string tempPath = backupFilePath + "temp";
-    while (access(tempPath.c_str(), F_OK) == E_OK) {
-        tempPath += "temp";
+
+    auto deleteDirtyFiles = [&backupFilePath] {
+        auto res = SqliteUtils::DeleteFile(backupFilePath);
+        res = SqliteUtils::DeleteFile(backupFilePath + "-shm") && res;
+        res = SqliteUtils::DeleteFile(backupFilePath + "-wal") && res;
+        return res;
+    };
+
+    auto walFile = backupFilePath + "-wal";
+    if (access(walFile.c_str(), F_OK) == E_OK) {
+        if (!deleteDirtyFiles()) {
+            return E_ERROR;
+        }
     }
-    if (access(backupFilePath.c_str(), F_OK) == E_OK) {
+    std::string tempPath = backupFilePath + ".tmp";
+    if (access(tempPath.c_str(), F_OK) == E_OK) {
+        SqliteUtils::DeleteFile(backupFilePath);
+    } else {
         SqliteUtils::RenameFile(backupFilePath, tempPath);
-        ret = InnerBackup(backupFilePath, destEncryptKey);
-        if (ret == E_OK) {
-            SqliteUtils::DeleteFile(tempPath);
-        } else {
+    }
+    ret = InnerBackup(backupFilePath, destEncryptKey);
+    if (ret != E_OK || access(walFile.c_str(), F_OK) == E_OK) {
+        if (deleteDirtyFiles()) {
             SqliteUtils::RenameFile(tempPath, backupFilePath);
         }
-        return ret;
+    } else {
+        SqliteUtils::DeleteFile(tempPath);
     }
-    ret = InnerBackup(backupFilePath, destEncryptKey);
     return ret;
 }
 
@@ -1101,7 +1156,11 @@ int RdbStoreImpl::InnerBackup(const std::string &databasePath, const std::vector
         if (isEncrypt_) {
             return E_NOT_SUPPORT;
         }
-        return conn->Backup(databasePath, {});
+        return conn->Backup(databasePath, {}, false, slaveStatus_);
+    }
+    if (config_.GetHaMode() != HAMode::SINGLE && SqliteUtils::IsSlaveDbName(databasePath)) {
+        auto conn = connectionPool_->AcquireConnection(false);
+        return conn == nullptr ? E_BASE : conn->Backup(databasePath, {}, false, slaveStatus_);
     }
     auto [errCode, statement] = GetStatement(GlobalExpr::CIPHER_DEFAULT_ATTACH_HMAC_ALGO, true);
     if (statement == nullptr) {
@@ -1220,8 +1279,9 @@ int RdbStoreImpl::AttachInner(
 std::pair<int32_t, int32_t> RdbStoreImpl::Attach(
     const RdbStoreConfig &config, const std::string &attachName, int32_t waitTime)
 {
-    if ((config_.GetRoleType() == VISITOR) || (config_.GetDBType() == DB_VECTOR) || (config_.IsReadOnly())) {
-        return { E_NOT_SUPPORT, 0 };
+    if ((config_.GetRoleType() == VISITOR) || (config_.GetDBType() == DB_VECTOR) || (config_.IsReadOnly()) ||
+        config_.GetHaMode() != HAMode::SINGLE) {
+        return {E_NOT_SUPPORT, 0};
     }
     std::string dbPath;
     int err = SqliteGlobalConfig::GetDbPath(config, dbPath);
@@ -1248,7 +1308,8 @@ std::pair<int32_t, int32_t> RdbStoreImpl::Attach(
     }
 #endif
     err = AttachInner(attachName, dbPath, key, waitTime);
-    if (err == SQLITE_ERROR) {
+    key.assign(key.size(), 0);
+    if (err == E_SQLITE_ERROR) {
         // only when attachName is already in use, SQLITE-ERROR will be reported here.
         return { E_ATTACHED_DATABASE_EXIST, 0 };
     } else if (err != E_OK) {
@@ -1359,7 +1420,6 @@ int RdbStoreImpl::BeginTransaction()
     if (errCode != E_OK) {
         LOG_ERROR("transaction id: %{public}zu, storeName: %{public}s, errCode: %{public}d",
             transactionId, name_.c_str(), errCode);
-
         return errCode;
     }
     connectionPool_->SetInTransaction(true);
@@ -1387,12 +1447,11 @@ std::pair<int, int64_t> RdbStoreImpl::BeginTrans()
         LOG_ERROR("Get null connection, storeName: %{public}s time:%{public}" PRIu64 ".", name_.c_str(), time);
         return {errCode, 0};
     }
-    tmpTrxId = newTrxId_;
-    newTrxId_++;
-    trxConnMap_[tmpTrxId] = connection;
+    tmpTrxId = newTrxId_.fetch_add(1);
+    trxConnMap_.Insert(tmpTrxId, connection);
     errCode = ExecuteByTrxId(BEGIN_TRANSACTION_SQL, tmpTrxId);
     if (errCode != E_OK) {
-        trxConnMap_.erase(tmpTrxId);
+        trxConnMap_.Erase(tmpTrxId);
     }
     return {errCode, tmpTrxId};
 }
@@ -1425,6 +1484,11 @@ int RdbStoreImpl::RollBack()
         return E_DATABASE_BUSY;
     }
     errCode = statement->Execute();
+    if (errCode != E_OK) {
+        LOG_ERROR("failed, id: %{public}zu, storeName: %{public}s, errCode: %{public}d",
+            transactionId, name_.c_str(), errCode);
+        return errCode;
+    }
     if (connectionPool_->GetTransactionStack().empty()) {
         connectionPool_->SetInTransaction(false);
     }
@@ -1445,12 +1509,14 @@ int RdbStoreImpl::ExecuteByTrxId(const std::string &sql, int64_t trxId, bool clo
     if (trxId == 0) {
         return E_INVALID_ARGS;
     }
-    if (trxConnMap_.find(trxId) == trxConnMap_.end()) {
+
+    if (!trxConnMap_.Contains(trxId)) {
         LOG_ERROR("trxId hasn't appeared before %{public}" PRIu64, trxId);
         return E_INVALID_ARGS;
     }
     auto time = static_cast<uint64_t>(duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count());
-    auto connection = trxConnMap_[trxId];
+    auto result = trxConnMap_.Find(trxId);
+    auto connection = result.second;
     if (connection == nullptr) {
         LOG_ERROR("Get null connection, storeName: %{public}s time:%{public}" PRIu64 ".", name_.c_str(), time);
         return E_ERROR;
@@ -1464,11 +1530,11 @@ int RdbStoreImpl::ExecuteByTrxId(const std::string &sql, int64_t trxId, bool clo
         LOG_ERROR(
             "transaction id: %{public}" PRIu64 ", storeName: %{public}s, errCode: %{public}d" PRIu64, trxId,
             name_.c_str(), ret);
-        trxConnMap_.erase(trxId);
+        trxConnMap_.Erase(trxId);
         return ret;
     }
     if (closeConnAfterExecute) {
-        trxConnMap_.erase(trxId);
+        trxConnMap_.Erase(trxId);
     }
     return E_OK;
 }
@@ -1508,6 +1574,11 @@ int RdbStoreImpl::Commit()
         return E_DATABASE_BUSY;
     }
     errCode = statement->Execute();
+    if (errCode != E_OK) {
+        LOG_ERROR("failed, id: %{public}zu, storeName: %{public}s, errCode: %{public}d",
+            transactionId, name_.c_str(), errCode);
+        return errCode;
+    }
     connectionPool_->SetInTransaction(false);
     // 1 means the number of transactions in process
     if (transactionId > 1) {
@@ -1656,55 +1727,104 @@ int RdbStoreImpl::ConfigLocale(const std::string &localeStr)
     }
 
     if (connectionPool_ == nullptr) {
-        LOG_ERROR("connectionPool_ is null");
+        LOG_ERROR("connectionPool_ is null.");
         return E_ERROR;
     }
     return connectionPool_->ConfigLocale(localeStr);
 }
 
+int RdbStoreImpl::GetDestPath(const std::string &backupPath, std::string &destPath)
+{
+    int ret = GetDataBasePath(backupPath, destPath);
+    if (ret != E_OK) {
+        return ret;
+    }
+    std::string tempPath = destPath + ".tmp";
+    if (access(tempPath.c_str(), F_OK) == E_OK) {
+        destPath = tempPath;
+    } else {
+        auto walFile = destPath + "-wal";
+        if (access(walFile.c_str(), F_OK) == E_OK) {
+            return E_ERROR;
+        }
+    }
+
+    if (access(destPath.c_str(), F_OK) != E_OK) {
+        LOG_ERROR("The backupFilePath does not exists.");
+        return E_INVALID_FILE_PATH;
+    }
+    return E_OK;
+}
+
 int RdbStoreImpl::Restore(const std::string &backupPath, const std::vector<uint8_t> &newKey)
 {
+    LOG_INFO("Restore db: %{public}s.", config_.GetName().c_str());
     if (config_.IsReadOnly()) {
         return E_NOT_SUPPORT;
     }
 
-    if (!isOpen_) {
-        LOG_ERROR("The connection pool has been closed.");
-        return E_ERROR;
-    }
-    if (connectionPool_ == nullptr) {
-        LOG_ERROR("The connectionPool_ is null.");
+    if (!isOpen_ || connectionPool_ == nullptr) {
+        LOG_ERROR("The connection pool is created: %{public}d, pool is null: %{public}d", isOpen_,
+            connectionPool_ == nullptr);
         return E_ERROR;
     }
 
-    std::string backupFilePath;
-    int ret = GetDataBasePath(backupPath, backupFilePath);
-    if (ret != E_OK) {
-        return ret;
-    }
-
-    if (access(backupFilePath.c_str(), F_OK) != E_OK) {
-        LOG_ERROR("The backupFilePath does not exists.");
-        return E_INVALID_FILE_PATH;
+    std::string destPath;
+    if (!TryGetMasterSlaveBackupPath(backupPath, destPath, true)) {
+        int ret = GetDestPath(backupPath, destPath);
+        if (ret != E_OK) {
+            return ret;
+        }
     }
-
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
     auto [err, service] = RdbMgr::GetInstance().GetRdbService(syncerParam_);
     if (service != nullptr) {
         service->Disable(syncerParam_);
     }
 #endif
-    int errCode = connectionPool_->ChangeDbFileForRestore(path_, backupFilePath, newKey);
+    int errCode = connectionPool_->ChangeDbFileForRestore(path_, destPath, newKey, slaveStatus_);
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+    NotifyDataChange();
     SecurityPolicy::SetSecurityLabel(config_);
     if (service != nullptr) {
         service->Enable(syncerParam_);
-        return errCode;
     }
 #endif
+    if (errCode == E_OK) {
+        ReportDbRestoreSuccessEvent();
+        rebuild_ = RebuiltType::NONE;
+    }
+    if (!cloudTables_.empty()) {
+        DoCloudSync("");
+    }
     return errCode;
 }
 
+void RdbStoreImpl::ReportDbRestoreSuccessEvent()
+{
+    RdbCorruptedEvent eventInfo;
+    eventInfo.bundleName = config_.GetBundleName();
+    eventInfo.moduleName = config_.GetModuleName();
+    eventInfo.storeType = "RDB";
+    eventInfo.storeName = config_.GetName();
+    eventInfo.securityLevel = static_cast<uint32_t>(config_.GetSecurityLevel());
+    eventInfo.pathArea = static_cast<uint32_t>(config_.GetArea());
+    eventInfo.encryptStatus = static_cast<uint32_t>(config_.IsEncrypt());
+    eventInfo.integrityCheck = static_cast<uint32_t>(config_.GetIntegrityCheck());
+    eventInfo.errorCode = 0; // Rdb Restore Success
+    eventInfo.systemErrorNo = 0;
+    eventInfo.errorOccurTime = time(nullptr);
+    std::string dbPath;
+    if (SqliteGlobalConfig::GetDbPath(config_, dbPath) == E_OK && access(dbPath.c_str(), F_OK) == 0) {
+        eventInfo.dbFileStatRet = stat(dbPath.c_str(), &eventInfo.dbFileStat);
+        std::string walPath = dbPath + "-wal";
+        eventInfo.walFileStatRet = stat(walPath.c_str(), &eventInfo.walFileStat);
+    } else {
+        eventInfo.dbFileStatRet = -1;
+        eventInfo.walFileStatRet = -1;
+    }
+    RdbFaultHiViewReporter::ReportRdbCorruptedFault(eventInfo);
+}
 /**
  * Queries data in the database based on specified conditions.
  */
@@ -1744,6 +1864,15 @@ int RdbStoreImpl::SetDistributedTables(const std::vector<std::string> &tables, i
         LOG_ERROR("Fail to set distributed tables, error=%{public}d", errorCode);
         return errorCode;
     }
+    if (type == DistributedRdb::DISTRIBUTED_CLOUD) {
+        auto conn = connectionPool_->AcquireConnection(false);
+        if (conn != nullptr) {
+            auto strategy = conn->GenerateExchangeStrategy(slaveStatus_);
+            if (strategy == ExchangeStrategy::BACKUP) {
+                (void)conn->Backup({}, {}, false, slaveStatus_);
+            }
+        }
+    }
     if (type != DistributedRdb::DISTRIBUTED_CLOUD || !distributedConfig.autoSync) {
         return E_OK;
     }
@@ -1751,6 +1880,11 @@ int RdbStoreImpl::SetDistributedTables(const std::vector<std::string> &tables, i
         std::unique_lock<decltype(rwMutex_)> lock(rwMutex_);
         cloudTables_.insert(tables.begin(), tables.end());
     }
+    auto isRebuilt = RebuiltType::NONE;
+    GetRebuilt(isRebuilt);
+    if (isRebuilt == RebuiltType::REBUILT) {
+        DoCloudSync("");
+    }
     return E_OK;
 }
 
@@ -1765,7 +1899,7 @@ std::string RdbStoreImpl::ObtainDistributedTableName(const std::string &device,
         DeviceManagerAdaptor::RdbDeviceManagerAdaptor::GetInstance(syncerParam_.bundleName_);
     errCode = deviceManager.GetEncryptedUuidByNetworkId(device, uuid);
     if (errCode != E_OK) {
-        LOG_ERROR("GetUuid is failed");
+        LOG_ERROR("GetUuid is failed.");
         return "";
     }
 
@@ -1847,7 +1981,7 @@ int RdbStoreImpl::SubscribeLocal(const SubscribeOption& option, RdbStoreObserver
     auto &list = localObservers_.find(option.event)->second;
     for (auto it = list.begin(); it != list.end(); it++) {
         if ((*it)->getObserver() == observer) {
-            LOG_ERROR("duplicate subscribe");
+            LOG_ERROR("duplicate subscribe.");
             return E_OK;
         }
     }
@@ -1863,7 +1997,7 @@ int RdbStoreImpl::SubscribeLocalShared(const SubscribeOption& option, RdbStoreOb
     auto &list = localSharedObservers_.find(option.event)->second;
     for (auto it = list.begin(); it != list.end(); it++) {
         if ((*it)->getObserver() == observer) {
-            LOG_ERROR("duplicate subscribe");
+            LOG_ERROR("duplicate subscribe.");
             return E_OK;
         }
     }
@@ -2099,6 +2233,16 @@ int RdbStoreImpl::Notify(const std::string &event)
     return E_OK;
 }
 
+int RdbStoreImpl::SetSearchable(bool isSearchable)
+{
+    auto [errCode, service] = DistributedRdb::RdbManagerImpl::GetInstance().GetRdbService(syncerParam_);
+    if (errCode != E_OK || service == nullptr) {
+        LOG_ERROR("GetRdbService is failed, err is %{public}d.", errCode);
+        return errCode;
+    }
+    return service->SetSearchable(syncerParam_, isSearchable);
+}
+
 int RdbStoreImpl::RegisterAutoSyncCallback(std::shared_ptr<DetailProgressObserver> observer)
 {
     if (config_.GetDBType() == DB_VECTOR) {
@@ -2129,11 +2273,12 @@ void RdbStoreImpl::InitDelayNotifier()
         delayNotifier_ = std::make_shared<DelayNotify>();
     }
     if (delayNotifier_ == nullptr) {
-        LOG_ERROR("Init delay notifier failed");
+        LOG_ERROR("Init delay notifier failed.");
         return;
     }
     delayNotifier_->SetExecutorPool(pool_);
-    delayNotifier_->SetTask([param = syncerParam_](const DistributedRdb::RdbChangedData& rdbChangedData) -> int {
+    delayNotifier_->SetTask([param = syncerParam_]
+        (const DistributedRdb::RdbChangedData& rdbChangedData, const RdbNotifyConfig& rdbNotifyConfig) -> int {
         auto [errCode, service] = DistributedRdb::RdbManagerImpl::GetInstance().GetRdbService(param);
         if (errCode == E_NOT_SUPPORT) {
             return errCode;
@@ -2142,7 +2287,7 @@ void RdbStoreImpl::InitDelayNotifier()
             LOG_ERROR("GetRdbService is failed, err is %{public}d.", errCode);
             return errCode;
         }
-        return service->NotifyDataChange(param, rdbChangedData);
+        return service->NotifyDataChange(param, rdbChangedData, rdbNotifyConfig);
     });
 }
 
@@ -2245,6 +2390,48 @@ int RdbStoreImpl::ModifyLockStatus(const AbsRdbPredicates &predicates, bool isLo
     }
     return errCode;
 }
+
+std::pair<int32_t, uint32_t> RdbStoreImpl::LockCloudContainer()
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
+    RdbRadar ret(Scene::SCENE_SYNC, __FUNCTION__, config_.GetBundleName());
+    auto [errCode, service] = DistributedRdb::RdbManagerImpl::GetInstance().GetRdbService(syncerParam_);
+    if (errCode == E_NOT_SUPPORT) {
+        LOG_ERROR("not support");
+        return { errCode, 0 };
+    }
+    if (errCode != E_OK) {
+        LOG_ERROR("GetRdbService is failed, err is %{public}d, bundleName is %{public}s.", errCode,
+            syncerParam_.bundleName_.c_str());
+        return { errCode, 0 };
+    }
+    auto result = service->LockCloudContainer(syncerParam_);
+    if (result.first != E_OK) {
+        LOG_ERROR("LockCloudContainer failed, err is %{public}d.", result.first);
+    }
+    return result;
+}
+
+int32_t RdbStoreImpl::UnlockCloudContainer()
+{
+    DISTRIBUTED_DATA_HITRACE(std::string(__FUNCTION__));
+    RdbRadar ret(Scene::SCENE_SYNC, __FUNCTION__, config_.GetBundleName());
+    auto [errCode, service] = DistributedRdb::RdbManagerImpl::GetInstance().GetRdbService(syncerParam_);
+    if (errCode == E_NOT_SUPPORT) {
+        LOG_ERROR("not support");
+        return errCode;
+    }
+    if (errCode != E_OK) {
+        LOG_ERROR("GetRdbService is failed, err is %{public}d, bundleName is %{public}s.", errCode,
+                  syncerParam_.bundleName_.c_str());
+        return errCode;
+    }
+    errCode = service->UnlockCloudContainer(syncerParam_);
+    if (errCode != E_OK) {
+        LOG_ERROR("UnlockCloudContainer failed, err is %{public}d.", errCode);
+    }
+    return errCode;
+}
 #endif
 
 std::pair<int32_t, std::shared_ptr<Statement>> RdbStoreImpl::GetStatement(
@@ -2270,4 +2457,69 @@ int RdbStoreImpl::GetRebuilt(RebuiltType &rebuilt)
     rebuilt = static_cast<RebuiltType>(rebuild_);
     return E_OK;
 }
+
+int RdbStoreImpl::InterruptBackup()
+{
+    if (config_.GetHaMode() != HAMode::MANUAL_TRIGGER) {
+        return E_NOT_SUPPORT;
+    }
+    if (slaveStatus_ == SlaveStatus::BACKING_UP) {
+        slaveStatus_ = SlaveStatus::BACKUP_INTERRUPT;
+        return E_OK;
+    }
+    return E_INVALID_INTERRUPT;
+}
+
+int32_t RdbStoreImpl::GetBackupStatus() const
+{
+    if (config_.GetHaMode() != HAMode::MANUAL_TRIGGER && config_.GetHaMode() != HAMode::MAIN_REPLICA) {
+        return SlaveStatus::UNDEFINED;
+    }
+    return slaveStatus_;
+}
+
+bool RdbStoreImpl::TryGetMasterSlaveBackupPath(const std::string &srcPath, std::string &destPath, bool isRestore)
+{
+    if (!srcPath.empty() || config_.GetHaMode() == HAMode::SINGLE || config_.GetDBType() != DB_SQLITE) {
+        return false;
+    }
+    int ret = GetSlaveName(config_.GetPath(), destPath);
+    if (ret != E_OK) {
+        destPath = {};
+        return false;
+    }
+    if (isRestore && access(destPath.c_str(), F_OK) != 0) {
+        LOG_WARN("The backup path can not access: %{public}s", SqliteUtils::Anonymous(destPath).c_str());
+        return false;
+    }
+    return true;
+}
+
+bool RdbStoreImpl::IsSlaveDiffFromMaster() const
+{
+    std::string failureFlagFile = config_.GetPath() + "-slaveFailure";
+    return access(failureFlagFile.c_str(), F_OK) == 0;
+}
+
+int32_t RdbStoreImpl::ExchangeSlaverToMaster()
+{
+    if (config_.GetRoleType() == VISITOR || config_.IsReadOnly()) {
+        return E_OK;
+    }
+    auto conn = connectionPool_->AcquireConnection(false);
+    if (conn == nullptr) {
+        return E_DATABASE_BUSY;
+    }
+    auto strategy = conn->GenerateExchangeStrategy(slaveStatus_);
+    if (strategy != ExchangeStrategy::NOT_HANDLE) {
+        LOG_WARN("exchange st:%{public}d, %{public}s,", strategy, config_.GetName().c_str());
+    }
+    int ret = E_OK;
+    if (strategy == ExchangeStrategy::RESTORE) {
+        ret = conn->Restore({}, {}, slaveStatus_);
+    } else if (strategy == ExchangeStrategy::BACKUP) {
+        ret = conn->Backup({}, {}, true, slaveStatus_);
+    }
+    return ret;
+}
 } // namespace OHOS::NativeRdb
\ No newline at end of file
diff --git a/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp b/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp
index 4b964a6232ae36e76bd6f537de68978fd6fb0de1..c8c65e176d0852870f3a506786e9ba58c2eab4a3 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_store_manager.cpp
@@ -58,7 +58,7 @@ std::shared_ptr<RdbStore> RdbStoreManager::GetRdbStore(const RdbStoreConfig &con
     int &errCode, int version, RdbOpenCallback &openCallback)
 {
     if (config.IsVector() && config.GetStorageMode() == StorageMode::MODE_MEMORY) {
-        LOG_ERROR("GetRdbStore type not support memory mode");
+        LOG_ERROR("GetRdbStore type not support memory mode.");
         return nullptr;
     }
     // TOD this lock should only work on storeCache_, add one more lock for connectionpool
@@ -100,6 +100,11 @@ std::shared_ptr<RdbStore> RdbStoreManager::GetRdbStore(const RdbStoreConfig &con
     }
 
     storeCache_[path] = rdbStore;
+    errCode = rdbStore->ExchangeSlaverToMaster();
+    if (errCode != E_OK) {
+        LOG_ERROR("fail, name:%{public}s err:%{public}d", config.GetName().c_str(), errCode);
+        return nullptr;
+    }
     return rdbStore;
 }
 
@@ -145,6 +150,7 @@ DistributedRdb::RdbSyncerParam RdbStoreManager::GetSyncParam(const RdbStoreConfi
     syncerParam.isAutoClean_ = config.GetAutoClean();
     syncerParam.isSearchable_ = config.IsSearchable();
     syncerParam.roleType_ = config.GetRoleType();
+    syncerParam.haMode_ = config.GetHaMode();
     return syncerParam;
 }
 
diff --git a/relational_store/frameworks/native/rdb/src/rdb_types_util.cpp b/relational_store/frameworks/native/rdb/src/rdb_types_util.cpp
index af6e5de1d20159ad39d6d2390ce8c721c711be06..45c7169c25144143a94e295680d6496ef5b61b5c 100644
--- a/relational_store/frameworks/native/rdb/src/rdb_types_util.cpp
+++ b/relational_store/frameworks/native/rdb/src/rdb_types_util.cpp
@@ -20,14 +20,25 @@ bool Marshalling(const SyncerParam &input, MessageParcel &data)
 {
     return ITypesUtil::Marshal(data, input.bundleName_, input.hapName_, input.storeName_, input.area_,
         input.level_, input.type_, input.isEncrypt_, input.password_, input.customDir_, input.isAutoClean_,
-        input.isSearchable_);
+        input.isSearchable_, input.haMode_);
 }
 template<>
 bool Unmarshalling(SyncerParam &output, MessageParcel &data)
 {
     return ITypesUtil::Unmarshal(data, output.bundleName_, output.hapName_, output.storeName_, output.area_,
         output.level_, output.type_, output.isEncrypt_, output.password_, output.customDir_, output.isAutoClean_,
-        output.isSearchable_);
+        output.isSearchable_, output.haMode_);
+}
+
+template<>
+bool Marshalling(const NotifyConfig &input, MessageParcel &data)
+{
+    return ITypesUtil::Marshal(data, input.delay_, input.isFull_);
+}
+template<>
+bool Unmarshalling(NotifyConfig &output, MessageParcel &data)
+{
+    return ITypesUtil::Unmarshal(data, output.delay_, output.isFull_);
 }
 
 template<>
diff --git a/relational_store/frameworks/native/rdb/src/security_policy.cpp b/relational_store/frameworks/native/rdb/src/security_policy.cpp
index 7266603a81948fa401aa8a103e548377a15811ff..783494e7bb73c57fbadf59dd0d80909cf6849677 100644
--- a/relational_store/frameworks/native/rdb/src/security_policy.cpp
+++ b/relational_store/frameworks/native/rdb/src/security_policy.cpp
@@ -46,18 +46,13 @@ std::string SecurityPolicy::GetFileSecurityLevel(const std::string &filePath)
 int SecurityPolicy::SetSecurityLabel(const RdbStoreConfig &config)
 {
     if (config.GetStorageMode() != StorageMode::MODE_MEMORY && config.GetSecurityLevel() != SecurityLevel::LAST) {
-        std::string currentLevel = GetFileSecurityLevel(config.GetPath());
-        std::string toSetLevel = GetSecurityLevelValue(config.GetSecurityLevel());
-        int errCode = E_OK;
-        if (currentLevel.empty()) {
-            errCode = FileManagement::ModuleSecurityLabel::SecurityLabel::SetSecurityLabel(config.GetPath(),
-                toSetLevel) ? E_OK : E_ERROR;
-        } else {
-            errCode = currentLevel == toSetLevel ? E_OK : E_CONFIG_INVALID_CHANGE;
-        }
+        auto toSetLevel = GetSecurityLevelValue(config.GetSecurityLevel());
+        auto errCode = FileManagement::ModuleSecurityLabel::SecurityLabel::SetSecurityLabel(config.GetPath(),
+            toSetLevel) ? E_OK : E_CONFIG_INVALID_CHANGE;
         if (errCode != E_OK) {
-            LOG_ERROR("Set security level from %{public}s to %{public}s, result:%{public}d.", currentLevel.c_str(),
-                toSetLevel.c_str(), errCode);
+            auto currentLevel = GetFileSecurityLevel(config.GetPath());
+            LOG_ERROR("Set security level from %{public}s to %{public}s, result:%{public}d, errno:%{public}d.",
+                currentLevel.c_str(), toSetLevel.c_str(), errCode, errno);
         }
         return errCode;
     }
diff --git a/relational_store/frameworks/native/rdb/src/share_block.cpp b/relational_store/frameworks/native/rdb/src/share_block.cpp
index 3b81f8a245230d243025960a58d205a316a7478c..6a6a53b74aa9d1de74f93bbadaa98e5e7b13eff4 100644
--- a/relational_store/frameworks/native/rdb/src/share_block.cpp
+++ b/relational_store/frameworks/native/rdb/src/share_block.cpp
@@ -161,12 +161,12 @@ int FillSharedBlock(SharedBlockInfo *info, sqlite3_stmt *stmt)
             isFull = info->isFull;
             hasException = info->hasException;
         } else if (err == SQLITE_DONE) {
-            LOG_WARN("Processed all rows");
+            LOG_WARN("Processed all rows.");
             break;
         } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
             LOG_WARN("Database locked, retrying");
             if (retryCount > RETRY_TIME) {
-                LOG_ERROR("Bailing on database busy retry");
+                LOG_ERROR("Bailing on database busy retry.");
                 hasException = true;
                 return E_DATABASE_BUSY;
             } else {
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp b/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp
index 0e73fd961d0e58e197d6d7dddab87707f871cf78..737f529acbbfa03fc83e3e12b1f44d5418ce6230 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_connection.cpp
@@ -34,58 +34,129 @@
 
 #include "logger.h"
 #include "raw_data_parser.h"
-#include "rdb_store_config.h"
 #include "rdb_errno.h"
+#include "rdb_security_manager.h"
 #include "rdb_sql_statistic.h"
+#include "rdb_store_config.h"
 #include "relational_store_client.h"
 #include "sqlite_errno.h"
 #include "sqlite_global_config.h"
 #include "sqlite_utils.h"
+#include "rdb_fault_hiview_reporter.h"
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-#include "rdb_security_manager.h"
 #include "relational/relational_store_sqlite_ext.h"
+#include "rdb_manager_impl.h"
 #endif
+#include "task_executor.h"
 
 namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
 using namespace std::chrono;
-
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
 using RdbKeyFile = RdbSecurityManager::KeyFileType;
-#endif
 
+constexpr const char *INTEGRITIES[] = {nullptr, "PRAGMA quick_check", "PRAGMA integrity_check"};
+__attribute__((used))
+const int32_t SqliteConnection::regCreator_ = Connection::RegisterCreator(DB_SQLITE, SqliteConnection::Create);
 __attribute__((used))
-const int32_t SqliteConnection::regCreater_ = Connection::RegisterCreator(DB_SQLITE, SqliteConnection::Create);
-const int32_t SqliteConnection::regFileDeleter_ =
-    Connection::RegisterFileDeleter(DB_SQLITE, SqliteConnection::DeleteDbFile);
+const int32_t SqliteConnection::regRepairer_ = Connection::RegisterRepairer(DB_SQLITE, SqliteConnection::Repair);
+__attribute__((used))
+const int32_t SqliteConnection::regDeleter_ = Connection::RegisterDeleter(DB_SQLITE, SqliteConnection::Delete);
 
 std::pair<int32_t, std::shared_ptr<Connection>> SqliteConnection::Create(const RdbStoreConfig &config, bool isWrite)
 {
-    std::pair<int32_t, std::shared_ptr<Connection>> result;
+    std::pair<int32_t, std::shared_ptr<Connection>> result = { E_ERROR, nullptr };
     auto &[errCode, conn] = result;
-    for (size_t i = 0; i < ITERS_COUNT; i++) {
-        std::shared_ptr<SqliteConnection> connection(new (std::nothrow) SqliteConnection(isWrite));
-        if (connection == nullptr) {
-            LOG_ERROR("SqliteConnection::Open new failed, connection is nullptr");
-            break;
-        }
-        errCode = connection->InnerOpen(config, i);
-        if (errCode == E_OK) {
-            conn = connection;
-            break;
+    std::tie(errCode, conn) = InnerCreate(config, isWrite);
+    return result;
+}
+
+int32_t SqliteConnection::Delete(const RdbStoreConfig &config)
+{
+    auto path = config.GetPath();
+    SqliteUtils::DeleteFile(path);
+    SqliteUtils::DeleteFile(path + "-shm");
+    SqliteUtils::DeleteFile(path + "-wal");
+    SqliteUtils::DeleteFile(path + "-journal");
+    SqliteUtils::DeleteFile(path + "-slaveFailure");
+    SqliteUtils::DeleteFile(path + "-syncInterrupt");
+    return E_OK;
+}
+
+SqliteConnection::SqliteConnection(const RdbStoreConfig &config, bool isWriteConnection)
+    : dbHandle_(nullptr), isWriter_(isWriteConnection), isReadOnly_(false), maxVariableNumber_(0), filePath(""),
+      config_(config)
+{
+}
+
+int SqliteConnection::CreateSlaveConnection(const RdbStoreConfig &config, bool isWrite, bool checkSlaveExist)
+{
+    if (config.GetHaMode() != HAMode::MAIN_REPLICA && config.GetHaMode() != HAMode::MANUAL_TRIGGER) {
+        return E_OK;
+    }
+    bool isSlaveExist = access(config.GetPath().c_str(), F_OK) == 0;
+    bool isSlaveLockExist = SqliteUtils::TryAccessSlaveLock(config_.GetPath(), false, false);
+    if (config.GetHaMode() == HAMode::MANUAL_TRIGGER && (checkSlaveExist && (!isSlaveExist || isSlaveLockExist))) {
+        LOG_INFO("not dual write on manual, slave:%{public}d, lock:%{public}d",
+            isSlaveExist, isSlaveLockExist);
+        return E_OK;
+    }
+
+    slaveConnection_ = std::make_shared<SqliteConnection>(config, isWrite);
+    int errCode = slaveConnection_->InnerOpen(config);
+    if (errCode != E_OK) {
+        SqliteUtils::TryAccessSlaveLock(config_.GetPath(), false, true, true);
+        if (errCode == E_SQLITE_CORRUPT) {
+            LOG_WARN("slave corrupt, rebuild:%{public}s", SqliteUtils::Anonymous(config.GetPath()).c_str());
+            (void)Delete(config);
+            errCode = slaveConnection_->InnerOpen(config);
+            if (errCode != E_OK) {
+                LOG_ERROR("reopen slave failed:%{public}d", errCode);
+                return errCode;
+            }
+        } else {
+            LOG_WARN("open slave failed:%{public}d, %{public}s", errCode,
+                SqliteUtils::Anonymous(config.GetPath()).c_str());
         }
     }
-    return result;
+    return errCode;
 }
 
-SqliteConnection::SqliteConnection(bool isWriteConnection)
-    : dbHandle(nullptr), isWriter_(isWriteConnection), isReadOnly(false), openFlags(0), maxVariableNumber_(0),
-      filePath("")
+RdbStoreConfig SqliteConnection::GetSlaveRdbStoreConfig(const RdbStoreConfig rdbConfig)
 {
+    RdbStoreConfig rdbStoreConfig(SqliteUtils::GetSlavePath(rdbConfig.GetPath()));
+    rdbStoreConfig.SetEncryptStatus(rdbConfig.IsEncrypt());
+    rdbStoreConfig.SetSearchable(rdbConfig.IsSearchable());
+    rdbStoreConfig.SetIsVector(rdbConfig.IsVector());
+    rdbStoreConfig.SetAutoClean(rdbConfig.GetAutoClean());
+    rdbStoreConfig.SetSecurityLevel(rdbConfig.GetSecurityLevel());
+    rdbStoreConfig.SetDataGroupId(rdbConfig.GetDataGroupId());
+    rdbStoreConfig.SetName(SqliteUtils::GetSlavePath(rdbConfig.GetName()));
+    rdbStoreConfig.SetCustomDir(rdbConfig.GetCustomDir());
+    rdbStoreConfig.SetAllowRebuild(rdbConfig.GetAllowRebuild());
+    rdbStoreConfig.SetReadOnly(rdbConfig.IsReadOnly());
+    rdbStoreConfig.SetAutoCheck(rdbConfig.IsAutoCheck());
+    rdbStoreConfig.SetCreateNecessary(rdbConfig.IsCreateNecessary());
+    rdbStoreConfig.SetIter(rdbConfig.GetIter());
+    rdbStoreConfig.SetJournalSize(rdbConfig.GetJournalSize());
+    rdbStoreConfig.SetPageSize(rdbConfig.GetPageSize());
+    rdbStoreConfig.SetReadConSize(rdbConfig.GetReadConSize());
+    rdbStoreConfig.SetReadTime(rdbConfig.GetReadTime());
+    rdbStoreConfig.SetDBType(rdbConfig.GetDBType());
+    rdbStoreConfig.SetVisitorDir(rdbConfig.GetVisitorDir());
+    rdbStoreConfig.SetEncryptKey(rdbConfig.GetEncryptKey());
+    rdbStoreConfig.SetNewEncryptKey(rdbConfig.GetNewEncryptKey());
+    rdbStoreConfig.SetScalarFunctions(rdbConfig.GetScalarFunctions());
+    rdbStoreConfig.SetJournalMode(rdbConfig.GetJournalMode());
+
+    rdbStoreConfig.SetModuleName(rdbConfig.GetModuleName());
+    rdbStoreConfig.SetArea(rdbConfig.GetArea());
+    rdbStoreConfig.SetPluginLibs(rdbConfig.GetPluginLibs());
+    rdbStoreConfig.SetHaMode(rdbConfig.GetHaMode());
+    return rdbStoreConfig;
 }
 
-int SqliteConnection::InnerOpen(const RdbStoreConfig &config, uint32_t retry)
+int SqliteConnection::InnerOpen(const RdbStoreConfig &config)
 {
     std::string dbPath;
     auto errCode = SqliteGlobalConfig::GetDbPath(config, dbPath);
@@ -100,16 +171,16 @@ int SqliteConnection::InnerOpen(const RdbStoreConfig &config, uint32_t retry)
         return E_DB_NOT_EXIST;
     }
 #endif
-    isReadOnly = !isWriter_ || config.IsReadOnly();
+    isReadOnly_ = !isWriter_ || config.IsReadOnly();
     int openFileFlags = config.IsReadOnly() ? (SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX)
-                                            : (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX);
+                                    : (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX);
     errCode = OpenDatabase(dbPath, openFileFlags);
     if (errCode != E_OK) {
         return errCode;
     }
 
-    maxVariableNumber_ = sqlite3_limit(dbHandle, SQLITE_LIMIT_VARIABLE_NUMBER, -1);
-    errCode = Configure(config, retry, dbPath);
+    maxVariableNumber_ = sqlite3_limit(dbHandle_, SQLITE_LIMIT_VARIABLE_NUMBER, -1);
+    errCode = Configure(config, dbPath);
     isConfigured_ = true;
     if (errCode != E_OK) {
         return errCode;
@@ -117,22 +188,59 @@ int SqliteConnection::InnerOpen(const RdbStoreConfig &config, uint32_t retry)
 
     if (isWriter_) {
         TryCheckPoint();
-        auto [ret, object] = ExecuteForValue("PRAGMA integrity_check");
-        if (ret == E_OK && static_cast<std::string>(object) != "ok") {
-            LOG_ERROR("integrity check result is %{public}s", static_cast<std::string>(object).c_str());
-            return E_SQLITE_CORRUPT;
+        ValueObject checkResult{"ok"};
+        auto index = static_cast<uint32_t>(config.GetIntegrityCheck());
+        if (index < static_cast<uint32_t>(sizeof(INTEGRITIES) / sizeof(INTEGRITIES[0]))) {
+            auto sql = INTEGRITIES[index];
+            if (sql != nullptr) {
+                LOG_INFO("%{public}s : %{public}s, ", sql, config.GetName().c_str());
+                std::tie(errCode, checkResult) = ExecuteForValue(sql);
+            }
+            if (errCode == E_OK && static_cast<std::string>(checkResult) != "ok") {
+                LOG_ERROR("%{public}s integrity check result is %{public}s, sql:%{public}s", config.GetName().c_str(),
+                    static_cast<std::string>(checkResult).c_str(), sql);
+                ReportDbCorruptedEvent(errCode, static_cast<std::string>(checkResult));
+            } else {
+                LOG_DEBUG("%{public}s integrity check err:%{public}d, result is %{public}s, sql:%{public}s",
+                    config.GetName().c_str(), errCode, static_cast<std::string>(checkResult).c_str(), sql);
+            }
         }
     }
 
     filePath = dbPath;
-    openFlags = openFileFlags;
-
     return E_OK;
 }
 
+void SqliteConnection::ReportDbCorruptedEvent(int errorCode, const std::string &checkResultInfo)
+{
+    RdbCorruptedEvent eventInfo;
+    eventInfo.bundleName = config_.GetBundleName();
+    eventInfo.moduleName = config_.GetModuleName();
+    eventInfo.storeType = "RDB";
+    eventInfo.storeName = config_.GetName();
+    eventInfo.securityLevel = static_cast<uint32_t>(config_.GetSecurityLevel());
+    eventInfo.pathArea = static_cast<uint32_t>(config_.GetArea());
+    eventInfo.encryptStatus = static_cast<uint32_t>(config_.IsEncrypt());
+    eventInfo.integrityCheck = static_cast<uint32_t>(config_.GetIntegrityCheck());
+    eventInfo.errorCode = static_cast<uint32_t>(errorCode);
+    eventInfo.systemErrorNo = errno;
+    eventInfo.appendix = checkResultInfo;
+    eventInfo.errorOccurTime = time(nullptr);
+    std::string dbPath;
+    if (SqliteGlobalConfig::GetDbPath(config_, dbPath) == E_OK && access(dbPath.c_str(), F_OK) == 0) {
+        eventInfo.dbFileStatRet = stat(dbPath.c_str(), &eventInfo.dbFileStat);
+        std::string walPath = dbPath + "-wal";
+        eventInfo.walFileStatRet = stat(walPath.c_str(), &eventInfo.walFileStat);
+    } else {
+        eventInfo.dbFileStatRet = -1;
+        eventInfo.walFileStatRet = -1;
+    }
+    RdbFaultHiViewReporter::ReportRdbCorruptedFault(eventInfo);
+}
+
 int32_t SqliteConnection::OpenDatabase(const std::string &dbPath, int openFileFlags)
 {
-    int errCode = sqlite3_open_v2(dbPath.c_str(), &dbHandle, openFileFlags, nullptr);
+    int errCode = sqlite3_open_v2(dbPath.c_str(), &dbHandle_, openFileFlags, nullptr);
     if (errCode != SQLITE_OK) {
         LOG_ERROR("fail to open database errCode=%{public}d, dbPath=%{public}s, flags=%{public}d, errno=%{public}d",
             errCode, dbPath.c_str(), openFileFlags, errno);
@@ -145,36 +253,12 @@ int32_t SqliteConnection::OpenDatabase(const std::string &dbPath, int openFileFl
                 return E_INVALID_FILE_PATH;
             }
         }
-        if (errCode == SQLITE_NOTADB) {
-            ReadFile2Buffer(dbPath.c_str());
-        }
 #endif
         return SQLiteError::ErrNo(errCode);
     }
     return E_OK;
 }
 
-void SqliteConnection::ReadFile2Buffer(const char* fileName)
-{
-    uint64_t buffer[BUFFER_LEN] = {0x0};
-    FILE *file = fopen(fileName, "r");
-    if (file == nullptr) {
-        LOG_ERROR("open db file failed: %{public}s, errno is %{public}d", fileName, errno);
-        return;
-    }
-    size_t readSize = fread(buffer, sizeof(uint64_t), BUFFER_LEN, file);
-    if (readSize != BUFFER_LEN) {
-        LOG_ERROR("read db file size: %{public}zu, errno is %{public}d", readSize, errno);
-        (void)fclose(file);
-        return;
-    }
-    for (uint32_t i = 0; i < BUFFER_LEN; i += 4) {
-        LOG_WARN("line%{public}d: %{public}" PRIx64 "%{public}" PRIx64 "%{public}" PRIx64 "%{public}" PRIx64,
-            i >> 2, buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]);
-    }
-    (void)fclose(file);
-}
-
 int SqliteConnection::SetCustomFunctions(const RdbStoreConfig &config)
 {
     customScalarFunctions_ = config.GetScalarFunctions();
@@ -190,12 +274,12 @@ int SqliteConnection::SetCustomFunctions(const RdbStoreConfig &config)
 static void CustomScalarFunctionCallback(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
     if (ctx == nullptr || argv == nullptr) {
-        LOG_ERROR("ctx or argv is nullptr");
+        LOG_ERROR("ctx or argv is nullptr.");
         return;
     }
     auto function = static_cast<ScalarFunction *>(sqlite3_user_data(ctx));
     if (function == nullptr) {
-        LOG_ERROR("function is nullptr");
+        LOG_ERROR("function is nullptr.");
         return;
     }
 
@@ -220,7 +304,7 @@ static void CustomScalarFunctionCallback(sqlite3_context *ctx, int argc, sqlite3
 
 int SqliteConnection::SetCustomScalarFunction(const std::string &functionName, int argc, ScalarFunction *function)
 {
-    int err = sqlite3_create_function_v2(dbHandle, functionName.c_str(), argc, SQLITE_UTF8, function,
+    int err = sqlite3_create_function_v2(dbHandle_, functionName.c_str(), argc, SQLITE_UTF8, function,
         &CustomScalarFunctionCallback, nullptr, nullptr, nullptr);
     if (err != SQLITE_OK) {
         LOG_ERROR("SetCustomScalarFunction errCode is %{public}d, errno is %{public}d.", err, errno);
@@ -228,12 +312,8 @@ int SqliteConnection::SetCustomScalarFunction(const std::string &functionName, i
     return err;
 }
 
-int SqliteConnection::Configure(const RdbStoreConfig &config, uint32_t retry, std::string &dbPath)
+int SqliteConnection::Configure(const RdbStoreConfig &config, std::string &dbPath)
 {
-    if (retry >= ITERS_COUNT) {
-        return E_INVALID_ARGS;
-    }
-
     if (config.GetStorageMode() == StorageMode::MODE_MEMORY) {
         return E_OK;
     }
@@ -242,7 +322,7 @@ int SqliteConnection::Configure(const RdbStoreConfig &config, uint32_t retry, st
         return E_OK;
     }
 
-    auto errCode = RegDefaultFunctions(dbHandle);
+    auto errCode = RegDefaultFunctions(dbHandle_);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -261,7 +341,7 @@ int SqliteConnection::Configure(const RdbStoreConfig &config, uint32_t retry, st
         return errCode;
     }
 
-    errCode = SetEncryptKey(config, ITERS[retry]);
+    errCode = SetEncrypt(config);
     if (errCode != E_OK) {
         return errCode;
     }
@@ -285,24 +365,28 @@ int SqliteConnection::Configure(const RdbStoreConfig &config, uint32_t retry, st
     if (errCode != E_OK) {
         return errCode;
     }
-
-    return E_OK;
+    return LoadExtension(config, dbHandle_);
 }
 
 SqliteConnection::~SqliteConnection()
 {
-    if (dbHandle != nullptr) {
+    if (backupId_ != TaskExecutor::INVALID_TASK_ID) {
+        auto pool = TaskExecutor::GetInstance().GetExecutor();
+        if (pool != nullptr) {
+            pool->Remove(backupId_, true);
+        }
+    }
+    if (dbHandle_ != nullptr) {
         if (hasClientObserver_) {
-            UnRegisterClientObserver(dbHandle);
+            UnRegisterClientObserver(dbHandle_);
         }
         if (isWriter_) {
-            UnregisterStoreObserver(dbHandle);
+            UnregisterStoreObserver(dbHandle_);
         }
 
-        int errCode = sqlite3_close_v2(dbHandle);
+        int errCode = sqlite3_close_v2(dbHandle_);
         if (errCode != SQLITE_OK) {
-            LOG_ERROR("SqliteConnection ~SqliteConnection: could not close database "
-                "err = %{public}d, errno = %{public}d", errCode, errno);
+            LOG_ERROR("could not close database err = %{public}d, errno = %{public}d", errCode, errno);
         }
     }
 }
@@ -316,11 +400,23 @@ std::pair<int, std::shared_ptr<Statement>> SqliteConnection::CreateStatement(
     const std::string &sql, std::shared_ptr<Connection> conn)
 {
     std::shared_ptr<SqliteStatement> statement = std::make_shared<SqliteStatement>();
-    int errCode = statement->Prepare(dbHandle, sql);
+    statement->config_ = &config_;
+    int errCode = statement->Prepare(dbHandle_, sql);
     if (errCode != E_OK) {
         return { errCode, nullptr };
     }
     statement->conn_ = conn;
+    if (slaveConnection_ && IsWriter()) {
+        auto slaveStmt = std::make_shared<SqliteStatement>();
+        slaveStmt->config_ = &slaveConnection_->config_;
+        errCode = slaveStmt->Prepare(slaveConnection_->dbHandle_, sql);
+        if (errCode != E_OK) {
+            LOG_WARN("prepare slave stmt failed:%{public}d, sql:%{public}s", errCode, sql.c_str());
+            SqliteUtils::TryAccessSlaveLock(config_.GetPath(), false, true, true);
+            return { E_OK, statement };
+        }
+        statement->slave_ = slaveStmt;
+    }
     return { E_OK, statement };
 }
 
@@ -336,7 +432,7 @@ int SqliteConnection::SubscribeTableChanges(const Connection::Notifier &notifier
         return E_OK;
     }
     hasClientObserver_ = true;
-    int32_t status = RegisterClientObserver(dbHandle, [notifier](const ClientChangedData &clientData) {
+    int32_t status = RegisterClientObserver(dbHandle_, [notifier](const ClientChangedData &clientData) {
         std::set<std::string> tables;
         for (auto &[key, val] : clientData.tableData) {
             if (val.isTrackedDataChange) {
@@ -370,14 +466,14 @@ int32_t SqliteConnection::GetDBType() const
 
 int SqliteConnection::SetPageSize(const RdbStoreConfig &config)
 {
-    if (isReadOnly || config.GetPageSize() == GlobalExpr::DB_PAGE_SIZE) {
+    if (isReadOnly_ || config.GetPageSize() == GlobalExpr::DB_PAGE_SIZE) {
         return E_OK;
     }
 
     int targetValue = config.GetPageSize();
     auto [errCode, object] = ExecuteForValue("PRAGMA page_size");
     if (errCode != E_OK) {
-        LOG_ERROR("SqliteConnection SetPageSize fail to get page size : %{public}d", errCode);
+        LOG_ERROR("SetPageSize fail to get page size : %{public}d", errCode);
         return errCode;
     }
 
@@ -387,12 +483,12 @@ int SqliteConnection::SetPageSize(const RdbStoreConfig &config)
 
     errCode = ExecuteSql("PRAGMA page_size=" + std::to_string(targetValue));
     if (errCode != E_OK) {
-        LOG_ERROR("SqliteConnection SetPageSize fail to set page size : %{public}d", errCode);
+        LOG_ERROR("SetPageSize fail to set page size : %{public}d", errCode);
     }
     return errCode;
 }
 
-int SqliteConnection::ExecuteEncryptSql(const RdbStoreConfig &config, uint32_t iter)
+int SqliteConnection::SetEncryptAgo(int32_t iter)
 {
     int errCode = E_ERROR;
     if (iter != NO_ITER) {
@@ -419,93 +515,93 @@ int SqliteConnection::ExecuteEncryptSql(const RdbStoreConfig &config, uint32_t i
         LOG_ERROR("set rekey sha algo failed, err = %{public}d", errCode);
         return errCode;
     }
-
-    ValueObject version;
-    std::tie(errCode, version) = ExecuteForValue(GlobalExpr::PRAGMA_VERSION);
-    if (errCode != E_OK || version.GetType() == ValueObject::TYPE_NULL) {
-        LOG_ERROR("test failed, iter = %{public}d, err = %{public}d, name = %{public}s", iter, errCode,
-            config.GetName().c_str());
-        return errCode;
-    }
-
-    return errCode;
+    return E_OK;
 }
 
 int SqliteConnection::ReSetKey(const RdbStoreConfig &config)
 {
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+    if (!IsWriter()) {
+        return E_OK;
+    }
+    LOG_INFO("name = %{public}s, iter = %{public}d", config.GetName().c_str(), config.GetIter());
     std::vector<uint8_t> newKey = config.GetNewEncryptKey();
-    int errCode = sqlite3_rekey(dbHandle, static_cast<const void *>(newKey.data()), static_cast<int>(newKey.size()));
+    int errCode = sqlite3_rekey(dbHandle_, static_cast<const void *>(newKey.data()), static_cast<int>(newKey.size()));
     newKey.assign(newKey.size(), 0);
     if (errCode != SQLITE_OK) {
         LOG_ERROR("ReKey failed, err = %{public}d, errno = %{public}d", errCode, errno);
-        RdbSecurityManager::GetInstance().DelRdbSecretDataFile(config.GetPath(), RdbKeyFile::PUB_KEY_FILE_NEW_KEY);
+        RdbSecurityManager::GetInstance().DelKeyFile(config.GetPath(), RdbKeyFile::PUB_KEY_FILE_NEW_KEY);
         return E_OK;
     }
-
-    RdbSecurityManager::GetInstance().UpdateKeyFile(config.GetPath());
-#endif
+    config.ChangeEncryptKey();
     return E_OK;
 }
 
-std::string SqliteConnection::GetSecManagerName(const RdbStoreConfig &config)
+int SqliteConnection::SetEncrypt(const RdbStoreConfig &config)
 {
-    auto name = config.GetBundleName();
-    if (name.empty()) {
-        LOG_WARN("Bundle name is empty, using path instead.");
-        return std::string(config.GetPath()).substr(0, config.GetPath().rfind("/") + 1);
+    if (!config.IsEncrypt()) {
+        return E_OK;
+    }
+
+    std::vector<uint8_t> key = config.GetEncryptKey();
+    std::vector<uint8_t> newKey = config.GetNewEncryptKey();
+    auto errCode = SetEncryptKey(key, config.GetIter());
+    key.assign(key.size(), 0);
+    if (errCode != E_OK) {
+        if (!newKey.empty()) {
+            LOG_INFO("use new key, iter=%{public}d err=%{public}d errno=%{public}d name=%{public}s",
+                config.GetIter(), errCode, errno, config.GetName().c_str());
+            errCode = SetEncryptKey(newKey, config.GetIter());
+        }
+        newKey.assign(newKey.size(), 0);
+        if (errCode != E_OK) {
+            errCode = SetServiceKey(config, errCode);
+            LOG_ERROR("fail, iter=%{public}d err=%{public}d errno=%{public}d name=%{public}s", config.GetIter(),
+                errCode, errno, config.GetName().c_str());
+            return errCode;
+        }
+        config.ChangeEncryptKey();
+        newKey = {};
+    }
+
+    if (!newKey.empty()) {
+        ReSetKey(config);
     }
-    return name;
+    newKey.assign(newKey.size(), 0);
+    return E_OK;
 }
 
-int SqliteConnection::SetEncryptKey(const RdbStoreConfig &config, uint32_t iter)
+int SqliteConnection::SetEncryptKey(const std::vector<uint8_t> &key, int32_t iter)
 {
-#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
-    std::vector<uint8_t> key = config.GetEncryptKey();
-    if (key.size() == 0) {
-        return E_OK;
+    if (key.empty()) {
+        return E_INVALID_ARGS;
     }
 
-    auto errCode = sqlite3_key(dbHandle, static_cast<const void *>(key.data()), static_cast<int>(key.size()));
-    key.assign(key.size(), 0);
+    auto errCode = sqlite3_key(dbHandle_, static_cast<const void *>(key.data()), static_cast<int>(key.size()));
     if (errCode != SQLITE_OK) {
-        if (RdbSecurityManager::GetInstance().IsKeyFileExists(config.GetPath(), RdbKeyFile::PUB_KEY_FILE_NEW_KEY)) {
-            std::vector<uint8_t> newKey = config.GetNewEncryptKey();
-            errCode = sqlite3_key(dbHandle, static_cast<const void *>(newKey.data()), static_cast<int>(newKey.size()));
-            newKey.assign(newKey.size(), 0);
-            if (errCode != SQLITE_OK) {
-                LOG_ERROR("SqliteConnection SetEncryptKey fail with new key, err = %{public}d errno = %{public}d",
-                    errCode, errno);
-                return SQLiteError::ErrNo(errCode);
-            }
-            RdbSecurityManager::GetInstance().UpdateKeyFile(config.GetPath());
-        }
-        if (errCode != SQLITE_OK) {
-            LOG_ERROR("SqliteConnection SetEncryptKey fail, err = %{public}d, errno = %{public}d", errCode, errno);
-            return SQLiteError::ErrNo(errCode);
-        }
+        return SQLiteError::ErrNo(errCode);
     }
 
-    errCode = ExecuteEncryptSql(config, iter);
+    errCode = SetEncryptAgo(iter);
     if (errCode != E_OK) {
-        LOG_ERROR("execute encrypt sql failed, err = %{public}d", errCode);
         return errCode;
     }
 
-    if (RdbSecurityManager::GetInstance().IsKeyFileExists(config.GetPath(), RdbKeyFile::PUB_KEY_FILE_NEW_KEY)) {
-        ReSetKey(config);
+    if (IsWriter()) {
+        ValueObject version;
+        std::tie(errCode, version) = ExecuteForValue(GlobalExpr::PRAGMA_VERSION);
+        if (errCode != E_OK || version.GetType() == ValueObject::TYPE_NULL) {
+            return errCode;
+        }
     }
-
-#endif
-    return E_OK;
+    return errCode;
 }
 
 int SqliteConnection::SetPersistWal()
 {
     int opcode = 1;
-    int errCode = sqlite3_file_control(dbHandle, "main", SQLITE_FCNTL_PERSIST_WAL, &opcode);
+    int errCode = sqlite3_file_control(dbHandle_, "main", SQLITE_FCNTL_PERSIST_WAL, &opcode);
     if (errCode != SQLITE_OK) {
-        LOG_ERROR("failed");
+        LOG_ERROR("failed.");
         return E_SET_PERSIST_WAL;
     }
     return E_OK;
@@ -513,7 +609,7 @@ int SqliteConnection::SetPersistWal()
 
 int SqliteConnection::SetBusyTimeout(int timeout)
 {
-    auto errCode = sqlite3_busy_timeout(dbHandle, timeout);
+    auto errCode = sqlite3_busy_timeout(dbHandle_, timeout);
     if (errCode != SQLITE_OK) {
         LOG_ERROR("set buys timeout failed, errCode=%{public}d, errno=%{public}d", errCode, errno);
         return errCode;
@@ -527,13 +623,25 @@ int SqliteConnection::RegDefaultFunctions(sqlite3 *dbHandle)
         return SQLITE_OK;
     }
     // The number of parameters is 2
-    return sqlite3_create_function_v2(dbHandle, MERGE_ASSETS_FUNC, 2, SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr,
-        &MergeAssets, nullptr, nullptr, nullptr);
+    int errCode = sqlite3_create_function_v2(dbHandle, MERGE_ASSETS_FUNC, 2, SQLITE_UTF8 | SQLITE_DETERMINISTIC,
+        nullptr, &MergeAssets, nullptr, nullptr, nullptr);
+    if (errCode != SQLITE_OK) {
+        LOG_ERROR("register function mergeAssets failed, errCode=%{public}d, errno=%{public}d", errCode, errno);
+        return errCode;
+    }
+    // The number of parameters is 2
+    errCode = sqlite3_create_function_v2(dbHandle, MERGE_ASSET_FUNC, 2, SQLITE_UTF8 | SQLITE_DETERMINISTIC, nullptr,
+        &MergeAsset, nullptr, nullptr, nullptr);
+    if (errCode != SQLITE_OK) {
+        LOG_ERROR("register function mergeAsset failed, errCode=%{public}d, errno=%{public}d", errCode, errno);
+        return errCode;
+    }
+    return SQLITE_OK;
 }
 
 int SqliteConnection::SetJournalMode(const RdbStoreConfig &config)
 {
-    if (isReadOnly) {
+    if (isReadOnly_) {
         return E_OK;
     }
 
@@ -556,7 +664,7 @@ int SqliteConnection::SetJournalMode(const RdbStoreConfig &config)
         }
 
         if (SqliteUtils::StrToUpper(static_cast<std::string>(journalMode)) != config.GetJournalMode()) {
-            LOG_ERROR("SqliteConnection SetJournalMode: result incorrect");
+            LOG_ERROR("SqliteConnection SetJournalMode: result incorrect.");
             return E_EXECUTE_RESULT_INCORRECT;
         }
     }
@@ -572,7 +680,7 @@ int SqliteConnection::SetJournalMode(const RdbStoreConfig &config)
 
 int SqliteConnection::SetJournalSizeLimit(const RdbStoreConfig &config)
 {
-    if (isReadOnly || config.GetJournalSize() == GlobalExpr::DB_JOURNAL_SIZE) {
+    if (isReadOnly_ || config.GetJournalSize() == GlobalExpr::DB_JOURNAL_SIZE) {
         return E_OK;
     }
 
@@ -596,7 +704,7 @@ int SqliteConnection::SetJournalSizeLimit(const RdbStoreConfig &config)
 
 int SqliteConnection::SetAutoCheckpoint(const RdbStoreConfig &config)
 {
-    if (isReadOnly || config.IsAutoCheck() == GlobalExpr::DB_AUTO_CHECK) {
+    if (isReadOnly_ || config.IsAutoCheck() == GlobalExpr::DB_AUTO_CHECK) {
         return E_OK;
     }
 
@@ -671,8 +779,14 @@ std::pair<int32_t, ValueObject> SqliteConnection::ExecuteForValue(const std::str
 
 int SqliteConnection::ClearCache()
 {
-    if (dbHandle != nullptr && mode_ == JournalMode::MODE_WAL) {
-        sqlite3_db_release_memory(dbHandle);
+    if (dbHandle_ != nullptr && mode_ == JournalMode::MODE_WAL) {
+        sqlite3_db_release_memory(dbHandle_);
+    }
+    if (slaveConnection_) {
+        int errCode = slaveConnection_->ClearCache();
+        if (errCode != E_OK) {
+            LOG_ERROR("slaveConnection clearCache failed:%{public}d", errCode);
+        }
     }
     return E_OK;
 }
@@ -742,7 +856,7 @@ int SqliteConnection::ConfigLocale(const std::string &localeStr)
         return E_ERROR;
     }
 
-    int err = sqlite3_create_collation_v2(dbHandle, "LOCALES", SQLITE_UTF8, collator, Collate8Compare,
+    int err = sqlite3_create_collation_v2(dbHandle_, "LOCALES", SQLITE_UTF8, collator, Collate8Compare,
         (void (*)(void *))LocalizedCollatorDestroy);
     if (err != SQLITE_OK) {
         LOG_ERROR("SCreate collator in sqlite3 failed.");
@@ -755,10 +869,10 @@ int SqliteConnection::ConfigLocale(const std::string &localeStr)
 int SqliteConnection::CleanDirtyData(const std::string &table, uint64_t cursor)
 {
     if (table.empty()) {
-        return E_ERROR;
+        return E_INVALID_ARGS;
     }
     uint64_t tmpCursor = cursor == UINT64_MAX ? 0 : cursor;
-    auto status = DropLogicDeletedData(dbHandle, table, tmpCursor);
+    auto status = DropLogicDeletedData(dbHandle_, table, tmpCursor);
     return status == DistributedDB::DBStatus::OK ? E_OK : E_ERROR;
 }
 
@@ -768,16 +882,23 @@ int SqliteConnection::TryCheckPoint()
         return E_NOT_SUPPORT;
     }
 
-    std::string walName = sqlite3_filename_wal(sqlite3_db_filename(dbHandle, "main"));
+    std::string walName = sqlite3_filename_wal(sqlite3_db_filename(dbHandle_, "main"));
     int fileSize = SqliteUtils::GetFileSize(walName);
     if (fileSize <= GlobalExpr::DB_WAL_SIZE_LIMIT_MIN) {
         return E_OK;
     }
-    int errCode = sqlite3_wal_checkpoint_v2(dbHandle, nullptr, SQLITE_CHECKPOINT_TRUNCATE, nullptr, nullptr);
+    int errCode = sqlite3_wal_checkpoint_v2(dbHandle_, nullptr, SQLITE_CHECKPOINT_TRUNCATE, nullptr, nullptr);
     if (errCode != SQLITE_OK) {
         LOG_WARN("sqlite3_wal_checkpoint_v2 failed err %{public}d.", errCode);
         return E_ERROR;
     }
+
+    if (slaveConnection_) {
+        int errCode = slaveConnection_->TryCheckPoint();
+        if (errCode != E_OK) {
+            LOG_ERROR("slaveConnection tryCheckPoint failed:%{public}d", errCode);
+        }
+    }
     return E_OK;
 }
 
@@ -787,7 +908,7 @@ int SqliteConnection::LimitWalSize()
         return E_OK;
     }
 
-    std::string walName = sqlite3_filename_wal(sqlite3_db_filename(dbHandle, "main"));
+    std::string walName = sqlite3_filename_wal(sqlite3_db_filename(dbHandle_, "main"));
     int fileSize = SqliteUtils::GetFileSize(walName);
     if (fileSize > GlobalExpr::DB_WAL_SIZE_LIMIT_MAX) {
         LOG_ERROR("the WAL file size over default limit, %{public}s size is %{public}d",
@@ -821,22 +942,50 @@ void SqliteConnection::MergeAssets(sqlite3_context *ctx, int argc, sqlite3_value
     sqlite3_result_blob(ctx, blob.data(), blob.size(), SQLITE_TRANSIENT);
 }
 
+void SqliteConnection::MergeAsset(sqlite3_context *ctx, int argc, sqlite3_value **argv)
+{
+    // 2 is the number of parameters
+    if (ctx == nullptr || argc != 2 || argv == nullptr) {
+        LOG_ERROR("Parameter does not meet restrictions.");
+        return;
+    }
+    ValueObject::Asset asset;
+    size_t size = 0;
+    auto data = static_cast<const uint8_t *>(sqlite3_value_blob(argv[0]));
+    if (data != nullptr) {
+        int len = sqlite3_value_bytes(argv[0]);
+        size = RawDataParser::ParserRawData(data, len, asset);
+    }
+    ValueObject::Asset newAsset;
+    data = static_cast<const uint8_t *>(sqlite3_value_blob(argv[1]));
+    if (data != nullptr) {
+        int len = sqlite3_value_bytes(argv[1]);
+        RawDataParser::ParserRawData(data, len, newAsset);
+    }
+
+    if (size == 0) {
+        asset = std::move(newAsset);
+        if (asset.status != AssetValue::Status::STATUS_DELETE) {
+            asset.status = AssetValue::Status::STATUS_INSERT;
+        }
+    } else if (asset.name == newAsset.name) {
+        MergeAsset(asset, newAsset);
+    } else {
+        LOG_WARN("name change! old:%{public}s, new:%{public}s", SqliteUtils::Anonymous(asset.name).c_str(),
+            SqliteUtils::Anonymous(newAsset.name).c_str());
+    }
+    auto blob = RawDataParser::PackageRawData(asset);
+    sqlite3_result_blob(ctx, blob.data(), blob.size(), SQLITE_TRANSIENT);
+}
+
 void SqliteConnection::CompAssets(std::map<std::string, ValueObject::Asset> &assets,
     std::map<std::string, ValueObject::Asset> &newAssets)
 {
-    using Status = ValueObject::Asset::Status;
     auto oldIt = assets.begin();
     auto newIt = newAssets.begin();
     for (; oldIt != assets.end() && newIt != newAssets.end();) {
         if (oldIt->first == newIt->first) {
-            if (newIt->second.status == Status::STATUS_DELETE) {
-                oldIt->second.status = Status::STATUS_DELETE;
-                oldIt->second.hash = "";
-                oldIt->second.modifyTime = "";
-                oldIt->second.size = "";
-            } else {
-                MergeAsset(oldIt->second, newIt->second);
-            }
+            MergeAsset(oldIt->second, newIt->second);
             oldIt++;
             newIt = newAssets.erase(newIt);
             continue;
@@ -856,6 +1005,13 @@ void SqliteConnection::CompAssets(std::map<std::string, ValueObject::Asset> &ass
 void SqliteConnection::MergeAsset(ValueObject::Asset &oldAsset, ValueObject::Asset &newAsset)
 {
     using Status = ValueObject::Asset::Status;
+    if (newAsset.status == Status::STATUS_DELETE) {
+        oldAsset.status = Status::STATUS_DELETE;
+        oldAsset.hash = "";
+        oldAsset.modifyTime = "";
+        oldAsset.size = "";
+        return;
+    }
     auto status = static_cast<int32_t>(oldAsset.status);
     switch (status) {
         case Status::STATUS_UNKNOWN:  // fallthrough
@@ -884,36 +1040,27 @@ void SqliteConnection::MergeAsset(ValueObject::Asset &oldAsset, ValueObject::Ass
     }
 }
 
-void SqliteConnection::DeleteDbFile(const RdbStoreConfig &config)
-{
-    auto path = config.GetPath();
-    SqliteUtils::DeleteFile(path);
-    SqliteUtils::DeleteFile(path + "-shm");
-    SqliteUtils::DeleteFile(path + "-wal");
-    SqliteUtils::DeleteFile(path + "-journal");
-}
-
 int32_t SqliteConnection::Subscribe(const std::string &event, const std::shared_ptr<RdbStoreObserver> &observer)
 {
     if (!isWriter_ || observer == nullptr) {
         return E_OK;
     }
     std::lock_guard<std::mutex> lock(mutex_);
-    rdbStoreLocalDbObservers_.try_emplace(event);
-    auto &list = rdbStoreLocalDbObservers_.find(event)->second;
+    observers_.try_emplace(event);
+    auto &list = observers_.find(event)->second;
     for (auto it = list.begin(); it != list.end(); it++) {
         if ((*it)->GetObserver() == observer) {
-            LOG_ERROR("duplicate subscribe");
+            LOG_ERROR("duplicate subscribe.");
             return E_OK;
         }
     }
     auto localStoreObserver = std::make_shared<RdbStoreLocalDbObserver>(observer);
-    int32_t errCode = RegisterStoreObserver(dbHandle, localStoreObserver);
+    int32_t errCode = RegisterStoreObserver(dbHandle_, localStoreObserver);
     if (errCode != E_OK) {
         LOG_ERROR("subscribe failed.");
         return errCode;
     }
-    rdbStoreLocalDbObservers_[event].push_back(std::move(localStoreObserver));
+    observers_[event].push_back(std::move(localStoreObserver));
     return E_OK;
 }
 
@@ -932,15 +1079,15 @@ int32_t SqliteConnection::UnsubscribeLocalDetail(const std::string &event,
     const std::shared_ptr<RdbStoreObserver> &observer)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto observers = rdbStoreLocalDbObservers_.find(event);
-    if (observers == rdbStoreLocalDbObservers_.end()) {
+    auto observers = observers_.find(event);
+    if (observers == observers_.end()) {
         return E_OK;
     }
 
     auto &list = observers->second;
     for (auto it = list.begin(); it != list.end(); it++) {
         if ((*it)->GetObserver() == observer) {
-            int32_t err = UnregisterStoreObserver(dbHandle, *it);
+            int32_t err = UnregisterStoreObserver(dbHandle_, *it);
             if (err != 0) {
                 LOG_ERROR("unsubscribeLocalShared failed.");
                 return err;
@@ -950,7 +1097,7 @@ int32_t SqliteConnection::UnsubscribeLocalDetail(const std::string &event,
         }
     }
     if (list.empty()) {
-        rdbStoreLocalDbObservers_.erase(event);
+        observers_.erase(event);
     }
     return E_OK;
 }
@@ -958,15 +1105,15 @@ int32_t SqliteConnection::UnsubscribeLocalDetail(const std::string &event,
 int32_t SqliteConnection::UnsubscribeLocalDetailAll(const std::string &event)
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto observers = rdbStoreLocalDbObservers_.find(event);
-    if (observers == rdbStoreLocalDbObservers_.end()) {
+    auto observers = observers_.find(event);
+    if (observers == observers_.end()) {
         return E_OK;
     }
 
     auto &list = observers->second;
     auto it = list.begin();
     while (it != list.end()) {
-        int32_t err = UnregisterStoreObserver(dbHandle, *it);
+        int32_t err = UnregisterStoreObserver(dbHandle_, *it);
         if (err != 0) {
             LOG_ERROR("unsubscribe failed.");
             return err;
@@ -974,18 +1121,320 @@ int32_t SqliteConnection::UnsubscribeLocalDetailAll(const std::string &event)
         it = list.erase(it);
     }
 
-    rdbStoreLocalDbObservers_.erase(event);
+    observers_.erase(event);
     return E_OK;
 }
 
-int32_t SqliteConnection::Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey)
+int32_t SqliteConnection::Backup(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+    bool isAsync, SlaveStatus &slaveStatus)
 {
-    return E_NOT_SUPPORT;
+    if (slaveStatus == SlaveStatus::BACKING_UP) {
+        LOG_INFO("backing up, return:%{public}s", config_.GetName().c_str());
+        return E_OK;
+    }
+    LOG_INFO("begin backup to slave:%{public}s, isAsync:%{public}d", SqliteUtils::Anonymous(databasePath).c_str(),
+        isAsync);
+    if (!isAsync) {
+        if (config_.GetHaMode() == HAMode::MANUAL_TRIGGER && slaveConnection_ == nullptr) {
+            RdbStoreConfig rdbSlaveStoreConfig = GetSlaveRdbStoreConfig(config_);
+            int errCode = CreateSlaveConnection(rdbSlaveStoreConfig, true, false);
+            if (errCode != E_OK) {
+                LOG_ERROR("manual slave conn failed:%{public}d", errCode);
+                return errCode;
+            }
+        }
+        return ExchangeSlaverToMaster(false, slaveStatus);
+    }
+    if (backupId_ == TaskExecutor::INVALID_TASK_ID) {
+        auto pool = TaskExecutor::GetInstance().GetExecutor();
+        if (pool == nullptr) {
+            LOG_WARN("task pool err when restore");
+            return E_OK;
+        }
+        backupId_ = pool->Execute([this, &slaveStatus]() {
+            auto [err, conn] = InnerCreate(config_, true);
+            if (err != E_OK) {
+                return;
+            }
+            err = conn->ExchangeSlaverToMaster(false, slaveStatus);
+            if (err != E_OK) {
+                LOG_WARN("master backup to slave failed:%{public}d", err);
+            }
+            backupId_ = TaskExecutor::INVALID_TASK_ID;
+        });
+    }
+    return E_OK;
 }
 
-int32_t SqliteConnection::Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey)
+int32_t SqliteConnection::Restore(const std::string &databasePath, const std::vector<uint8_t> &destEncryptKey,
+    SlaveStatus &slaveStatus)
 {
-    return E_NOT_SUPPORT;
+    LOG_INFO("begin to restore from slave:%{public}s", SqliteUtils::Anonymous(databasePath).c_str());
+    return ExchangeSlaverToMaster(true, slaveStatus);
 };
+
+int SqliteConnection::LoadExtension(const RdbStoreConfig &config, sqlite3 *dbHandle)
+{
+    if (config.GetPluginLibs().empty() || dbHandle == nullptr) {
+        return E_OK;
+    }
+    if (config.GetPluginLibs().size() > SqliteUtils::MAX_LOAD_EXTENSION_COUNT) {
+        LOG_ERROR("failed, size %{public}zu is too large", config.GetPluginLibs().size());
+        return E_INVALID_ARGS;
+    }
+    int err = sqlite3_db_config(dbHandle, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SqliteUtils::ENABLE_LOAD_EXTENSION,
+        nullptr);
+    if (err != SQLITE_OK) {
+        LOG_ERROR("enable failed, err=%{public}d, errno=%{public}d", err, errno);
+        return SQLiteError::ErrNo(err);
+    }
+    for (auto &path : config.GetPluginLibs()) {
+        if (path.empty()) {
+            continue;
+        }
+        if (access(path.c_str(), F_OK) != 0) {
+            LOG_ERROR("no file, errno:%{public}d %{public}s", errno, path.c_str());
+            return E_INVALID_FILE_PATH;
+        }
+        err = sqlite3_load_extension(dbHandle, path.c_str(), nullptr, nullptr);
+        if (err != SQLITE_OK) {
+            LOG_ERROR("load error. err=%{public}d, errno=%{public}d, errmsg:%{public}s, lib=%{public}s",
+                err, errno, sqlite3_errmsg(dbHandle), path.c_str());
+            break;
+        }
+    }
+    int ret = sqlite3_db_config(dbHandle, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SqliteUtils::DISABLE_LOAD_EXTENSION,
+        nullptr);
+    if (ret != SQLITE_OK) {
+        LOG_ERROR("disable failed, err=%{public}d, errno=%{public}d", err, errno);
+    }
+    return SQLiteError::ErrNo(err == SQLITE_OK ? ret : err);
+}
+
+int SqliteConnection::SetServiceKey(const RdbStoreConfig &config, int32_t errCode)
+{
+    DistributedRdb::RdbSyncerParam param;
+    param.bundleName_ = config.GetBundleName();
+    param.hapName_ = config.GetModuleName();
+    param.storeName_ = config.GetName();
+    param.customDir_ = config.GetCustomDir();
+    param.area_ = config.GetArea();
+    param.level_ = static_cast<int32_t>(config.GetSecurityLevel());
+    param.type_ = config.GetDistributedType();
+    param.isEncrypt_ = config.IsEncrypt();
+    param.isAutoClean_ = config.GetAutoClean();
+    param.isSearchable_ = config.IsSearchable();
+    param.haMode_ = config.GetHaMode();
+    param.password_ = {};
+    std::vector<uint8_t> key;
+#if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM) && !defined(ANDROID_PLATFORM) && !defined(IOS_PLATFORM)
+    auto [svcErr, service] = DistributedRdb::RdbManagerImpl::GetInstance().GetRdbService(param);
+    if (svcErr != E_OK) {
+        return errCode;
+    }
+    svcErr = service->GetPassword(param, key);
+    if (svcErr != RDB_OK) {
+        return errCode;
+    }
+#endif
+
+    errCode = SetEncryptKey(key, config.GetIter());
+    if (errCode == E_OK) {
+        config.RestoreEncryptKey(key);
+    }
+    key.assign(key.size(), 0);
+    return errCode;
+}
+
+int SqliteConnection::ExchangeSlaverToMaster(bool isRestore, SlaveStatus &curStatus)
+{
+    curStatus = SlaveStatus::BACKING_UP;
+    auto [isReturn, err] = ExchangeVerify(isRestore);
+    if (isReturn) {
+        curStatus = err == E_OK ? SlaveStatus::UNDEFINED : SlaveStatus::DB_NOT_EXITS;
+        return err;
+    }
+
+    sqlite3 *dbFrom = isRestore ? dbHandle_ : slaveConnection_->dbHandle_;
+    sqlite3 *dbTo = isRestore ? slaveConnection_->dbHandle_ : dbHandle_;
+    sqlite3_backup *pBackup = sqlite3_backup_init(dbFrom, "main", dbTo, "main");
+    if (pBackup == nullptr) {
+        LOG_WARN("slave backup init failed");
+        curStatus = SlaveStatus::UNDEFINED;
+        return E_OK;
+    }
+    int rc = SQLITE_OK;
+    do {
+        if (!isRestore && curStatus == SlaveStatus::BACKUP_INTERRUPT) {
+            LOG_INFO("backup slave was interrupt!");
+            (void)sqlite3_backup_finish(pBackup);
+            (void)SqliteConnection::Delete(slaveConnection_->config_);
+            slaveConnection_ = nullptr;
+            return E_BACKUP_INTERRUPT;
+        }
+        rc = sqlite3_backup_step(pBackup, BACKUP_PAGES_PRE_STEP);
+        LOG_INFO("backup slave process cur/total:%{public}d/%{public}d, isRestore:%{public}d",
+            sqlite3_backup_pagecount(pBackup) - sqlite3_backup_remaining(pBackup), sqlite3_backup_pagecount(pBackup),
+            isRestore);
+        if (!isRestore && (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED)) {
+            sqlite3_sleep(BACKUP_PRE_WAIT_TIME);
+        }
+    } while (rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
+    (void)sqlite3_backup_finish(pBackup);
+    if (rc != SQLITE_DONE) {
+        curStatus = SlaveStatus::BACKUP_INTERRUPT;
+        LOG_WARN("backup slave err:%{public}d, isRestore:%{public}d", rc, isRestore);
+        return SQLiteError::ErrNo(rc);
+    } else {
+        isRestore ? TryCheckPoint() : slaveConnection_->TryCheckPoint();
+        curStatus = SlaveStatus::BACKUP_FINISHED;
+        SqliteUtils::TryAccessSlaveLock(config_.GetPath(), true, false);
+        SqliteUtils::TryAccessSlaveLock(config_.GetPath(), true, false, true);
+        LOG_INFO("backup slave success, isRestore:%{public}d", isRestore);
+    }
+    return E_OK;
+}
+
+ExchangeStrategy SqliteConnection::GenerateExchangeStrategy(const SlaveStatus &status)
+{
+    if (dbHandle_ == nullptr || slaveConnection_ == nullptr || slaveConnection_->dbHandle_ == nullptr ||
+        config_.GetHaMode() != HAMode::MAIN_REPLICA || status == SlaveStatus::BACKING_UP) {
+        return ExchangeStrategy::NOT_HANDLE;
+    }
+    std::string failureFlagFile = config_.GetPath() + "-slaveFailure";
+    if (status == SlaveStatus::DB_NOT_EXITS || status == SlaveStatus::BACKUP_INTERRUPT) {
+        return ExchangeStrategy::BACKUP;
+    }
+    static const std::string querySql = "SELECT COUNT(*) FROM sqlite_master WHERE type='table';";
+    auto [mRet, mObj] = ExecuteForValue(querySql);
+    if (mRet != E_OK) {
+        return ExchangeStrategy::NOT_HANDLE;
+    }
+    auto [sRet, sObj] = slaveConnection_->ExecuteForValue(querySql);
+    if (sRet != E_OK) {
+        LOG_WARN("slave db abnormal, need backup, err:%{public}d", sRet);
+        return ExchangeStrategy::BACKUP;
+    }
+    int64_t mCount = static_cast<int64_t>(mObj);
+    int64_t sCount = static_cast<int64_t>(sObj);
+    if (mCount == sCount && access(failureFlagFile.c_str(), F_OK) != 0) {
+        LOG_INFO("equal, main:%{public}" PRId64 ",slave:%{public}" PRId64, mCount, sCount);
+        return ExchangeStrategy::NOT_HANDLE;
+    }
+    if (mCount == 0) {
+        LOG_INFO("main empty, main:%{public}" PRId64 ",slave:%{public}" PRId64, mCount, sCount);
+        return ExchangeStrategy::RESTORE;
+    } else {
+        auto [cRet, cObj] = ExecuteForValue(INTEGRITIES[1]); // 1 is quick_check
+        if (cRet != E_OK || (static_cast<std::string>(cObj) != "ok")) {
+            LOG_ERROR("main corrupt, need restore, ret:%{public}s, cRet:%{public}d",
+                static_cast<std::string>(cObj).c_str(), cRet);
+            return ExchangeStrategy::RESTORE;
+        } else {
+            LOG_INFO("not equal, main:%{public}" PRId64 ",slave:%{public}" PRId64, mCount, sCount);
+            return ExchangeStrategy::BACKUP;
+        }
+    }
+    return ExchangeStrategy::NOT_HANDLE;
+}
+
+int32_t SqliteConnection::Repair(const RdbStoreConfig &config)
+{
+    if (config.GetHaMode() != MAIN_REPLICA) {
+        return E_NOT_SUPPORT;
+    }
+    std::shared_ptr<SqliteConnection> connection = std::make_shared<SqliteConnection>(config, true);
+    if (connection == nullptr) {
+        return E_NOT_SUPPORT;
+    }
+    RdbStoreConfig rdbSlaveStoreConfig = connection->GetSlaveRdbStoreConfig(config);
+    int ret = connection->CreateSlaveConnection(rdbSlaveStoreConfig, true);
+    if (ret != E_OK) {
+        return ret;
+    }
+    if (!connection->IsRepairable()) {
+        return E_NOT_SUPPORT;
+    }
+    LOG_WARN("begin repair main:%{public}s", SqliteUtils::Anonymous(config.GetPath()).c_str());
+    (void)SqliteConnection::Delete(config);
+    ret = connection->InnerOpen(config);
+    if (ret != E_OK) {
+        LOG_ERROR("reopen db failed, err:%{public}d", ret);
+        return ret;
+    }
+    SlaveStatus curStatus;
+    ret = connection->ExchangeSlaverToMaster(true, curStatus);
+    if (ret != E_OK) {
+        LOG_ERROR("repair failed, [%{public}s]->[%{public}s], err:%{public}d", rdbSlaveStoreConfig.GetName().c_str(),
+            config.GetName().c_str(), ret);
+    } else {
+        LOG_INFO("repair main success:%{public}s", SqliteUtils::Anonymous(config.GetPath()).c_str());
+    }
+    connection->slaveConnection_ = nullptr;
+    connection = nullptr;
+    return ret;
+}
+
+bool SqliteConnection::IsRepairable()
+{
+    if (slaveConnection_ == nullptr || slaveConnection_->dbHandle_ == nullptr) {
+        return false;
+    }
+    static const std::string querySql = "SELECT COUNT(*) FROM sqlite_master WHERE type='table';";
+    auto [qRet, qObj] = slaveConnection_->ExecuteForValue(querySql);
+    if (qRet != E_OK || (static_cast<int64_t>(qObj) == 0L)) {
+        LOG_INFO("cancel repair, ret:%{public}d", qRet);
+        return false;
+    }
+    auto [cRet, cObj] = slaveConnection_->ExecuteForValue(INTEGRITIES[1]); // 1 is quick check
+    if (cRet != E_OK || (static_cast<std::string>(cObj) != "ok")) {
+        LOG_ERROR("cancel repair, ret:%{public}s, cRet:%{public}d", static_cast<std::string>(cObj).c_str(), cRet);
+        return false;
+    }
+    return true;
+}
+
+std::pair<bool, int> SqliteConnection::ExchangeVerify(bool isRestore)
+{
+    if (dbHandle_ == nullptr || slaveConnection_ == nullptr || slaveConnection_->dbHandle_ == nullptr) {
+        LOG_WARN("slave conn invalid");
+        return { true, E_OK };
+    }
+    if (!SqliteUtils::TryAccessSlaveLock(config_.GetPath(), false, true)) {
+        LOG_WARN("try create slave lock failed! isRestore:%{public}d", isRestore);
+    }
+    if (isRestore) {
+        auto [cRet, cObj] = slaveConnection_->ExecuteForValue(INTEGRITIES[2]); // 2 is integrity_check
+        if (cRet != E_OK || (static_cast<std::string>(cObj) != "ok")) {
+            LOG_ERROR("slave may corrupt, cancel backup, ret:%{public}s, cRet:%{public}d",
+                static_cast<std::string>(cObj).c_str(), cRet);
+            return { true, E_SQLITE_CORRUPT };
+        }
+    }
+    return { false, E_OK };
+}
+
+std::pair<int32_t, std::shared_ptr<SqliteConnection>> SqliteConnection::InnerCreate(const RdbStoreConfig &config,
+    bool isWrite)
+{
+    std::pair<int32_t, std::shared_ptr<SqliteConnection>> result = { E_ERROR, nullptr };
+    auto &[errCode, conn] = result;
+    std::shared_ptr<SqliteConnection> connection = std::make_shared<SqliteConnection>(config, isWrite);
+    if (connection == nullptr) {
+        LOG_ERROR("connection is nullptr.");
+        return result;
+    }
+
+    RdbStoreConfig rdbSlaveStoreConfig = connection->GetSlaveRdbStoreConfig(config);
+    errCode = connection->InnerOpen(config);
+    if (errCode != E_OK) {
+        return result;
+    }
+    conn = connection;
+    if (isWrite) {
+        (void)connection->CreateSlaveConnection(rdbSlaveStoreConfig, isWrite);
+    }
+    return result;
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_global_config.cpp b/relational_store/frameworks/native/rdb/src/sqlite_global_config.cpp
index cdb1ba1518a253712cbb70fbc1a33478d1e3092d..433b648f7554873969ad731ffd7ddcb026b8c56b 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_global_config.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_global_config.cpp
@@ -63,9 +63,9 @@ void SqliteGlobalConfig::Log(const void *data, int err, const char *msg)
             LOG_INFO("Error(%{public}d) %{public}s ", err, msg);
         }
     } else if (errType == SQLITE_WARNING) {
-        LOG_WARN("WARNING(%{public}d) %{public}s ", err, SqliteUtils::Anonymous(msg).c_str());
+        LOG_WARN("WARNING(%{public}d) %{public}s ", err, msg);
     } else {
-        LOG_ERROR("Error(%{public}d) errno is:%{public}d %{public}s" PRIu64 ".", err, errno, msg);
+        LOG_ERROR("Error(%{public}d) errno is:%{public}d %{public}s.", err, errno, msg);
     }
 }
 
@@ -116,7 +116,7 @@ int SqliteGlobalConfig::GetDbPath(const RdbStoreConfig &config, std::string &dbP
         }
         dbPath = SqliteGlobalConfig::GetMemoryDbPath();
     } else if (path.empty() || (path.front() != '/' && path.at(1) != ':')) {
-        LOG_ERROR("SqliteConnection GetDbPath input empty database path");
+        LOG_ERROR("SqliteConnection GetDbPath input empty database path.");
         return E_INVALID_FILE_PATH;
     } else {
         dbPath = path;
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_shared_result_set.cpp b/relational_store/frameworks/native/rdb/src/sqlite_shared_result_set.cpp
index 6db163ba295d5017a61542adee16b2a5e90693a2..0bf0b00e5c98f0cb787dbd9cfd5aca7f6b532b6b 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_shared_result_set.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_shared_result_set.cpp
@@ -21,6 +21,7 @@
 #include <memory>
 #include <mutex>
 #include <tuple>
+#include <cinttypes>
 
 #include "logger.h"
 #include "rdb_sql_utils.h"
@@ -35,21 +36,41 @@
 namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
-SqliteSharedResultSet::SqliteSharedResultSet(std::shared_ptr<SqliteConnectionPool> pool, std::string path,
+
+constexpr int64_t TIME_OUT = 1500;
+SqliteSharedResultSet::SqliteSharedResultSet(std::shared_ptr<ConnectionPool> pool, std::string path,
     std::string sql, const std::vector<ValueObject>& bindArgs)
     : AbsSharedResultSet(path), isOnlyFillBlock_(false), blockCapacity_(0), qrySql_(std::move(sql)),
       bindArgs_(std::move(bindArgs))
 {
+    auto queryStart = std::chrono::steady_clock::now();
     conn_ = pool->AcquireRef(true);
     if (conn_ == nullptr) {
         isClosed_ = true;
+        return;
     }
+    auto preparStart = std::chrono::steady_clock::now();
     auto [statement, errCode] = PrepareStep();
     if (errCode != E_OK) {
         LOG_ERROR("step resultset ret %{public}d", errCode);
+        return;
     }
     statement_ = statement;
+    auto initCountStart = std::chrono::steady_clock::now();
     rowCount_ = InitRowCount();
+    auto queryEnd = std::chrono::steady_clock::now();
+    int64_t totalCostTime = std::chrono::duration_cast<std::chrono::milliseconds>(queryEnd - queryStart).count();
+    if (totalCostTime >= TIME_OUT) {
+        int64_t acquirCost = std::chrono::duration_cast<std::chrono::milliseconds>(preparStart - queryStart).count();
+        int64_t preparCost =
+            std::chrono::duration_cast<std::chrono::milliseconds>(initCountStart - preparStart).count();
+        int64_t initCountCost =
+            std::chrono::duration_cast<std::chrono::milliseconds>(queryEnd - initCountStart).count();
+        LOG_WARN("query totalCostTime[%{public}" PRId64 "] acquirCost[%{public}" PRId64 "] preparCost[%{public}" PRId64
+            "] "
+            "initCountCost[%{public}" PRId64 "] rowCount[%{public}d] sql[%{public}s] path[%{public}s]",
+            totalCostTime, acquirCost, preparCost, initCountCost, rowCount_, qrySql_.c_str(), path.c_str());
+    }
 }
 
 int SqliteSharedResultSet::InitRowCount()
@@ -70,6 +91,7 @@ int SqliteSharedResultSet::InitRowCount()
         count++;
     } while (status == E_OK || ((status == E_SQLITE_BUSY || status == E_SQLITE_LOCKED) && retry < MAX_RETRY_TIMES));
     if (status != E_NO_MORE_ROWS) {
+        lastErr_ = status;
         count = NO_COUNT;
     }
     statement_->Reset();
@@ -79,7 +101,8 @@ int SqliteSharedResultSet::InitRowCount()
 std::pair<std::shared_ptr<Statement>, int> SqliteSharedResultSet::PrepareStep()
 {
     if (conn_ == nullptr) {
-        LOG_ERROR("Already close");
+        LOG_ERROR("Already close.");
+        lastErr_ = E_ALREADY_CLOSED;
         return { nullptr, E_ALREADY_CLOSED };
     }
 
@@ -90,16 +113,19 @@ std::pair<std::shared_ptr<Statement>, int> SqliteSharedResultSet::PrepareStep()
     auto type = SqliteUtils::GetSqlStatementType(qrySql_);
     if (type == SqliteUtils::STATEMENT_ERROR) {
         LOG_ERROR("invalid sql_ %{public}s!", qrySql_.c_str());
+        lastErr_ = E_INVALID_ARGS;
         return { nullptr, E_INVALID_ARGS };
     }
 
     auto [errCode, statement] = conn_->CreateStatement(qrySql_, conn_);
     if (statement == nullptr) {
+        lastErr_ = errCode;
         return { statement, errCode };
     }
 
     if (!statement->ReadOnly()) {
         LOG_ERROR("failed, %{public}s is not query sql!", SqliteUtils::Anonymous(qrySql_).c_str());
+        lastErr_ = E_NOT_SELECT;
         return { nullptr, E_NOT_SELECT };
     }
 
@@ -108,6 +134,7 @@ std::pair<std::shared_ptr<Statement>, int> SqliteSharedResultSet::PrepareStep()
         LOG_ERROR("Bind arg faild! Ret is %{public}d", errCode);
         statement->Reset();
         statement = nullptr;
+        lastErr_ = errCode;
         return { nullptr, errCode };
     }
     return { statement, E_OK };
@@ -145,8 +172,8 @@ std::pair<int, std::vector<std::string>> SqliteSharedResultSet::GetColumnNames()
 int SqliteSharedResultSet::Close()
 {
     AbsSharedResultSet::Close();
-    conn_ = nullptr;
     statement_ = nullptr;
+    conn_ = nullptr;
     rowCount_ = NO_COUNT;
     auto qrySql = std::move(qrySql_);
     auto bindArgs = std::move(bindArgs_);
@@ -192,9 +219,13 @@ int SqliteSharedResultSet::FillBlock(int requiredPos)
         return errCode;
     }
     blockCapacity_ = block->GetRowNum();
-    LOG_INFO("blockRowNum=%{public}d, requiredPos= %{public}d, startPos_= %{public}" PRIu32
+    if ((block->GetStartPos() == block->GetLastPos() && (uint32_t)rowCount_ != block->GetStartPos())
+        || ((uint32_t)requiredPos < block->GetStartPos() || block->GetLastPos() <= (uint32_t)requiredPos)
+        || block->GetStartPos() > 0) {
+        LOG_WARN("blockRowNum=%{public}d, requiredPos= %{public}d, startPos_= %{public}" PRIu32
              ", lastPos_= %{public}" PRIu32 ", blockPos_= %{public}" PRIu32 ".",
         rowCount_, requiredPos, block->GetStartPos(), block->GetLastPos(), block->GetBlockPos());
+    }
     return E_OK;
 }
 
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_sql_builder.cpp b/relational_store/frameworks/native/rdb/src/sqlite_sql_builder.cpp
index 229edd4c03c643825a0987b2aeab39cdb3b11907..133ff618f0a29ae479a976797288781757293b3d 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_sql_builder.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_sql_builder.cpp
@@ -21,8 +21,8 @@
 #include "logger.h"
 #include "rdb_errno.h"
 #include "rdb_trace.h"
-#include "string_utils.h"
 #include "sqlite_utils.h"
+#include "string_utils.h"
 
 namespace OHOS {
 namespace NativeRdb {
@@ -40,8 +40,10 @@ std::string SqliteSqlBuilder::BuildDeleteString(const std::string &tableName, co
     const std::string &whereClause, const std::string &group, const std::string &order, int limit, int offset)
 {
     std::string sql;
-    sql.append("Delete ").append("FROM ").append(tableName).append(
-        BuildSqlStringFromPredicates(index, "", whereClause, group, order, limit, offset));
+    sql.append("Delete ")
+        .append("FROM ")
+        .append(HandleTable(tableName))
+        .append(BuildSqlStringFromPredicates(index, "", whereClause, group, order, limit, offset));
     return sql;
 }
 
@@ -58,7 +60,7 @@ std::string SqliteSqlBuilder::BuildUpdateString(const ValuesBucket &values, cons
     sql.append("UPDATE")
         .append(g_onConflictClause[static_cast<int>(conflictResolution)])
         .append(" ")
-        .append(tableName)
+        .append(HandleTable(tableName))
         .append(" SET ");
     const char *split = "";
     for (auto &[key, val] : values.values_) {
@@ -98,8 +100,9 @@ int SqliteSqlBuilder::BuildQueryString(bool distinct, const std::string &table,
     } else {
         sql.append("* ");
     }
-    sql.append("FROM ").append(table).append(
-        BuildSqlStringFromPredicates(indexName, joinClause, whereClause, groupBy, orderBy, limit, offset));
+    sql.append("FROM ")
+        .append(HandleTable(table))
+        .append(BuildSqlStringFromPredicates(indexName, joinClause, whereClause, groupBy, orderBy, limit, offset));
     outSql = sql;
 
     return E_OK;
@@ -113,7 +116,7 @@ std::string SqliteSqlBuilder::BuildCountString(const std::string &tableName, con
 {
     std::string sql;
     sql.append("SELECT COUNT(*) FROM ")
-        .append(tableName)
+        .append(HandleTable(tableName))
         .append(BuildSqlStringFromPredicates(index, "", whereClause, group, order, limit, offset));
     return sql;
 }
@@ -172,8 +175,8 @@ std::string SqliteSqlBuilder::BuildSqlStringFromPredicatesNoWhere(const std::str
     return sqlString;
 }
 
-void SqliteSqlBuilder::AppendClause(std::string &builder, const std::string &name,
-    const std::string &clause, const std::string &table)
+void SqliteSqlBuilder::AppendClause(
+    std::string &builder, const std::string &name, const std::string &clause, const std::string &table)
 {
     if (clause.empty()) {
         return;
@@ -222,23 +225,24 @@ std::string SqliteSqlBuilder::BuildQueryString(
     int limit = predicates.GetLimit();
     int offset = predicates.GetOffset();
     std::string sqlStr;
-    BuildQueryString(distinct, tableName, joinClauseStr, columns, whereClauseStr,
-        groupStr, indexStr, orderStr, limit, offset, sqlStr);
+    BuildQueryString(distinct, tableName, joinClauseStr, columns, whereClauseStr, groupStr, indexStr, orderStr, limit,
+        offset, sqlStr);
     return sqlStr;
 }
 
 std::string SqliteSqlBuilder::BuildCountString(const AbsRdbPredicates &predicates)
 {
     std::string tableName = predicates.GetTableName();
-    return "SELECT COUNT(*) FROM " + tableName + BuildSqlStringFromPredicates(predicates);
+    return "SELECT COUNT(*) FROM " + HandleTable(tableName) + BuildSqlStringFromPredicates(predicates);
 }
 
 std::string SqliteSqlBuilder::BuildCursorQueryString(const AbsRdbPredicates &predicates,
-    const std::vector<std::string> &columns, const std::string &logTable,  const std::pair<bool, bool> &queryStatus)
+    const std::vector<std::string> &columns, const std::string &logTable, const std::pair<bool, bool> &queryStatus)
 {
     std::string sql;
-    std::string table = predicates.GetTableName();
-    if (table.empty() || logTable.empty()) {
+    std::string table = HandleTable(predicates.GetTableName());
+    auto logName = HandleTable(logTable);
+    if (table.empty() || logName.empty()) {
         return sql;
     }
     sql.append("SELECT ");
@@ -254,23 +258,26 @@ std::string SqliteSqlBuilder::BuildCursorQueryString(const AbsRdbPredicates &pre
         std::string field = DistributedRdb::Field::SHARING_RESOURCE_FIELD;
         SqliteUtils::Replace(field, SqliteUtils::REP, "");
         SqliteUtils::Replace(sql, table + "." + DistributedRdb::Field::SHARING_RESOURCE_FIELD,
-            logTable + "." + SHARING_RESOURCE + " AS " + field);
+            logName + "." + SHARING_RESOURCE + " AS " + field);
     }
     if (queryStatus.second) {
         sql.append(", " + logTable + ".cursor");
         sql.append(", CASE WHEN ").append(logTable).append(".")
             .append("flag & 0x8 = 0x8 THEN true ELSE false END AS deleted_flag");
+        sql.append(", CASE WHEN ").append(logTable).append(".");
+        sql.append("flag & 0x808 = 0x808 THEN 3 WHEN ").append(logTable).append(".flag & 0x800 = 0x800 THEN 1 WHEN ")
+            .append(logTable).append(".flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status");
     }
     sql.append(" FROM ").append(table);
     AppendClause(sql, " INDEXED BY ", predicates.GetIndex());
     sql.append(" INNER JOIN ").append(logTable).append(" ON ").append(table)
         .append(".ROWID = ").append(logTable).append(".data_key");
     auto whereClause = predicates.GetWhereClause();
-    SqliteUtils::Replace(whereClause, SqliteUtils::REP, logTable + ".");
+    SqliteUtils::Replace(whereClause, SqliteUtils::REP, logName + ".");
     AppendClause(sql, " WHERE ", whereClause);
     AppendClause(sql, " GROUP BY ", predicates.GetGroup(), table);
     auto order = predicates.GetOrder();
-    SqliteUtils::Replace(order, SqliteUtils::REP, logTable + ".");
+    SqliteUtils::Replace(order, SqliteUtils::REP, logName + ".");
     AppendClause(sql, " ORDER BY ", order);
     int limit = predicates.GetLimit();
     auto limitClause = (limit == AbsPredicates::INIT_LIMIT_VALUE) ? "" : std::to_string(limit);
@@ -285,8 +292,9 @@ std::string SqliteSqlBuilder::BuildLockRowQueryString(
     const AbsRdbPredicates &predicates, const std::vector<std::string> &columns, const std::string &logTable)
 {
     std::string sql;
-    std::string table = predicates.GetTableName();
-    if (table.empty() || logTable.empty()) {
+    std::string table = HandleTable(predicates.GetTableName());
+    auto logName = HandleTable(logTable);
+    if (table.empty() || logName.empty()) {
         return sql;
     }
     sql.append("SELECT ");
@@ -300,18 +308,18 @@ std::string SqliteSqlBuilder::BuildLockRowQueryString(
     }
     sql.append(" FROM ").append(table);
     AppendClause(sql, " INDEXED BY ", predicates.GetIndex());
-    sql.append(" INNER JOIN ").append(logTable).append(" ON ");
-    sql.append(table).append(".ROWID = ").append(logTable).append(".data_key");
+    sql.append(" INNER JOIN ").append(logName).append(" ON ");
+    sql.append(table).append(".ROWID = ").append(logName).append(".data_key");
     auto whereClause = predicates.GetWhereClause();
     if (whereClause.empty()) {
-        sql.append(" WHERE ").append(logTable).append(".status = 2 OR ").append(logTable).append(".status = 3 ");
+        sql.append(" WHERE ").append(logName).append(".status = 2 OR ").append(logName).append(".status = 3 ");
     } else {
-        SqliteUtils::Replace(whereClause, SqliteUtils::REP, logTable + ".");
+        SqliteUtils::Replace(whereClause, SqliteUtils::REP, logName + ".");
         AppendClause(sql, " WHERE ", whereClause);
     }
     AppendClause(sql, " GROUP BY ", predicates.GetGroup(), table);
     auto order = predicates.GetOrder();
-    SqliteUtils::Replace(order, SqliteUtils::REP, logTable + ".");
+    SqliteUtils::Replace(order, SqliteUtils::REP, logName + ".");
     AppendClause(sql, " ORDER BY ", order);
     int limit = predicates.GetLimit();
     auto limitClause = (limit == AbsPredicates::INIT_LIMIT_VALUE) ? "" : std::to_string(limit);
@@ -348,7 +356,7 @@ SqliteSqlBuilder::ExecuteSqls SqliteSqlBuilder::MakeExecuteSqls(
         "remainingRows %{public}zu, fieldSize %{public}d, limit %{public}d",
         rowNumbers, maxRowNumbersOneTimes, executeTimes, remainingRows, fieldSize, limit);
     std::string singleRowSqlArgs = "(" + SqliteSqlBuilder::GetSqlArgs(fieldSize) + ")";
-    auto appendAgsSql = [&singleRowSqlArgs, &sql] (size_t rowNumber) {
+    auto appendAgsSql = [&singleRowSqlArgs, &sql](size_t rowNumber) {
         std::string sqlStr = sql;
         for (size_t i = 0; i < rowNumber; ++i) {
             sqlStr.append(singleRowSqlArgs).append(",");
@@ -378,5 +386,17 @@ SqliteSqlBuilder::ExecuteSqls SqliteSqlBuilder::MakeExecuteSqls(
     }
     return executeSqls;
 }
+
+std::string SqliteSqlBuilder::HandleTable(const std::string &tableName)
+{
+    if (tableName.empty()) {
+        return tableName;
+    }
+    std::regex validName("^([a-zA-Z_][a-zA-Z0-9_\\.\\ ]*)$");
+    if (std::regex_match(tableName, validName)) {
+        return tableName;
+    }
+    return "'" + tableName + "'";
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_statement.cpp b/relational_store/frameworks/native/rdb/src/sqlite_statement.cpp
index 3475d4732eeb400d2b4aa707f33eeeda70cd909d..fe0d2e295465bf809864c2d1906426a886e0884e 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_statement.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_statement.cpp
@@ -21,6 +21,7 @@
 #include <sstream>
 #include <utility>
 
+#include "connection_pool.h"
 #include "logger.h"
 #include "raw_data_parser.h"
 #include "rdb_errno.h"
@@ -32,9 +33,10 @@
 #include "sqlite3.h"
 #include "sqlite3ext.h"
 #include "sqlite_connection.h"
-#include "sqlite_connection_pool.h"
 #include "sqlite_errno.h"
 #include "sqlite_utils.h"
+#include "rdb_fault_hiview_reporter.h"
+#include "sqlite_global_config.h"
 
 namespace OHOS {
 namespace NativeRdb {
@@ -69,9 +71,17 @@ int SqliteStatement::Prepare(sqlite3 *dbHandle, const std::string &newSql)
         if (stmt != nullptr) {
             sqlite3_finalize(stmt);
         }
-        return SQLiteError::ErrNo(errCode);
+        if (errCode == SQLITE_NOTADB) {
+            ReadFile2Buffer();
+        }
+        int ret = SQLiteError::ErrNo(errCode);
+        if (ret == E_SQLITE_CORRUPT) {
+            ReportDbCorruptedEvent(ret);
+        }
+        PrintInfoForDbError(ret);
+        return ret;
     }
-    Finalize(); // finalize the old
+    InnerFinalize(); // finalize the old
     sql_ = newSql;
     stmt_ = stmt;
     readOnly_ = (sqlite3_stmt_readonly(stmt_) != 0);
@@ -81,6 +91,46 @@ int SqliteStatement::Prepare(sqlite3 *dbHandle, const std::string &newSql)
     return E_OK;
 }
 
+void SqliteStatement::PrintInfoForDbError(int errorCode)
+{
+    if (config_ == nullptr) {
+        return;
+    }
+    if (errorCode == E_SQLITE_ERROR || errorCode == E_SQLITE_BUSY || errorCode == E_SQLITE_LOCKED ||
+        errorCode == E_SQLITE_IOERR || errorCode == E_SQLITE_CORRUPT || errorCode == E_SQLITE_CANTOPEN) {
+        LOG_ERROR(" DbError errorCode: %{public}d  DbName: %{public}s ", errorCode, config_->GetName().c_str());
+    }
+}
+
+void SqliteStatement::ReadFile2Buffer()
+{
+    if (config_ == nullptr) {
+        return;
+    }
+    std::string fileName;
+    if (SqliteGlobalConfig::GetDbPath(*config_, fileName) != E_OK || access(fileName.c_str(), F_OK) != 0) {
+        return;
+    }
+    uint64_t buffer[BUFFER_LEN] = {0x0};
+    FILE *file = fopen(fileName.c_str(), "r");
+    if (file == nullptr) {
+        LOG_ERROR("open db file failed: %{public}s, errno is %{public}d", fileName.c_str(), errno);
+        return;
+    }
+    size_t readSize = fread(buffer, sizeof(uint64_t), BUFFER_LEN, file);
+    if (readSize != BUFFER_LEN) {
+        LOG_ERROR("read db file size: %{public}zu, errno is %{public}d", readSize, errno);
+        (void)fclose(file);
+        return;
+    }
+    constexpr int bufferSize = 4;
+    for (uint32_t i = 0; i < BUFFER_LEN; i += bufferSize) {
+        LOG_WARN("line%{public}d: %{public}" PRIx64 "%{public}" PRIx64 "%{public}" PRIx64 "%{public}" PRIx64,
+            i >> 2, buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]);
+    }
+    (void)fclose(file);
+}
+
 int SqliteStatement::BindArgs(const std::vector<ValueObject> &bindArgs)
 {
     SqlStatistic sqlStatistic("", SqlStatistic::Step::STEP_PREPARE, seqId_);
@@ -114,8 +164,8 @@ int SqliteStatement::IsValid(int index) const
         return E_ALREADY_CLOSED;
     }
 
-    if (index >= columnCount_) {
-        LOG_ERROR("index (%{public}d) >= columnCount (%{public}d)", index, columnCount_);
+    if (index >= columnCount_ || index < 0) {
+        LOG_ERROR("index (%{public}d) is out of range [0, %{public}d]", index, columnCount_ - 1);
         return E_COLUMN_OUT_RANGE;
     }
     return E_OK;
@@ -127,7 +177,19 @@ int SqliteStatement::Prepare(const std::string &sql)
         return E_ERROR;
     }
     auto db = sqlite3_db_handle(stmt_);
-    return Prepare(db, sql);
+    int errCode = Prepare(db, sql);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+
+    if (slave_) {
+        int errCode = slave_->Prepare(sql);
+        if (errCode != E_OK) {
+            LOG_WARN("slave prepare Error:%{public}d", errCode);
+            SqliteUtils::TryAccessSlaveLock(config_->GetPath(), false, true, true);
+        }
+    }
+    return E_OK;
 }
 
 int SqliteStatement::Bind(const std::vector<ValueObject> &args)
@@ -156,13 +218,70 @@ int SqliteStatement::Bind(const std::vector<ValueObject> &args)
         return E_INVALID_BIND_ARGS_COUNT;
     }
 
-    return BindArgs(abindArgs);
+    int errCode = BindArgs(abindArgs);
+    if (errCode != E_OK) {
+        return errCode;
+    }
+
+    if (slave_) {
+        int errCode = slave_->Bind(args);
+        if (errCode != E_OK) {
+            LOG_ERROR("slave bind error:%{public}d", errCode);
+            SqliteUtils::TryAccessSlaveLock(config_->GetPath(), false, true, true);
+        }
+    }
+    return E_OK;
+}
+
+std::pair<int32_t, int32_t> SqliteStatement::Count()
+{
+    int32_t count = INVALID_COUNT;
+    int32_t status = E_OK;
+    int32_t retry = 0;
+    do {
+        status = Step();
+        if (status == E_SQLITE_BUSY || status == E_SQLITE_LOCKED) {
+            retry++;
+            usleep(RETRY_INTERVAL);
+            continue;
+        }
+        count++;
+    } while (status == E_OK || ((status == E_SQLITE_BUSY || status == E_SQLITE_LOCKED) && retry < MAX_RETRY_TIMES));
+    if (status != E_NO_MORE_ROWS) {
+        Reset();
+        return { status, INVALID_COUNT };
+    }
+    if (retry > 0) {
+        LOG_WARN("locked, retry=%{public}d, sql=%{public}s", retry, sql_.c_str());
+    }
+    Reset();
+    return { E_OK, count };
 }
 
 int SqliteStatement::Step()
+{
+    int ret = InnerStep();
+    if (ret != E_OK) {
+        return ret;
+    }
+    if (slave_) {
+        ret = slave_->InnerStep();
+        if (ret != E_OK) {
+            LOG_WARN("slave step error:%{public}d", ret);
+        }
+    }
+    return E_OK;
+}
+
+int SqliteStatement::InnerStep()
 {
     SqlStatistic sqlStatistic("", SqlStatistic::Step::STEP_EXECUTE, seqId_);
-    return SQLiteError::ErrNo(sqlite3_step(stmt_));
+    int ret = SQLiteError::ErrNo(sqlite3_step(stmt_));
+    if (ret == E_SQLITE_CORRUPT) {
+        ReportDbCorruptedEvent(ret);
+    }
+    PrintInfoForDbError(ret);
+    return ret;
 }
 
 int SqliteStatement::Reset()
@@ -176,25 +295,27 @@ int SqliteStatement::Reset()
         LOG_ERROR("reset ret is %{public}d, errno is %{public}d", errCode, errno);
         return SQLiteError::ErrNo(errCode);
     }
+    if (slave_) {
+        errCode = slave_->Reset();
+        if (errCode != E_OK) {
+            LOG_WARN("slave reset error:%{public}d", errCode);
+        }
+    }
     return E_OK;
 }
 
 int SqliteStatement::Finalize()
 {
-    if (stmt_ == nullptr) {
-        return E_OK;
+    int errCode = InnerFinalize();
+    if (errCode != E_OK) {
+        return errCode;
     }
 
-    int errCode = sqlite3_finalize(stmt_);
-    stmt_ = nullptr;
-    sql_ = "";
-    readOnly_ = false;
-    columnCount_ = -1;
-    numParameters_ = 0;
-    types_ = std::vector<int32_t>();
-    if (errCode != SQLITE_OK) {
-        LOG_ERROR("finalize ret is %{public}d, errno is %{public}d", errCode, errno);
-        return SQLiteError::ErrNo(errCode);
+    if (slave_) {
+        errCode = slave_->Finalize();
+        if (errCode != E_OK) {
+            LOG_WARN("slave finalize error:%{public}d", errCode);
+        }
     }
     return E_OK;
 }
@@ -212,10 +333,12 @@ int SqliteStatement::Execute(const std::vector<ValueObject> &args)
         if (!conn_->IsWriter() && !ReadOnly()) {
             return E_EXECUTE_WRITE_IN_READ_CONNECTION;
         }
-
         auto errCode = conn_->LimitWalSize();
         if (errCode != E_OK) {
-            return errCode;
+            int sqlType = SqliteUtils::GetSqlStatementType(sql_);
+            if (sqlType != SqliteUtils::STATEMENT_COMMIT && sqlType != SqliteUtils::STATEMENT_ROLLBACK) {
+                return errCode;
+            }
         }
     }
 
@@ -223,11 +346,19 @@ int SqliteStatement::Execute(const std::vector<ValueObject> &args)
     if (errCode != E_OK) {
         return errCode;
     }
-    errCode = Step();
+    errCode = InnerStep();
     if (errCode != E_NO_MORE_ROWS && errCode != E_OK) {
         LOG_ERROR("sqlite3_step failed %{public}d, sql is %{public}s, errno %{public}d", errCode, sql_.c_str(), errno);
         return errCode;
     }
+
+    if (slave_) {
+        int errCode = slave_->Execute(args);
+        if (errCode != E_OK) {
+            LOG_ERROR("slave execute error:%{public}d", errCode);
+            SqliteUtils::TryAccessSlaveLock(config_->GetPath(), false, true, true);
+        }
+    }
     return E_OK;
 }
 
@@ -487,6 +618,10 @@ int32_t SqliteStatement::BindBlob(sqlite3_stmt *stat, int index, const ValueObje
     if (val == nullptr) {
         return SQLITE_MISMATCH;
     }
+
+    if (val->empty()) {
+        return sqlite3_bind_zeroblob(stat, index, 0);
+    }
     return sqlite3_bind_blob(stat, index, static_cast<const void *>((*val).data()), (*val).size(), SQLITE_TRANSIENT);
 }
 
@@ -555,5 +690,55 @@ int SqliteStatement::ModifyLockStatus(const std::string &table, const std::vecto
     LOG_ERROR("Lock/Unlock failed, err is %{public}d.", ret);
     return E_ERROR;
 }
+
+void SqliteStatement::ReportDbCorruptedEvent(int errorCode)
+{
+    if (config_ == nullptr) {
+        return;
+    }
+    RdbCorruptedEvent eventInfo;
+    eventInfo.bundleName = config_->GetBundleName();
+    eventInfo.moduleName = config_->GetModuleName();
+    eventInfo.storeType = "RDB";
+    eventInfo.storeName = config_->GetName();
+    eventInfo.securityLevel = static_cast<uint32_t>(config_->GetSecurityLevel());
+    eventInfo.pathArea = static_cast<uint32_t>(config_->GetArea());
+    eventInfo.encryptStatus = static_cast<uint32_t>(config_->IsEncrypt());
+    eventInfo.integrityCheck = static_cast<uint32_t>(config_->GetIntegrityCheck());
+    eventInfo.errorCode = static_cast<uint32_t>(errorCode);
+    eventInfo.systemErrorNo = errno;
+    eventInfo.errorOccurTime = time(nullptr);
+    std::string dbPath;
+    if (SqliteGlobalConfig::GetDbPath(*config_, dbPath) == E_OK && access(dbPath.c_str(), F_OK) == 0) {
+        eventInfo.dbFileStatRet = stat(dbPath.c_str(), &eventInfo.dbFileStat);
+        std::string walPath = dbPath + "-wal";
+        eventInfo.walFileStatRet = stat(walPath.c_str(), &eventInfo.walFileStat);
+    } else {
+        eventInfo.dbFileStatRet = -1;
+        eventInfo.walFileStatRet = -1;
+    }
+    RdbFaultHiViewReporter::ReportRdbCorruptedFault(eventInfo);
+}
+
+int SqliteStatement::InnerFinalize()
+{
+    if (stmt_ == nullptr) {
+        return E_OK;
+    }
+
+    int errCode = sqlite3_finalize(stmt_);
+    stmt_ = nullptr;
+    sql_ = "";
+    readOnly_ = false;
+    columnCount_ = -1;
+    numParameters_ = 0;
+    types_ = std::vector<int32_t>();
+    config_ = nullptr;
+    if (errCode != SQLITE_OK) {
+        LOG_ERROR("finalize ret is %{public}d, errno is %{public}d", errCode, errno);
+        return SQLiteError::ErrNo(errCode);
+    }
+    return E_OK;
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/sqlite_utils.cpp b/relational_store/frameworks/native/rdb/src/sqlite_utils.cpp
index 359f047692f2811deb9476feb000a80906dd685b..547004c6182f346254967931f2e76c35b58f2f5b 100644
--- a/relational_store/frameworks/native/rdb/src/sqlite_utils.cpp
+++ b/relational_store/frameworks/native/rdb/src/sqlite_utils.cpp
@@ -15,22 +15,23 @@
 #define LOG_TAG "SqliteUtils"
 #include "sqlite_utils.h"
 
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
 #include <algorithm>
 #include <cerrno>
 #include <climits>
 #include <cstdio>
 #include <cstring>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
+#include <fstream>
 
 #include "logger.h"
 #include "rdb_errno.h"
-
 #if !defined(WINDOWS_PLATFORM) && !defined(MAC_PLATFORM)
 #include "rdb_store_config.h"
 #endif
-
 namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
@@ -47,17 +48,23 @@ constexpr const char *SqliteUtils::ON_CONFLICT_CLAUSE[];
 int SqliteUtils::GetSqlStatementType(const std::string &sql)
 {
     /* the sql string length less than 3 can not be any type sql */
-    if (sql.length() < 3) {
+    auto alnum = std::find_if(sql.begin(), sql.end(), [](int ch) { return !std::isspace(ch) && !std::iscntrl(ch); });
+    if (alnum == sql.end()) {
+        return STATEMENT_ERROR;
+    }
+    auto pos = alnum - sql.begin();
+    /* 3 represents the number of prefix characters that need to be extracted and checked */
+    if (pos + 3 >= sql.length()) {
         return STATEMENT_ERROR;
     }
     /* analyze the sql type through first 3 character */
-    std::string prefixSql = StrToUpper(sql.substr(0, 3));
-    SqlType type = { prefixSql.c_str(), STATEMENT_OTHER};
-    auto it = std::lower_bound(SQL_TYPE_MAP, SQL_TYPE_MAP + TYPE_SIZE, type,
-        [](const SqlType& first, const SqlType& second) {
-            return strcmp(first.sql, second.sql) < 0;
-        });
-    if (it < SQL_TYPE_MAP + TYPE_SIZE) {
+    std::string prefixSql = StrToUpper(sql.substr(pos, 3));
+    SqlType type = { prefixSql.c_str(), STATEMENT_OTHER };
+    auto comp = [](const SqlType &first, const SqlType &second) {
+        return strcmp(first.sql, second.sql) < 0;
+    };
+    auto it = std::lower_bound(SQL_TYPE_MAP, SQL_TYPE_MAP + TYPE_SIZE, type, comp);
+    if (it < SQL_TYPE_MAP + TYPE_SIZE && !comp(type, *it)) {
         return it->type;
     }
     return STATEMENT_OTHER;
@@ -110,12 +117,42 @@ const char *SqliteUtils::GetConflictClause(int conflictResolution)
 
 bool SqliteUtils::DeleteFile(const std::string &filePath)
 {
-    return remove(filePath.c_str()) == 0;
+    auto ret = remove(filePath.c_str());
+    if (ret != 0) {
+        LOG_WARN("remove file failed errno %{public}d ret %{public}d %{public}s", errno, ret, filePath.c_str());
+        return false;
+    }
+    return true;
+}
+
+bool SqliteUtils::RenameFile(const std::string &srcFile, const std::string &destFile)
+{
+    auto ret = rename(srcFile.c_str(), destFile.c_str());
+    if (ret != 0) {
+        LOG_WARN("rename failed errno %{public}d ret %{public}d %{public}s -> %{public}s", errno, ret,
+            destFile.c_str(), srcFile.c_str());
+        return false;
+    }
+    return true;
 }
 
-int SqliteUtils::RenameFile(const std::string &srcFile, const std::string &destFile)
+bool SqliteUtils::CopyFile(const std::string &srcFile, const std::string &destFile)
 {
-    return rename(srcFile.c_str(), destFile.c_str());
+    std::ifstream src(srcFile.c_str(), std::ios::binary);
+    if (!src.is_open()) {
+        LOG_WARN("open srcFile failed errno %{public}d %{public}s", errno, srcFile.c_str());
+        return false;
+    }
+    std::ofstream dst(destFile.c_str(), std::ios::binary);
+    if (!dst.is_open()) {
+        src.close();
+        LOG_WARN("open destFile failed errno %{public}d %{public}s", errno, destFile.c_str());
+        return false;
+    }
+    dst << src.rdbuf();
+    src.close();
+    dst.close();
+    return true;
 }
 
 std::string SqliteUtils::Anonymous(const std::string &srcFile)
@@ -142,5 +179,57 @@ int SqliteUtils::GetFileSize(const std::string &fileName)
 
     return static_cast<int>(fileStat.st_size);
 }
+
+bool SqliteUtils::IsSlaveDbName(const std::string &fileName)
+{
+    std::string slaveSuffix("_slave.db");
+    if (fileName.size() < slaveSuffix.size()) {
+        return false;
+    }
+    size_t pos = fileName.rfind(slaveSuffix);
+    return (pos != std::string::npos) && (pos == fileName.size() - slaveSuffix.size());
+}
+
+bool SqliteUtils::TryAccessSlaveLock(const std::string &dbPath, bool isDelete, bool needCreate,
+    bool isSlaveFailure)
+{
+    std::string lockFile = isSlaveFailure ? dbPath + "-slaveFailure" : dbPath + "-syncInterrupt";
+    if (isDelete) {
+        if (std::remove(lockFile.c_str()) != 0) {
+            LOG_WARN("remove slave lock failed errno %{public}d %{public}s", errno, Anonymous(lockFile).c_str());
+            return false;
+        } else {
+            LOG_INFO("remove slave lock %{public}s", Anonymous(lockFile).c_str());
+            return true;
+        }
+    } else {
+        if (access(lockFile.c_str(), F_OK) == 0) {
+            return true;
+        }
+        if (needCreate) {
+            std::ofstream src(lockFile.c_str(), std::ios::binary);
+            if (src.is_open()) {
+                LOG_INFO("create slave lock %{public}s", Anonymous(lockFile).c_str());
+                src.close();
+                return true;
+            } else {
+                LOG_WARN("open slave lock failed errno %{public}d %{public}s", errno, Anonymous(lockFile).c_str());
+                return false;
+            }
+        }
+        return false;
+    }
+}
+
+std::string SqliteUtils::GetSlavePath(const std::string& name)
+{
+    std::string suffix(".db");
+    std::string slaveSuffix("_slave.db");
+    auto pos = name.rfind(suffix);
+    if (pos == std::string::npos || pos < name.length() - suffix.length()) {
+        return name + slaveSuffix;
+    }
+    return name.substr(0, pos) + slaveSuffix;
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/frameworks/native/rdb/src/step_result_set.cpp b/relational_store/frameworks/native/rdb/src/step_result_set.cpp
index 0f77f2a15cb59fdc7694d94e723ce3433438000c..6b67314f8206c243357a7987d33699689a6e0f80 100644
--- a/relational_store/frameworks/native/rdb/src/step_result_set.cpp
+++ b/relational_store/frameworks/native/rdb/src/step_result_set.cpp
@@ -20,7 +20,7 @@
 #include "logger.h"
 #include "rdb_errno.h"
 #include "sqlite3sym.h"
-#include "sqlite_connection_pool.h"
+#include "connection_pool.h"
 #include "sqlite_errno.h"
 #include "sqlite_statement.h"
 #include "sqlite_utils.h"
@@ -29,7 +29,7 @@
 namespace OHOS {
 namespace NativeRdb {
 using namespace OHOS::Rdb;
-StepResultSet::StepResultSet(std::shared_ptr<SqliteConnectionPool> pool, const std::string &sql,
+StepResultSet::StepResultSet(std::shared_ptr<ConnectionPool> pool, const std::string &sql,
     const std::vector<ValueObject> &args)
     : AbsResultSet(), sql_(sql), args_(std::move(args))
 {
@@ -42,8 +42,17 @@ StepResultSet::StepResultSet(std::shared_ptr<SqliteConnectionPool> pool, const s
     auto errCode = PrepareStep();
     if (errCode != E_OK) {
         LOG_ERROR("step resultset ret %{public}d", errCode);
+        return;
+    }
+    auto statement = GetStatement();
+    if (statement == nullptr) {
+        return;
+    }
+    std::tie(lastErr_, rowCount_) = statement->Count();
+    if (lastErr_ == E_NOT_SUPPORT && rowCount_ == Statement::INVALID_COUNT) {
+        isSupportCountRow_ = false;
+        lastErr_ = E_OK;
     }
-    rowCount_ = InitRowCount();
 }
 
 StepResultSet::~StepResultSet()
@@ -71,6 +80,7 @@ int StepResultSet::InitRowCount()
     } while (status == E_OK ||
              ((status == E_SQLITE_BUSY || status == E_SQLITE_LOCKED) && retry < STEP_QUERY_RETRY_MAX_TIMES));
     if (status != E_NO_MORE_ROWS) {
+        lastErr_ = status;
         count = NO_COUNT;
     }
     statement->Reset();
@@ -86,23 +96,27 @@ int StepResultSet::PrepareStep()
     }
 
     if (conn_ == nullptr) {
-        return E_ALREADY_CLOSED;
+        lastErr_ = E_ALREADY_CLOSED;
+        return lastErr_;
     }
 
     auto type = SqliteUtils::GetSqlStatementType(sql_);
     if (type == SqliteUtils::STATEMENT_ERROR) {
         LOG_ERROR("invalid sql_ %{public}s!", sql_.c_str());
-        return E_INVALID_ARGS;
+        lastErr_ = E_INVALID_ARGS;
+        return lastErr_;
     }
 
     auto [errCode, statement] = conn_->CreateStatement(sql_, conn_);
     if (statement == nullptr || errCode != E_OK) {
+        lastErr_ = errCode;
         return E_STATEMENT_NOT_PREPARED;
     }
 
     if (!statement->ReadOnly()) {
         LOG_ERROR("failed, %{public}s is not query sql!", SqliteUtils::Anonymous(sql_).c_str());
-        return E_NOT_SELECT;
+        lastErr_ = E_NOT_SELECT;
+        return lastErr_;
     }
 
     errCode = statement->Bind(args_);
@@ -110,12 +124,13 @@ int StepResultSet::PrepareStep()
         LOG_ERROR("Bind arg faild! Ret is %{public}d", errCode);
         statement->Reset();
         statement = nullptr;
-        return errCode;
+        lastErr_ = errCode;
+        return lastErr_;
     }
 
     sqliteStatement_ = std::move(statement);
     if (sqliteStatement_ == nullptr) {
-        LOG_ERROR("sqliteStatement_ is nullptr");
+        LOG_ERROR("sqliteStatement_ is nullptr.");
     }
     return E_OK;
 }
@@ -130,7 +145,7 @@ std::pair<int, std::vector<std::string>> StepResultSet::GetColumnNames()
 
     auto statement = GetStatement();
     if (statement == nullptr) {
-        LOG_ERROR("Statement is nullptr");
+        LOG_ERROR("Statement is nullptr.");
         return { E_ALREADY_CLOSED, {} };
     }
     auto colCount = statement->GetColumnCount();
@@ -152,13 +167,13 @@ int StepResultSet::GetColumnType(int columnIndex, ColumnType &columnType)
     if (isClosed_) {
         return E_ALREADY_CLOSED;
     }
-    if (rowPos_ == INIT_POS || IsEnded().second) {
+    if (rowPos_ == INIT_POS || ((isSupportCountRow_ || rowCount_ != Statement::INVALID_COUNT) && IsEnded().second)) {
         LOG_ERROR("query not executed.");
         return E_ROW_OUT_RANGE;
     }
     auto statement = GetStatement();
     if (statement == nullptr) {
-        LOG_ERROR("Statement is nullptr");
+        LOG_ERROR("Statement is nullptr.");
         return E_ALREADY_CLOSED;
     }
 
@@ -180,12 +195,16 @@ int StepResultSet::GoToRow(int position)
         return E_ALREADY_CLOSED;
     }
 
-    if (position >= rowCount_ || position < 0) {
+    if (isSupportCountRow_ && position >= rowCount_) {
         rowPos_ = (position >= rowCount_ && rowCount_ != 0) ? rowCount_ : rowPos_;
         LOG_ERROR("position[%{public}d] rowCount[%{public}d] rowPos_[%{public}d]!", position, rowCount_, rowPos_);
         return E_ROW_OUT_RANGE;
     }
 
+    if (position < 0) {
+        return E_ROW_OUT_RANGE;
+    }
+
     if (position < rowPos_) {
         Reset();
         return GoToRow(position);
@@ -206,7 +225,7 @@ int StepResultSet::GoToRow(int position)
 int StepResultSet::GoToNextRow()
 {
     if (isClosed_) {
-        LOG_ERROR("resultSet closed");
+        LOG_ERROR("resultSet closed.");
         return E_ALREADY_CLOSED;
     }
 
@@ -217,7 +236,7 @@ int StepResultSet::GoToNextRow()
 
     auto statement = GetStatement();
     if (statement == nullptr) {
-        LOG_ERROR("Statement is nullptr");
+        LOG_ERROR("Statement is nullptr.");
         return E_ALREADY_CLOSED;
     }
 
@@ -241,7 +260,12 @@ int StepResultSet::GoToNextRow()
         rowPos_++;
         return E_OK;
     } else if (errCode == E_NO_MORE_ROWS) {
-        rowPos_ = rowCount_ != 0 ? rowCount_ : rowPos_;
+        if (isSupportCountRow_ || rowCount_ != Statement::INVALID_COUNT) {
+            rowPos_ = rowCount_ != 0 ? rowCount_ : rowPos_;
+        } else {
+            ++rowPos_;
+            rowCount_ = rowPos_;
+        }
         return E_ROW_OUT_RANGE;
     } else {
         Reset();
@@ -263,6 +287,28 @@ int StepResultSet::Close()
     return E_OK;
 }
 
+int StepResultSet::GetRowCount(int &count)
+{
+    if (isSupportCountRow_ || rowCount_ != Statement::INVALID_COUNT) {
+        return AbsResultSet::GetRowCount(count);
+    }
+    int ret = E_OK;
+    while (ret == E_OK) {
+        ret = GoToNextRow();
+        if (ret == E_ROW_OUT_RANGE) {
+            rowCount_ = rowPos_;
+            break;
+        }
+        if (ret != E_OK) {
+            LOG_ERROR("Get row cnt err %{public}d, rowCount_ %{public}d, rowPos_ %{public}d", ret, rowCount_, rowPos_);
+            return ret;
+        }
+    };
+    count = rowCount_;
+    Reset();
+    return E_OK;
+}
+
 /**
  * Reset the statement
  */
@@ -289,14 +335,14 @@ int StepResultSet::GetSize(int columnIndex, size_t &size)
     if (isClosed_) {
         return E_ALREADY_CLOSED;
     }
-    if (rowPos_ == INIT_POS || IsEnded().second) {
+    if (rowPos_ == INIT_POS || ((isSupportCountRow_ || rowCount_ != Statement::INVALID_COUNT) && IsEnded().second)) {
         size = 0;
         return E_ROW_OUT_RANGE;
     }
 
     auto statement = GetStatement();
     if (statement == nullptr) {
-        LOG_ERROR("Statement is nullptr");
+        LOG_ERROR("Statement is nullptr.");
         return E_ALREADY_CLOSED;
     }
     auto errCode = E_ERROR;
@@ -318,7 +364,7 @@ int StepResultSet::GetValue(int32_t col, T &value)
 
 std::pair<int, ValueObject> StepResultSet::GetValueObject(int32_t col, size_t index)
 {
-    if (rowPos_ == INIT_POS || IsEnded().second) {
+    if (rowPos_ == INIT_POS || ((isSupportCountRow_ || rowCount_ != Statement::INVALID_COUNT) && IsEnded().second)) {
         return { E_ROW_OUT_RANGE, ValueObject() };
     }
     auto statement = GetStatement();
diff --git a/relational_store/frameworks/native/rdb_data_share_adapter/src/rdb_utils.cpp b/relational_store/frameworks/native/rdb_data_share_adapter/src/rdb_utils.cpp
index 1f6f43fedbd3b08494531538f57e4e77b69b6fc2..4439bfb03100ff68f8a9301d7a1ac3f5a5fa3b59 100644
--- a/relational_store/frameworks/native/rdb_data_share_adapter/src/rdb_utils.cpp
+++ b/relational_store/frameworks/native/rdb_data_share_adapter/src/rdb_utils.cpp
@@ -67,7 +67,7 @@ OHOS::NativeRdb::ValueObject RdbUtils::ToValueObject(const DataSharePredicatesOb
 std::shared_ptr<ResultSetBridge> RdbUtils::ToResultSetBridge(std::shared_ptr<ResultSet> resultSet)
 {
     if (resultSet == nullptr) {
-        LOG_ERROR("resultSet is null");
+        LOG_ERROR("resultSet is null.");
         return nullptr;
     }
     return std::make_shared<RdbResultSetBridge>(resultSet);
diff --git a/relational_store/interfaces/inner_api/rdb/BUILD.gn b/relational_store/interfaces/inner_api/rdb/BUILD.gn
index 6e582cea6aa4821412858eb981e879a264f1b635..63e0aad494e690e419f75b3db256b88da9aca21c 100644
--- a/relational_store/interfaces/inner_api/rdb/BUILD.gn
+++ b/relational_store/interfaces/inner_api/rdb/BUILD.gn
@@ -21,6 +21,7 @@ base_sources = [
   "${relational_store_native_path}/rdb/src/big_integer.cpp",
   "${relational_store_native_path}/rdb/src/cache_result_set.cpp",
   "${relational_store_native_path}/rdb/src/connection.cpp",
+  "${relational_store_native_path}/rdb/src/connection_pool.cpp",
   "${relational_store_native_path}/rdb/src/raw_data_parser.cpp",
   "${relational_store_native_path}/rdb/src/rdb_helper.cpp",
   "${relational_store_native_path}/rdb/src/rdb_local_db_observer.cpp",
@@ -32,7 +33,6 @@ base_sources = [
   "${relational_store_native_path}/rdb/src/rdb_store_impl.cpp",
   "${relational_store_native_path}/rdb/src/rdb_store_manager.cpp",
   "${relational_store_native_path}/rdb/src/sqlite_connection.cpp",
-  "${relational_store_native_path}/rdb/src/sqlite_connection_pool.cpp",
   "${relational_store_native_path}/rdb/src/sqlite_global_config.cpp",
   "${relational_store_native_path}/rdb/src/sqlite_sql_builder.cpp",
   "${relational_store_native_path}/rdb/src/sqlite_statement.cpp",
@@ -44,8 +44,10 @@ base_sources = [
 ]
 
 if (!is_ohos) {
-  base_sources +=
-      [ "${relational_store_mock_path}/frameworks/native/rdb/mock.cpp" ]
+  base_sources += [
+    "${relational_store_mock_path}/frameworks/native/rdb/mock.cpp",
+    "${relational_store_native_path}/rdb/mock/src/rdb_fault_hiview_reporter.cpp",
+  ]
 }
 
 if (is_ohos && !build_ohos_sdk) {
@@ -121,6 +123,7 @@ if (is_ohos && !build_ohos_sdk) {
     ldflags = [ "-Wl,--exclude-libs,ALL" ]
     cflags_cc = [ "-fvisibility=hidden" ]
     sources += [
+      "${relational_store_native_path}/dfx/src/rdb_fault_hiview_reporter.cpp",
       "${relational_store_native_path}/dfx/src/rdb_radar_reporter.cpp",
       "${relational_store_native_path}/rdb/src/abs_shared_result_set.cpp",
       "${relational_store_native_path}/rdb/src/delay_notify.cpp",
@@ -190,6 +193,7 @@ if (is_ohos && !build_ohos_sdk) {
     ldflags = [ "-Wl,--exclude-libs,ALL" ]
 
     sources += [
+      "${relational_store_native_path}/dfx/src/rdb_fault_hiview_reporter.cpp",
       "${relational_store_native_path}/dfx/src/rdb_radar_reporter.cpp",
       "${relational_store_native_path}/rdb/src/abs_shared_result_set.cpp",
       "${relational_store_native_path}/rdb/src/delay_notify.cpp",
@@ -242,6 +246,7 @@ if (is_ohos && !build_ohos_sdk) {
 
     include_dirs = [
       "${relational_store_mock_path}/frameworks/native/rdb",
+      "${relational_store_mock_path}/frameworks/native/win32",
       "mock/include",
       "${relational_store_common_path}/include",
       "${relational_store_native_path}/rdb/mock/include",
diff --git a/relational_store/interfaces/inner_api/rdb/include/abs_result_set.h b/relational_store/interfaces/inner_api/rdb/include/abs_result_set.h
index 6b24d63a90f591876e5c6e89109249f495f7496e..ffca7af314042f736d31adc1f1da6646b284a58e 100644
--- a/relational_store/interfaces/inner_api/rdb/include/abs_result_set.h
+++ b/relational_store/interfaces/inner_api/rdb/include/abs_result_set.h
@@ -331,6 +331,7 @@ protected:
 
     virtual std::pair<int, std::vector<std::string>> GetColumnNames();
     std::pair<int, bool> IsEnded();
+
     // The default position of the result set
     static const int INIT_POS = -1;
     static constexpr int NO_COUNT = -1;
@@ -343,6 +344,7 @@ protected:
     int rowPos_ = INIT_POS;
     bool isClosed_ = false;
     int rowCount_ = NO_COUNT;
+    int32_t lastErr_;
 private:
     int InitColumnNames();
 
diff --git a/relational_store/interfaces/inner_api/rdb/include/abs_shared_result_set.h b/relational_store/interfaces/inner_api/rdb/include/abs_shared_result_set.h
index 13064d810aa4aa592449efff08f6caaa3dd3dedf..c055c7cf1d9afd622cb7b2350920603cb4218150 100644
--- a/relational_store/interfaces/inner_api/rdb/include/abs_shared_result_set.h
+++ b/relational_store/interfaces/inner_api/rdb/include/abs_shared_result_set.h
@@ -150,6 +150,8 @@ private:
     // The SharedBlock owned by this AbsSharedResultSet
     std::shared_ptr<AppDataFwk::SharedBlock> sharedBlock_ = nullptr;
     std::string sharedBlockName_ = "defaultSharedBlockName";
+    // If the shared memory application fails for the first time, GetBlock() returns nullptr forever
+    bool lowMem_ = false;
 };
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/interfaces/inner_api/rdb/include/distributeddata_relational_store_ipc_interface_code.h b/relational_store/interfaces/inner_api/rdb/include/distributeddata_relational_store_ipc_interface_code.h
index c0cb9d003d5c203a94623894499440faa68a34ce..36a506f71fc19499007f9cf917b495512ba5fc49 100644
--- a/relational_store/interfaces/inner_api/rdb/include/distributeddata_relational_store_ipc_interface_code.h
+++ b/relational_store/interfaces/inner_api/rdb/include/distributeddata_relational_store_ipc_interface_code.h
@@ -79,11 +79,15 @@ enum class RdbServiceInterfaceCode {
     RDB_SERVICE_CMD_REGISTER_AUTOSYNC_PROGRESS_OBSERVER,
     RDB_SERVICE_CMD_UNREGISTER_AUTOSYNC_PROGRESS_OBSERVER,
     RDB_SERVICE_CMD_NOTIFY_DATA_CHANGE,
+    RDB_SERVICE_CMD_SET_SEARCHABLE,
     RDB_SERVICE_CMD_QUERY_SHARING_RESOURCE,
     RDB_SERVICE_CMD_DISABLE,
     RDB_SERVICE_CMD_ENABLE,
     RDB_SERVICE_CMD_BEFORE_OPEN,
     RDB_SERVICE_CMD_AFTER_OPEN,
+    RDB_SERVICE_CMD_GET_PASSWORD,
+    RDB_SERVICE_CMD_LOCK_CLOUD_CONTAINER,
+    RDB_SERVICE_CMD_UNLOCK_CLOUD_CONTAINER,
     RDB_SERVICE_CMD_MAX
 };
 } // namespace RelationalStore
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_common.h b/relational_store/interfaces/inner_api/rdb/include/rdb_common.h
index 3a2a457733e00409afd528cec6cd5f3bc5a1dde6..f2897ee3234a4fbb257ae1579813d3ecb1faed46 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_common.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_common.h
@@ -39,6 +39,20 @@ enum RebuiltType : uint32_t {
     REBUILT,
     REPAIRED,
 };
+
+enum SlaveStatus : uint32_t {
+    UNDEFINED,
+    DB_NOT_EXITS,
+    BACKING_UP,
+    BACKUP_INTERRUPT,
+    BACKUP_FINISHED,
+};
+
+enum ExchangeStrategy : uint32_t {
+    NOT_HANDLE,
+    BACKUP,
+    RESTORE,
+};
 } // namespace NativeRdb
 } // namespace OHOS
 
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_errno.h b/relational_store/interfaces/inner_api/rdb/include/rdb_errno.h
index f8c9b786e9c143093fa9ae2f91c300dc45484c3b..4ddd9bbd7b22fe674028bc6b088de9da5b7f2752 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_errno.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_errno.h
@@ -394,6 +394,21 @@ static constexpr int E_CONFIG_INVALID_CHANGE = (E_BASE + 70);
  * @brief Not get service.
  */
 static constexpr int E_SERVICE_NOT_FOUND = (E_BASE + 71);
+
+/**
+ * @brief Database schema has changed.
+ */
+static constexpr int E_SQLITE_SCHEMA = (E_BASE + 72);
+
+/**
+ * @brief Database backup was interrupted.
+ */
+static constexpr int E_BACKUP_INTERRUPT = (E_BASE + 0x49);
+
+/**
+ * @brief Backup interrupt operation is invalid
+ */
+static constexpr int E_INVALID_INTERRUPT = (E_BASE + 0x4a);
 } // namespace NativeRdb
 } // namespace OHOS
 
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_helper.h b/relational_store/interfaces/inner_api/rdb/include/rdb_helper.h
index 1061d2ac310fd16301b460ac9eb2e08e93936042..d16645e073c18817dacb4158fecc1937526cda92 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_helper.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_helper.h
@@ -52,6 +52,8 @@ public:
      */
     API_EXPORT static int DeleteRdbStore(const std::string &path);
 
+    API_EXPORT static int DeleteRdbStore(const RdbStoreConfig &config);
+
     /**
      * @brief Clear Cache.
      */
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_service.h b/relational_store/interfaces/inner_api/rdb/include/rdb_service.h
index 74c5c6e9dfa9fae2d793f4b6f6798a6bfd55997c..d728bf8b1927c61f39409402a11a32b8c618b78d 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_service.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_service.h
@@ -73,12 +73,20 @@ public:
     virtual std::pair<int32_t, std::shared_ptr<ResultSet>> QuerySharingResource(
         const RdbSyncerParam &param, const PredicatesMemo &predicates, const std::vector<std::string> &columns) = 0;
 
-    virtual int32_t NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData) = 0;
+    virtual int32_t NotifyDataChange(
+        const RdbSyncerParam &param, const RdbChangedData &rdbChangedData, const RdbNotifyConfig &rdbNotifyConfig) = 0;
+
+    virtual int32_t SetSearchable(const RdbSyncerParam& param, bool isSearchable) = 0;
 
     virtual int32_t Disable(const RdbSyncerParam &param) = 0;
 
     virtual int32_t Enable(const RdbSyncerParam &param) = 0;
 
+    virtual int32_t GetPassword(const RdbSyncerParam &param, std::vector<uint8_t> &password) = 0;
+
+    virtual std::pair<int32_t, uint32_t> LockCloudContainer(const RdbSyncerParam &param) = 0;
+
+    virtual int32_t UnlockCloudContainer(const RdbSyncerParam &param) = 0;
     inline static constexpr const char *SERVICE_NAME = "relational_store";
 };
 }
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_store.h b/relational_store/interfaces/inner_api/rdb/include/rdb_store.h
index ca5e9f276ce75e84e2727a80f2ee5348c4947b89..8f1b9c5a9ad54c607ac442da2e6d4ca9ce73ceca 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_store.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_store.h
@@ -563,11 +563,39 @@ public:
      */
     virtual int Notify(const std::string &event) = 0;
 
+    /**
+     * @brief Check the slave database is different from current database.
+     */
+    virtual bool IsSlaveDiffFromMaster() const
+    {
+        return false;
+    }
+
     virtual int32_t GetDbType() const
     {
         return DB_SQLITE;
     }
 
+    virtual std::pair<int32_t, uint32_t> LockCloudContainer()
+    {
+        return std::pair<int32_t, uint32_t>(E_OK, 0);
+    }
+
+    virtual int32_t UnlockCloudContainer()
+    {
+        return E_OK;
+    }
+
+    virtual int InterruptBackup()
+    {
+        return E_OK;
+    }
+
+    virtual int32_t GetBackupStatus() const
+    {
+        return SlaveStatus::UNDEFINED;
+    }
+
     class ModifyTime {
     public:
         ModifyTime() = default;
@@ -644,6 +672,16 @@ public:
     {
         return E_ERROR;
     }
+
+    /**
+     * @brief Set search enable or disable.
+     *
+     * @param isSearchable Indicates enable or disable.
+     */
+    virtual int SetSearchable(bool isSearchable)
+    {
+        return E_ERROR;
+    }
 };
 } // namespace OHOS::NativeRdb
 #endif
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_store_config.h b/relational_store/interfaces/inner_api/rdb/include/rdb_store_config.h
index cc4fc426a7b2d05d6d736e92410f24fa9204473d..6db88ec23985e46e36667afe6791353593189b82 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_store_config.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_store_config.h
@@ -22,6 +22,18 @@
 #include "rdb_visibility.h"
 
 namespace OHOS::NativeRdb {
+/**
+ * @brief Indicates the mode of detecting the database corruption.
+ */
+enum class IntegrityCheck {
+    /** Indicates the database does not perform integrity check.*/
+    NONE,
+    /** Indicates the database perform quick integrity check.*/
+    QUICK,
+    /** Indicates the database perform full integrity check.*/
+    FULL,
+};
+
 /**
  * @brief Indicates the type of the storage.
  */
@@ -110,6 +122,18 @@ enum class SecurityLevel : int32_t {
     LAST
 };
 
+/**
+ * @brief High availability mode.
+ */
+enum HAMode : int32_t {
+    /** Single database.*/
+    SINGLE = 0,
+    /** Real-time dual-write backup database.*/
+    MAIN_REPLICA,
+    /** Database for which real-time dual-write is enabled only after backup is manually triggered.*/
+    MANUAL_TRIGGER,
+};
+
 enum RoleType : uint32_t {
     /**
       * The user has administrative rights.
@@ -422,6 +446,8 @@ public:
      */
     void SetEncryptKey(const std::vector<uint8_t> &encryptKey);
 
+    void RestoreEncryptKey(const std::vector<uint8_t> &encryptKey) const;
+
     /**
      * @brief Obtains the encrypt key in this {@code StoreConfig} object.
      */
@@ -440,7 +466,7 @@ public:
     /**
      * @brief Obtains the encrypted key in this {@code StoreConfig} object.
      */
-    void Initialize() const;
+    int32_t Initialize() const;
 
     /**
      * @brief Sets the scalar function for the object.
@@ -529,13 +555,13 @@ public:
             }
         }
 
-        return this->path == config.path && this->storageMode == config.storageMode
-               && this->storageMode == config.storageMode && this->journalMode == config.journalMode
-               && this->syncMode == config.syncMode && this->databaseFileType == config.databaseFileType
-               && this->isEncrypt_ == config.isEncrypt_ && this->securityLevel == config.securityLevel
-               && this->journalSize == config.journalSize && this->pageSize == config.pageSize
-               && this->readConSize_ == config.readConSize_ && this->customDir_ == config.customDir_
-               && this->allowRebuilt_ == config.allowRebuilt_;
+        return this->path_ == config.path_ && this->storageMode_ == config.storageMode_ &&
+               this->journalMode_ == config.journalMode_ && this->syncMode_ == config.syncMode_ &&
+               this->databaseFileType == config.databaseFileType && this->isEncrypt_ == config.isEncrypt_ &&
+               this->securityLevel_ == config.securityLevel_ && this->journalSize_ == config.journalSize_ &&
+               this->pageSize_ == config.pageSize_ && this->readConSize_ == config.readConSize_ &&
+               this->customDir_ == config.customDir_ && this->allowRebuilt_ == config.allowRebuilt_ &&
+               this->pluginLibs_ == config.pluginLibs_ && this->haMode_ == config.haMode_;
     }
 
     /**
@@ -579,43 +605,72 @@ public:
 
     int32_t GetDBType() const;
 
+    void SetIntegrityCheck(IntegrityCheck checkMode);
+
+    IntegrityCheck GetIntegrityCheck() const;
+
+    void SetPluginLibs(const std::vector<std::string> &pluginLibs);
+
+    std::vector<std::string> GetPluginLibs() const;
+
+    void SetIter(int32_t iter) const;
+
+    int32_t GetIter() const;
+
+    int32_t GetHaMode() const;
+ 
+    void SetHaMode(int32_t haMode);
+
+    void SetNewEncryptKey(const std::vector<uint8_t> newEncryptKey);
+
+    void SetScalarFunctions(const std::map<std::string, ScalarFunctionInfo> functions);
+
+    void SetJournalMode(const std::string &journalMode);
+
+    void EnableRekey(bool enable);
+
 private:
     void ClearEncryptKey();
-    void GenerateEncryptedKey() const;
+    int32_t GenerateEncryptedKey() const;
 
-    bool readOnly = false;
+    bool readOnly_ = false;
     bool isEncrypt_ = false;
     bool isCreateNecessary_;
     bool isSearchable_ = false;
     bool autoCheck_;
     bool isAutoClean_ = true;
     bool isVector_ = false;
-    int32_t journalSize;
-    int32_t pageSize;
+    bool autoRekey_ = false;
+    mutable int32_t iter_ = 0;
+    int32_t journalSize_;
+    int32_t pageSize_;
     int32_t readConSize_ = 4;
     int32_t area_ = 0;
     int32_t writeTimeout_ = 2; // seconds
     int32_t readTimeout_ = 1; // seconds
     int32_t dbType_ = DB_SQLITE;
-    SecurityLevel securityLevel = SecurityLevel::LAST;
+    int32_t haMode_ = HAMode::SINGLE;
+    SecurityLevel securityLevel_ = SecurityLevel::LAST;
     RoleType role_ = OWNER;
     DistributedType distributedType_ = DistributedRdb::RdbDistributedType::RDB_DEVICE_COLLABORATION;
-    StorageMode storageMode;
-    std::string name;
-    std::string path;
-    std::string journalMode;
-    std::string syncMode;
+    StorageMode storageMode_;
+    IntegrityCheck checkType_ = IntegrityCheck::NONE;
+    std::string name_;
+    std::string path_;
+    std::string journalMode_;
+    std::string syncMode_;
     std::string databaseFileType;
     // distributed rdb
     std::string bundleName_;
     std::string moduleName_;
     std::string visitorDir_;
-    std::string encryptAlgo;
+    std::string encryptAlgo_;
     std::string dataGroupId_;
     std::string customDir_;
     mutable std::vector<uint8_t> encryptKey_{};
     mutable std::vector<uint8_t> newEncryptKey_{};
     std::map<std::string, ScalarFunctionInfo> customScalarFunctions;
+    std::vector<std::string> pluginLibs_{};
 
     static constexpr int MAX_TIMEOUT = 300; // seconds
     static constexpr int MIN_TIMEOUT = 1;   // seconds
diff --git a/relational_store/interfaces/inner_api/rdb/include/rdb_types.h b/relational_store/interfaces/inner_api/rdb/include/rdb_types.h
index 4432c4d2ae3b50896c7b817ac247c158fb56682e..39b91e6c947287f97b1996e30e96f302bf603b72 100644
--- a/relational_store/interfaces/inner_api/rdb/include/rdb_types.h
+++ b/relational_store/interfaces/inner_api/rdb/include/rdb_types.h
@@ -43,6 +43,7 @@ struct RdbSyncerParam {
     std::string customDir_;
     int32_t area_ = 0;
     int32_t level_ = 0;
+    int32_t haMode_ = 0;
     int32_t type_ = RDB_DEVICE_COLLABORATION;
     uint32_t roleType_ = 0;
     bool isEncrypt_ = false;
@@ -55,6 +56,11 @@ struct RdbSyncerParam {
     };
 };
 
+struct RdbNotifyConfig {
+    uint32_t delay_ = 0;
+    bool isFull_ = false;
+};
+
 enum SyncMode {
     PUSH,
     PULL,
@@ -265,6 +271,7 @@ struct Field {
     static constexpr const char *CURSOR_FIELD = "#_cursor";
     static constexpr const char *ORIGIN_FIELD = "#_origin";
     static constexpr const char *DELETED_FLAG_FIELD = "#_deleted_flag";
+    static constexpr const char *DATA_STATUS_FIELD = "#_data_status";
     static constexpr const char *OWNER_FIELD = "#_cloud_owner";
     static constexpr const char *PRIVILEGE_FIELD = "#_cloud_privilege";
     static constexpr const char *SHARING_RESOURCE_FIELD = "#_sharing_resource_field";
diff --git a/relational_store/interfaces/inner_api/rdb/include/value_object.h b/relational_store/interfaces/inner_api/rdb/include/value_object.h
index a977c7ab0bb81cd264fa24afc945257743390627..91d93fcff637416fc6d227fe66ba47dfd9c0cf4a 100644
--- a/relational_store/interfaces/inner_api/rdb/include/value_object.h
+++ b/relational_store/interfaces/inner_api/rdb/include/value_object.h
@@ -23,6 +23,11 @@
 #include "asset_value.h"
 #include "big_integer.h"
 #include "rdb_visibility.h"
+
+#ifdef Nil
+#undef Nil
+#endif
+
 namespace OHOS {
 namespace NativeRdb {
 /**
@@ -395,7 +400,7 @@ private:
         /** Indicates the ValueObject type is assets.*/
         "ASSETS",
         /** Indicates the ValueObject type is vecs.*/
-        "VECS",
+        "FLOATVECTOR",
         /** Indicates the ValueObject type is bigint.*/
         "UNLIMITED INT"
     };
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/abs_result_set.h b/relational_store/interfaces/inner_api/rdb/mock/include/abs_result_set.h
index 52dfe66b1f891cc120119913a5fbc5feba7a628b..561b70fb3b6c944b5e586a8d69d3b528e8ae1644 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/abs_result_set.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/abs_result_set.h
@@ -94,7 +94,7 @@ protected:
     };
     using Mutex = Lock<std::mutex>;
 
-    virtual std::pair<int, std::vector<std::string>> GetColumnNames() = 0;
+    virtual std::pair<int, std::vector<std::string>> GetColumnNames();
     std::pair<int, bool> IsEnded();
 
     // The default position of the result set
@@ -108,7 +108,8 @@ protected:
      */
     int rowPos_ = INIT_POS;
     bool isClosed_ = false;
-    int rowCount_;
+    int rowCount_ = NO_COUNT;
+    int32_t lastErr_;
 private:
     int InitColumnNames();
 
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_common.h b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_common.h
index 2a56478824fd6a9e44a88a88075f3e644776bf3d..cffbdf8e69d33120e693a44bd1cfcc854fb9e680 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_common.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_common.h
@@ -32,6 +32,20 @@ enum RebuiltType : uint32_t {
     REBUILT,
     REPAIRED,
 };
+
+enum SlaveStatus : uint32_t {
+    UNDEFINED,
+    DB_NOT_EXITS,
+    BACKING_UP,
+    BACKUP_INTERRUPT,
+    BACKUP_FINISHED,
+};
+
+enum ExchangeStrategy : uint32_t {
+    NOT_HANDLE,
+    BACKUP,
+    RESTORE,
+};
 }
 }
 
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_helper.h b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_helper.h
index a845d501a3fccd7e115781441ca6281f6bf1ac2e..2183de99fc99dd26dc953b86662113abf6e3f0ff 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_helper.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_helper.h
@@ -31,6 +31,7 @@ public:
     static std::shared_ptr<RdbStore> GetRdbStore(
         const RdbStoreConfig &config, int version, RdbOpenCallback &openCallback, int &errCode);
     static int DeleteRdbStore(const std::string &path);
+    static int DeleteRdbStore(const RdbStoreConfig &config);
     static void ClearCache();
 };
 } // namespace NativeRdb
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store.h b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store.h
index e89d3e2c47712518823282ef86a7864ec0b56b33..9b2e021c53bd7db8fa7456262cd4e959bfeac464 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store.h
@@ -105,6 +105,22 @@ public:
         const RdbStoreConfig &config, const std::string &attachName, int32_t waitTime = 2) = 0;
     virtual std::pair<int32_t, int32_t> Detach(const std::string &attachName, int32_t waitTime = 2) = 0;
     virtual int GetRebuilt(RebuiltType &rebuilt) = 0;
+    virtual int32_t GetDbType() const
+    {
+        return DB_SQLITE;
+    }
+    virtual int InterruptBackup()
+    {
+        return E_OK;
+    }
+    virtual bool IsSlaveDiffFromMaster() const
+    {
+        return false;
+    }
+    virtual int32_t GetBackupStatus() const
+    {
+        return SlaveStatus::UNDEFINED;
+    }
 };
 } // namespace OHOS::NativeRdb
 #endif
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store_config.h b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store_config.h
index 6a6b65f4c35acad1135cf020fd5efb1dbf20be7f..5b86cf10490c4ef4bbc949ff21c8efe3c11640fc 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store_config.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/rdb_store_config.h
@@ -22,6 +22,12 @@
 #include <functional>
 
 namespace OHOS::NativeRdb {
+enum class IntegrityCheck {
+    NONE,
+    QUICK,
+    FULL,
+};
+
 // indicates the type of the storage
 enum class StorageMode {
     MODE_MEMORY = 101,
@@ -58,6 +64,12 @@ enum class SecurityLevel : int32_t {
     LAST
 };
 
+enum HAMode : int32_t {
+    SINGLE = 0,
+    MAIN_REPLICA,
+    MANUAL_TRIGGER,
+};
+
 enum RoleType : uint32_t {
     OWNER = 0,
     VISITOR,
@@ -69,6 +81,11 @@ enum DBType : uint32_t {
     DB_BUTT
 };
 
+enum DistributedType {
+    RDB_DEVICE_COLLABORATION = 10,
+    RDB_DISTRIBUTED_TYPE_MAX
+};
+
 using ScalarFunction = std::function<std::string(const std::vector<std::string>&)>;
 
 struct ScalarFunctionInfo {
@@ -96,10 +113,6 @@ public:
     StorageMode GetStorageMode() const;
     std::string GetJournalMode() const;
     std::string GetSyncMode() const;
-    std::vector<uint8_t> GetEncryptKey() const;
-    std::vector<uint8_t> GetNewEncryptKey() const;
-    void Initialize() const;
-    void ChangeEncryptKey() const;
 
     bool IsReadOnly() const;
     bool IsMemoryRdb() const;
@@ -116,24 +129,18 @@ public:
     void SetReadOnly(bool readOnly);
     void SetStorageMode(StorageMode storageMode);
     void SetDatabaseFileType(DatabaseFileType type);
-    void SetEncryptKey(const std::vector<uint8_t> &encryptKey);
     void SetSecurityLevel(SecurityLevel secLevel);
-    void ClearEncryptKey();
-
+    void SetCreateNecessary(bool isCreateNecessary);
     // distributed rdb
     int SetBundleName(const std::string &bundleName);
     std::string GetBundleName() const;
+    int SetDistributedType(DistributedType type);
+    DistributedType GetDistributedType() const;
     void SetModuleName(const std::string& moduleName);
     std::string GetModuleName() const;
     void SetServiceName(const std::string& serviceName);
     void SetArea(int32_t area);
     int32_t GetArea() const;
-    void SetCreateNecessary(bool isCreateNecessary);
-    void SetAutoClean(bool isAutoClean);
-    bool GetAutoClean() const;
-    void SetIsVector(bool isVector);
-    bool IsVector() const;
-
     static std::string GetJournalModeValue(JournalMode journalMode);
     static std::string GetSyncModeValue(SyncMode syncMode);
     static std::string GetDatabaseFileTypeValue(DatabaseFileType databaseFileType);
@@ -147,27 +154,26 @@ public:
     void SetEncryptAlgo(const std::string &encryptAlgo);
     int GetReadConSize() const;
     void SetReadConSize(int readConSize);
+    void SetEncryptKey(const std::vector<uint8_t> &encryptKey);
+    void RestoreEncryptKey(const std::vector<uint8_t> &encryptKey) const;
+    std::vector<uint8_t> GetEncryptKey() const;
+    void ChangeEncryptKey() const;
+    std::vector<uint8_t> GetNewEncryptKey() const;
+    int32_t Initialize() const;
     void SetScalarFunction(const std::string &functionName, int argc, ScalarFunction function);
+
+    std::map<std::string, ScalarFunctionInfo> GetScalarFunctions() const;
     void SetDataGroupId(const std::string &dataGroupId);
     std::string GetDataGroupId() const;
+    void SetAutoClean(bool isAutoClean);
+    bool GetAutoClean() const;
+    void SetIsVector(bool isVector);
+    bool IsVector() const;
+
     void SetCustomDir(const std::string &customDir);
     std::string GetCustomDir() const;
-    std::map<std::string, ScalarFunctionInfo> GetScalarFunctions() const;
-    bool IsSearchable() const;
-    void SetSearchable(bool searchable);
-    int GetWriteTime() const;
-    void SetWriteTime(int timeout);
-    int GetReadTime() const;
-    void SetReadTime(int timeout);
     void SetVisitorDir(const std::string &visitorDir);
     std::string GetVisitorDir() const;
-    void SetRoleType(RoleType role);
-    uint32_t GetRoleType() const;
-    void SetAllowRebuild(bool allowRebuild);
-    bool GetAllowRebuild() const;
-    void SetDBType(int32_t dbType);
-    int32_t GetDBType() const;
-
     bool operator==(const RdbStoreConfig &config) const
     {
         if (this->customScalarFunctions.size() != config.customScalarFunctions.size()) {
@@ -192,55 +198,87 @@ public:
             }
         }
 
-        return this->path == config.path && this->storageMode == config.storageMode
-               && this->storageMode == config.storageMode && this->journalMode == config.journalMode
-               && this->syncMode == config.syncMode && this->databaseFileType == config.databaseFileType
-               && this->isEncrypt_ == config.isEncrypt_ && this->securityLevel == config.securityLevel
-               && this->journalSize == config.journalSize && this->pageSize == config.pageSize
-               && this->readConSize_ == config.readConSize_ && this->customDir_ == config.customDir_
-               && this->allowRebuilt_ == config.allowRebuilt_;
+        return this->path_ == config.path_ && this->storageMode_ == config.storageMode_ &&
+               this->journalMode_ == config.journalMode_ && this->syncMode_ == config.syncMode_ &&
+               this->databaseFileType == config.databaseFileType && this->isEncrypt_ == config.isEncrypt_ &&
+               this->securityLevel_ == config.securityLevel_ && this->journalSize_ == config.journalSize_ &&
+               this->pageSize_ == config.pageSize_ && this->readConSize_ == config.readConSize_ &&
+               this->customDir_ == config.customDir_ && this->allowRebuilt_ == config.allowRebuilt_ &&
+               this->pluginLibs_ == config.pluginLibs_ && this->haMode_ == config.haMode_;
     }
 
+    bool IsSearchable() const;
+    void SetSearchable(bool searchable);
+    int GetWriteTime() const;
+    void SetWriteTime(int timeout);
+    int GetReadTime() const;
+    void SetReadTime(int timeout);
+    void SetRoleType(RoleType role);
+    uint32_t GetRoleType() const;
+    void SetAllowRebuild(bool allowRebuild);
+    bool GetAllowRebuild() const;
+    void SetDBType(int32_t dbType);
+    int32_t GetDBType() const;
+    void SetIntegrityCheck(IntegrityCheck checkMode);
+    IntegrityCheck GetIntegrityCheck() const;
+    void SetPluginLibs(const std::vector<std::string> &pluginLibs);
+    std::vector<std::string> GetPluginLibs() const;
+    void SetIter(int32_t iter) const;
+    int32_t GetIter() const;
+    int32_t GetHaMode() const;
+    void SetHaMode(int32_t haMode);
+    void SetNewEncryptKey(const std::vector<uint8_t> newEncryptKey);
+    void SetScalarFunctions(const std::map<std::string, ScalarFunctionInfo> functions);
+    void SetJournalMode(const std::string &journalMode);
+
+    void EnableRekey(bool enable);
+
 private:
-    void GenerateEncryptedKey() const;
+    void ClearEncryptKey();
+    int32_t GenerateEncryptedKey() const;
 
-    bool readOnly = false;
+    bool readOnly_ = false;
     bool isEncrypt_ = false;
     bool isCreateNecessary_;
     bool isSearchable_ = false;
     bool autoCheck_;
     bool isAutoClean_ = true;
     bool isVector_ = false;
-    int32_t journalSize;
-    int32_t pageSize;
+    bool autoRekey_ = false;
+    mutable int32_t iter_ = 0;
+    int32_t journalSize_;
+    int32_t pageSize_;
     int32_t readConSize_ = 4;
     int32_t area_ = 0;
     int32_t writeTimeout_ = 2; // seconds
     int32_t readTimeout_ = 1; // seconds
     int32_t dbType_ = DB_SQLITE;
-    SecurityLevel securityLevel = SecurityLevel::LAST;
+    int32_t haMode_ = HAMode::SINGLE;
+    SecurityLevel securityLevel_ = SecurityLevel::LAST;
     RoleType role_ = OWNER;
-    StorageMode storageMode;
-    std::string name;
-    std::string path;
-    std::string journalMode;
-    std::string syncMode;
+    DistributedType distributedType_ = DistributedType::RDB_DEVICE_COLLABORATION;
+    StorageMode storageMode_;
+    IntegrityCheck checkType_ = IntegrityCheck::NONE;
+    std::string name_;
+    std::string path_;
+    std::string journalMode_;
+    std::string syncMode_;
     std::string databaseFileType;
     // distributed rdb
     std::string bundleName_;
     std::string moduleName_;
     std::string visitorDir_;
-    std::string encryptAlgo;
+    std::string encryptAlgo_;
     std::string dataGroupId_;
     std::string customDir_;
     mutable std::vector<uint8_t> encryptKey_{};
     mutable std::vector<uint8_t> newEncryptKey_{};
     std::map<std::string, ScalarFunctionInfo> customScalarFunctions;
+    std::vector<std::string> pluginLibs_{};
 
     static constexpr int MAX_TIMEOUT = 300; // seconds
     static constexpr int MIN_TIMEOUT = 1;   // seconds
     bool allowRebuilt_ = false;
 };
 } // namespace OHOS::NativeRdb
-
 #endif
\ No newline at end of file
diff --git a/relational_store/interfaces/inner_api/rdb/mock/include/value_object.h b/relational_store/interfaces/inner_api/rdb/mock/include/value_object.h
index 5c95513f180114e033a507d32668b695b3f98281..cddf8464f3304b0c18877169225dac30714a06c3 100644
--- a/relational_store/interfaces/inner_api/rdb/mock/include/value_object.h
+++ b/relational_store/interfaces/inner_api/rdb/mock/include/value_object.h
@@ -346,7 +346,7 @@ private:
         /** Indicates the ValueObject type is assets.*/
         "ASSETS",
         /** Indicates the ValueObject type is vecs.*/
-        "VECS",
+        "FLOATVECTOR",
         /** Indicates the ValueObject type is bigint.*/
         "UNLIMITED INT"
     };
diff --git a/relational_store/interfaces/ndk/include/relational_store.h b/relational_store/interfaces/ndk/include/relational_store.h
index 3dc9be36ab53808c796735d1786734c1a2a431a7..6c6290543f9cbc55d85a154f204042e67ea333cf 100644
--- a/relational_store/interfaces/ndk/include/relational_store.h
+++ b/relational_store/interfaces/ndk/include/relational_store.h
@@ -92,6 +92,12 @@ typedef enum Rdb_SecurityArea {
      * @brief Security Area 4.
      */
     RDB_SECURITY_AREA_EL4,
+    /**
+     * @brief Security Area 5.
+     *
+     * @since 12
+     */
+    RDB_SECURITY_AREA_EL5,
 } Rdb_SecurityArea;
 
 /**
diff --git a/relational_store/interfaces/ndk/src/relational_asset.cpp b/relational_store/interfaces/ndk/src/relational_asset.cpp
index 686ee3ae6dcd52eb127634ef05da807cfe198f80..845ddbf6e8fba1efd92dc38a1047a614a539bd4c 100644
--- a/relational_store/interfaces/ndk/src/relational_asset.cpp
+++ b/relational_store/interfaces/ndk/src/relational_asset.cpp
@@ -160,7 +160,7 @@ int OH_Data_Asset_GetCreateTime(Data_Asset *asset, int64_t *createTime)
     char *endPtr;
     *createTime = strtol(asset->asset_.createTime.c_str(), &endPtr, ASSET_TRANSFORM_BASE);
     if (*endPtr != '\0') {
-        LOG_ERROR("GetCreateTime failed");
+        LOG_ERROR("GetCreateTime failed.");
         return OH_Rdb_ErrCode::RDB_ERR;
     }
     return OH_Rdb_ErrCode::RDB_OK;
@@ -174,7 +174,7 @@ int OH_Data_Asset_GetModifyTime(Data_Asset *asset, int64_t *modifyTime)
     char *endPtr;
     *modifyTime = strtol(asset->asset_.modifyTime.c_str(), &endPtr, ASSET_TRANSFORM_BASE);
     if (*endPtr != '\0') {
-        LOG_ERROR("GetModifyTime failed");
+        LOG_ERROR("GetModifyTime failed.");
         return OH_Rdb_ErrCode::RDB_ERR;
     }
     return OH_Rdb_ErrCode::RDB_OK;
@@ -188,7 +188,7 @@ int OH_Data_Asset_GetSize(Data_Asset *asset, size_t *size)
     char *endPtr;
     *size = strtol(asset->asset_.size.c_str(), &endPtr, ASSET_TRANSFORM_BASE);
     if (*endPtr != '\0') {
-        LOG_ERROR("GetModifyTime failed");
+        LOG_ERROR("GetModifyTime failed.");
         return OH_Rdb_ErrCode::RDB_ERR;
     }
     return OH_Rdb_ErrCode::RDB_OK;
diff --git a/relational_store/interfaces/ndk/src/relational_store.cpp b/relational_store/interfaces/ndk/src/relational_store.cpp
index ed1e7d949971ca97df24b2ead3439fa44b001569..4e1c8307c848162bd4b63e7f0e38a7dc2cd9cf7c 100644
--- a/relational_store/interfaces/ndk/src/relational_store.cpp
+++ b/relational_store/interfaces/ndk/src/relational_store.cpp
@@ -68,13 +68,13 @@ int RelationalStore::SubscribeAutoSyncProgress(const Rdb_ProgressObserver *callb
         return *observer == callback;
     });
     if (result) {
-        LOG_INFO("duplicate subscribe");
+        LOG_INFO("duplicate subscribe.");
         return OH_Rdb_ErrCode::RDB_OK;
     }
     auto obs = std::make_shared<NDKDetailProgressObserver>(callback);
     int errCode = store_->RegisterAutoSyncCallback(obs);
     if (errCode == NativeRdb::E_OK) {
-        LOG_ERROR("subscribe failed");
+        LOG_ERROR("subscribe failed.");
         return ConvertorErrorCode::NativeToNdk(errCode);
     }
     callbacks_.push_back(std::move(obs));
@@ -92,11 +92,11 @@ int RelationalStore::UnsubscribeAutoSyncProgress(const Rdb_ProgressObserver *cal
 
         int errCode = store_->UnregisterAutoSyncCallback(*it);
         if (errCode != NativeRdb::E_OK) {
-            LOG_ERROR("unsubscribe failed");
+            LOG_ERROR("unsubscribe failed.");
             return ConvertorErrorCode::NativeToNdk(errCode);
         }
         it = callbacks_.erase(it);
-        LOG_DEBUG("progress unsubscribe success");
+        LOG_DEBUG("progress unsubscribe success.");
     }
     return OH_Rdb_ErrCode::RDB_OK;
 }
@@ -438,7 +438,7 @@ OH_Cursor *OH_Rdb_FindModifyTime(OH_Rdb_Store *store, const char *tableName, con
 int OH_Rdb_Subscribe(OH_Rdb_Store *store, Rdb_SubscribeType type, const Rdb_DataObserver *observer)
 {
     auto rdbStore = GetRelationalStore(store);
-    if (rdbStore == nullptr) {
+    if (rdbStore == nullptr || observer == nullptr) {
         return OH_Rdb_ErrCode::RDB_E_INVALID_ARGS;
     }
     return rdbStore->DoSubScribe(type, observer);
@@ -467,7 +467,7 @@ int RelationalStore::DoSubScribe(Rdb_SubscribeType type, const Rdb_DataObserver
                                   return *item.get() == observer;
                               });
     if (result) {
-        LOG_INFO("duplicate subscribe");
+        LOG_INFO("duplicate subscribe.");
         return OH_Rdb_ErrCode::RDB_OK;
     }
     auto subscribeOption = SubscribeOption{ .mode = NDKUtils::GetSubscribeType(type), .event = "data_change" };
@@ -475,7 +475,7 @@ int RelationalStore::DoSubScribe(Rdb_SubscribeType type, const Rdb_DataObserver
     int subscribeResult = (type == RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS) ?
         store_->SubscribeObserver(subscribeOption, ndkObserver) : store_->Subscribe(subscribeOption, ndkObserver.get());
     if (subscribeResult != OHOS::NativeRdb::E_OK) {
-        LOG_ERROR("subscribe failed");
+        LOG_ERROR("subscribe failed.");
     } else {
         dataObservers_[type].emplace_back(std::move(ndkObserver));
     }
@@ -497,11 +497,11 @@ int RelationalStore::DoUnsubScribe(Rdb_SubscribeType type, const Rdb_DataObserve
         int errCode = (type == RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS) ?
             store_->UnsubscribeObserver(subscribeOption, *it) : store_->UnSubscribe(subscribeOption, it->get());
         if (errCode != NativeRdb::E_OK) {
-            LOG_ERROR("unsubscribe failed");
+            LOG_ERROR("unsubscribe failed.");
             return ConvertorErrorCode::NativeToNdk(errCode);
         }
         it = dataObservers_[type].erase(it);
-        LOG_DEBUG("data observer unsubscribe success");
+        LOG_DEBUG("data observer unsubscribe success.");
     }
     return OH_Rdb_ErrCode::RDB_OK;
 }
@@ -626,11 +626,11 @@ int OH_Rdb_CloudSync(OH_Rdb_Store *store, Rdb_SyncMode mode, const char *tables[
 
     auto progressCallback = [cxt = (*observer).context, cb = (*observer).callback](Details &&details) {
         if (details.size() > 1) {
-            LOG_ERROR("Not support edge to edge detail notify");
+            LOG_ERROR("Not support edge to edge detail notify.");
             return;
         }
         if (details.empty()) {
-            LOG_ERROR("No device or cloud synced");
+            LOG_ERROR("No device or cloud synced.");
             return;
         }
         for (auto &[device, detail] : details) {
@@ -773,7 +773,7 @@ void NDKStoreObserver::OnChange(const Origin &origin, const RdbStoreObserver::Pr
 {
     uint32_t count = changeInfo.size();
     if (count == 0) {
-        LOG_ERROR("No any infos");
+        LOG_ERROR("No any infos.");
         return;
     }
 
@@ -784,7 +784,7 @@ void NDKStoreObserver::OnChange(const Origin &origin, const RdbStoreObserver::Pr
         std::unique_ptr<uint8_t[]> buffer = std::make_unique<uint8_t[]>(size);
         Rdb_ChangeInfo **infos = (Rdb_ChangeInfo **)(buffer.get());
         if (infos == nullptr) {
-            LOG_ERROR("Failed to allocate memory for Rdb_ChangeInfo");
+            LOG_ERROR("Failed to allocate memory for Rdb_ChangeInfo.");
             return;
         }
 
@@ -839,7 +839,7 @@ void NDKStoreObserver::ConvertKeyInfoData(Rdb_KeyInfo::Rdb_KeyData *keyInfoData,
         } else if (auto val = std::get_if<std::string>(&key)) {
             keyInfoData[i].text = val->c_str();
         } else {
-            LOG_ERROR("Not support the data type");
+            LOG_ERROR("Not support the data type.");
             return;
         }
     }
diff --git a/relational_store/rdbmock/frameworks/native/rdb/concurrent_map.h b/relational_store/rdbmock/frameworks/native/rdb/concurrent_map.h
index 91332770c3bc0afa5be2b9600bdb415baadf368e..82aa6b05d81cba7876a3536479eb4fef1dd76252 100644
--- a/relational_store/rdbmock/frameworks/native/rdb/concurrent_map.h
+++ b/relational_store/rdbmock/frameworks/native/rdb/concurrent_map.h
@@ -181,12 +181,6 @@ public:
         return count;
     }
 
-    mapped_type &operator[](const key_type &key) noexcept
-    {
-        std::lock_guard<decltype(mutex_)> lock(mutex_);
-        return entries_[key];
-    }
-
     void ForEach(const std::function<bool(const key_type &, mapped_type &)> &action)
     {
         if (action == nullptr) {
diff --git a/relational_store/rdbmock/frameworks/native/rdb/file_ex.h b/relational_store/rdbmock/frameworks/native/rdb/file_ex.h
index 59e5112e9d7e3ec7a8ba4bbeb40ff9b2f45aa298..36dee10bed1bdbf78661fbf2c5d25a5b26c05974 100644
--- a/relational_store/rdbmock/frameworks/native/rdb/file_ex.h
+++ b/relational_store/rdbmock/frameworks/native/rdb/file_ex.h
@@ -29,5 +29,19 @@ static bool LoadBufferFromFile(const std::string& filePath, std::vector<char>& c
     return true;
 }
 
+#ifndef LOCK_EX
+#define LOCK_EX 0
+#endif
+
+#ifndef LOCK_UN
+#define LOCK_UN 1
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define flock(a, b) 0
+#ifdef __cplusplus
+}
+#endif
 #endif  /* MOCK_UTILS_BASE_FILE_EX_H */
 
diff --git a/relational_store/rdbmock/frameworks/native/rdb/mock.h b/relational_store/rdbmock/frameworks/native/rdb/mock.h
index 11d4bc150349ee9f619cb0cf73b3192b2db3d796..f5023a87516f8119d2181546a588c5b804dc827e 100644
--- a/relational_store/rdbmock/frameworks/native/rdb/mock.h
+++ b/relational_store/rdbmock/frameworks/native/rdb/mock.h
@@ -16,12 +16,12 @@
 #ifndef DISTRIBUTEDDATAMGR_RELATIONAL_STORE_MOCK_H
 #define DISTRIBUTEDDATAMGR_RELATIONAL_STORE_MOCK_H
 
-# include <iostream>
+#include <iostream>
 
 namespace OHOS {
 namespace NativeRdb {
 __attribute__((visibility("default"))) int gettid();
 }
-}
+} // namespace OHOS
 
 #endif //DISTRIBUTEDDATAMGR_RELATIONAL_STORE_MOCK_H
diff --git a/relational_store/rdbmock/frameworks/native/win32/sys/ioctl.h b/relational_store/rdbmock/frameworks/native/win32/sys/ioctl.h
new file mode 100644
index 0000000000000000000000000000000000000000..90e631448cb6274327ef29f03d8f8818ecb09088
--- /dev/null
+++ b/relational_store/rdbmock/frameworks/native/win32/sys/ioctl.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MOCK_SYS_IOCTL_H
+#define MOCK_SYS_IOCTL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _IOC(a, b, c, d) (((a) << 30) | ((b) << 8) | (c) | ((d) << 16))
+#define _IOC_READ 2U
+#define _IOR(a, b, c) _IOC(_IOC_READ, (a), (b), sizeof(c))
+
+static int ioctl(int fd, int req, unsigned int *flags)
+{
+    return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif //MOCK_SYS_IOCTL_H
\ No newline at end of file
diff --git a/relational_store/relational_store.gni b/relational_store/relational_store.gni
index 7562c03943a719db63abb86be0fb447b644bee34..69a033507634ae8585d8c8630100266dbb0dedcc 100644
--- a/relational_store/relational_store.gni
+++ b/relational_store/relational_store.gni
@@ -53,3 +53,7 @@ distributedfile_path =
 sdk_c_path = "//interface/sdk_c/distributeddatamgr"
 
 plugins_path = "//plugins"
+
+foundation_systemabilitymgr_path = "//foundation/systemabilitymgr/"
+
+base_security_dataclassification_path = "//base/security/dataclassification"
diff --git a/relational_store/test/js/rdb/unittest/src/RdbstorePredicatesJsunit.test.js b/relational_store/test/js/rdb/unittest/src/RdbstorePredicatesJsunit.test.js
index f1abb93fb443c71eb46b130de419ad2ada38f8ae..cb26f471cfb1d76712f76b1c0b951ec6179323bf 100644
--- a/relational_store/test/js/rdb/unittest/src/RdbstorePredicatesJsunit.test.js
+++ b/relational_store/test/js/rdb/unittest/src/RdbstorePredicatesJsunit.test.js
@@ -2453,6 +2453,23 @@ describe('rdbPredicatesTest', function () {
         console.log(TAG + "************* testIn0004 end *************");
     })
 
+        /**
+     * @tc.name predicates in normal test
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0194
+     * @tc.desc predicates in normal test
+     */
+    it('testIn0005', 0, async function (done) {
+        console.log(TAG + "************* testIn0005 start *************");
+        var values = [];
+        let predicates = new dataRdb.RdbPredicates("AllDataType");
+        predicates.in("doubleValue", values);
+        let result = await rdbStore.query(predicates);
+        expect(3).assertEqual(result.rowCount);
+        result.close()
+        done();
+        console.log(TAG + "************* testIn0005 end *************");
+    })
+
     /**
      * @tc.name testNotIn0001
      * @tc.number I4JWCV
@@ -2504,6 +2521,23 @@ describe('rdbPredicatesTest', function () {
         console.log(TAG + "************* testNotIn0003 end *************");
     })
 
+    /**
+     * @tc.name testNotIn0004
+     * @tc.number I4JWCV
+     * @tc.desc the min and max value test with notin.
+     */
+    it('testNotIn0004', 0, async function (done) {
+        console.log(TAG + "************* testNotIn0004 start *************");
+        var values = [];
+        let predicates = new dataRdb.RdbPredicates("AllDataType");
+        predicates.notIn("integerValue", values);
+        let result = await rdbStore.query(predicates);
+        expect(3).assertEqual(result.rowCount);
+        result.close();
+        done();
+        console.log(TAG + "************* testNotIn0004 end *************");
+    })
+
     /**
      * @tc.name predicates constructor test
      * @tc.number SUB_DDM_AppDataFWK_JSRDB_Predicates_0200
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreAssetResultSetJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreAssetResultSetJsunit.test.js
index 2e5630e23bb4a279c3f87c0617303cda2fd26991..5ee705a9f1f3560b1de94db36aa8c955d5dca8ac 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreAssetResultSetJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreAssetResultSetJsunit.test.js
@@ -135,6 +135,86 @@ describe('rdbAssetResultSetTest', function () {
         console.log(TAG + "createStatusTest data end");
     }
 
+    /**
+     * @tc.name Insert duplicate assets
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_DuplicateAsset_0010
+     * @tc.desc Insert duplicate assets by insert
+     */
+    it('testInsertDuplicateAssets0001', 0, async function (done) {
+        console.log(TAG + "************* testInsertDuplicateAssets0001 start *************");
+        const assets = [asset3, asset3];
+        let valuesBucket = {
+            "data1": asset1,
+            "data2": asset2,
+            "data3": assets,
+        }
+        try {
+            await rdbStore.insert("test", valuesBucket)
+            expect().assertFail();
+        } catch(e) {
+            console.log("insert failed, err: code=" + e.code + " message=" + e.message)
+            expect(e.code == 401).assertTrue();
+        }
+        done();
+        console.log(TAG + "************* testInsertDuplicateAssets0001 end *************");
+    })
+
+    /**
+     * @tc.name batchInsert duplicate assets
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_DuplicateAsset_0020
+     * @tc.desc Insert duplicate assets by batchInsert
+     */
+    it('testBatchInsertDuplicateAssets0001', 0, async function (done) {
+        console.log(TAG + "************* testBatchInsertDuplicateAssets0001 start *************");
+        let array = new Array();
+        const assets1 = [asset3];
+        let valuesBucket1 = {
+            "data1": asset1,
+            "data2": asset2,
+            "data3": assets1,
+        }
+        array.push(valuesBucket1);
+        const assets2 = [asset3, asset1, asset3];
+        let valuesBucket2 = {
+            "data1": asset2,
+            "data2": asset1,
+            "data3": assets2,
+        }
+        array.push(valuesBucket2);
+        try {
+            await rdbStore.batchInsert("test", array)
+            expect().assertFail();
+        } catch(e) {
+            console.log("batchInsert failed, err: code=" + e.code + " message=" + e.message)
+            expect(e.code == 401).assertTrue();
+        }
+        done();
+        console.log(TAG + "************* testBatchInsertDuplicateAssets0001 end *************");
+    })
+
+    /**
+     * @tc.name execute sql to insert duplicate assets
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_DuplicateAsset_0030
+     * @tc.desc Insert duplicate assets by executeSql
+     */
+    it('testExecuteSqlInsertDuplicateAssets0001', 0, async function (done) {
+        console.log(TAG + "************* testExecuteSqlInsertDuplicateAssets0001 start *************");
+        const assets = [asset2, asset3, asset3, asset2];
+        let array = new Array();
+        array.push(asset1);
+        array.push(asset2);
+        array.push(assets);
+        try {
+            await rdbStore.executeSql("insert into test (data1, data2, data3) values (?,?,?)", array)
+            expect().assertFail();
+        } catch(e) {
+            console.log("executeSql failed, err: code=" + e.code + " message=" + e.message)
+            expect(e.code == 401).assertTrue();
+        }
+        done();
+        console.log(TAG + "************* testExecuteSqlInsertDuplicateAssets0001 end *************");
+    })
+
     /**
      * @tc.name resultSet getAsset normal test with batchInsert
      * @tc.number SUB_DDM_AppDataFWK_JSRDB_ResultSet_0010
@@ -750,4 +830,251 @@ describe('rdbAssetResultSetTest', function () {
         done();
         console.log(TAG + "************* testGetAssetsUpdate2 end *************");
     })
+
+    /**
+     * @tc.name update asset
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateAsset_0010
+     * @tc.desc The original Asset is Null, Update Asset
+     */
+    it('testUpdateAsset0001', 0, async function (done) {
+        console.log(TAG + "************* testUpdateAsset0001 start *************");
+        let valuesBucket = {
+            "data1": null
+        }
+
+        await rdbStore.insert("test", valuesBucket)
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates)
+        let id;
+        try {
+            expect(true).assertEqual(resultSet.goToFirstRow())
+            id = resultSet.getLong(resultSet.getColumnIndex("id"))
+        } catch (e) {
+            console.log(TAG + "insert throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        const asset5 =  {
+            name: "name5",
+            uri: "uri5",
+            createTime: "createTime5",
+            modifyTime: "modifyTime5",
+            size: "size5",
+            path: "path5",
+            status: data_relationalStore.AssetStatus.ASSET_UPDATE,
+        }
+        valuesBucket = {
+            "data1" : asset5,
+        }
+        predicates.equalTo("id", id);
+        await rdbStore.update(valuesBucket, predicates);
+        console.log(TAG + "************* testUpdateAsset0001 update success *************");
+        let predicates1 = await new data_relationalStore.RdbPredicates("test");
+        let resultSet1 = await rdbStore.query(predicates1);
+        console.log(TAG + "************* testUpdateAsset0001 query success *************");
+        try {
+            expect(true).assertEqual(resultSet1.goToFirstRow())
+            let asset = resultSet1.getAsset(resultSet1.getColumnIndex("data1"))
+            expect("name5").assertEqual(asset.name);
+            expect("uri5").assertEqual(asset.uri);
+            expect("createTime5").assertEqual(asset.createTime);
+            expect("modifyTime5").assertEqual(asset.modifyTime);
+            expect("size5").assertEqual(asset.size);
+            expect("path5").assertEqual(asset.path);
+            expect(data_relationalStore.AssetStatus.ASSET_INSERT).assertEqual(asset.status);
+        } catch (e) {
+            console.log(TAG + "update throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        resultSet.close();
+        expect(true).assertEqual(resultSet.isClosed)
+        resultSet1.close();
+        expect(true).assertEqual(resultSet1.isClosed)
+        resultSet = null
+        resultSet1 = null
+        done();
+        console.log(TAG + "************* testUpdateAsset0001 end *************");
+    })
+
+    /**
+     * @tc.name update asset
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateAsset_0020
+     * @tc.desc Asset name inconsistent, the update is not successful
+     */
+    it('testUpdateAsset0002', 0, async function (done) {
+        console.log(TAG + "************* testUpdateAsset0002 start *************");
+        let valuesBucket = {
+            "data1": asset1
+        }
+
+        await rdbStore.insert("test", valuesBucket)
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates)
+        let id;
+        try {
+            expect(true).assertEqual(resultSet.goToFirstRow())
+            id = resultSet.getLong(resultSet.getColumnIndex("id"))
+        } catch (e) {
+            console.log(TAG + "insert throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        const asset5 =  {
+            name: "name5",
+            uri: "uri5",
+            createTime: "createTime5",
+            modifyTime: "modifyTime5",
+            size: "size5",
+            path: "path5",
+            status: data_relationalStore.AssetStatus.ASSET_UPDATE,
+        }
+        valuesBucket = {
+            "data1" : asset5,
+        }
+        predicates.equalTo("id", id);
+        await rdbStore.update(valuesBucket, predicates);
+        console.log(TAG + "************* testUpdateAsset0002 update success *************");
+        let predicates1 = await new data_relationalStore.RdbPredicates("test");
+        let resultSet1 = await rdbStore.query(predicates1);
+        console.log(TAG + "************* testUpdateAsset0002 query success *************");
+        try {
+            expect(true).assertEqual(resultSet1.goToFirstRow())
+            let asset = resultSet1.getAsset(resultSet1.getColumnIndex("data1"))
+            expect("uri1").assertEqual(asset.uri);
+            expect("createTime1").assertEqual(asset.createTime);
+            expect("modifyTime1").assertEqual(asset.modifyTime);
+            expect("size1").assertEqual(asset.size);
+            expect("path1").assertEqual(asset.path);
+            expect(data_relationalStore.AssetStatus.ASSET_INSERT).assertEqual(asset.status);
+        } catch (e) {
+            console.log(TAG + "update throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        resultSet.close();
+        expect(true).assertEqual(resultSet.isClosed)
+        resultSet1.close();
+        expect(true).assertEqual(resultSet1.isClosed)
+        resultSet = null
+        resultSet1 = null
+        done();
+        console.log(TAG + "************* testUpdateAsset0002 end *************");
+    })
+
+    /**
+     * @tc.name update asset
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateAsset_0030
+     * @tc.desc Update Asset normally, and the updated Asset.status should be ASSET_DELETE
+     */
+    it('testUpdateAsset0003', 0, async function (done) {
+        console.log(TAG + "************* testUpdateAsset0004 start *************");
+        let valuesBucket = {
+            "data1": asset1
+        }
+
+        await rdbStore.insert("test", valuesBucket)
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates)
+        let id;
+        try {
+            expect(true).assertEqual(resultSet.goToFirstRow())
+            id = resultSet.getLong(resultSet.getColumnIndex("id"))
+        } catch (e) {
+            console.log(TAG + "insert throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        const asset5 =  {
+            name: "name1",
+            uri: "uri5",
+            createTime: "createTime5",
+            modifyTime: "modifyTime5",
+            size: "size5",
+            path: "path5",
+            status: data_relationalStore.AssetStatus.ASSET_DELETE,
+        }
+        valuesBucket = {
+            "data1" : asset5,
+        }
+        predicates.equalTo("id", id);
+        await rdbStore.update(valuesBucket, predicates);
+        console.log(TAG + "************* testUpdateAsset0003 update success *************");
+        let predicates1 = await new data_relationalStore.RdbPredicates("test");
+        let resultSet1 = await rdbStore.query(predicates1);
+        console.log(TAG + "************* testUpdateAsset0003 query success *************");
+        try {
+            expect(true).assertEqual(resultSet1.goToFirstRow())
+            let asset = resultSet1.getAsset(resultSet1.getColumnIndex("data1"))
+            expect(data_relationalStore.AssetStatus.ASSET_DELETE).assertEqual(asset.status);
+        } catch (e) {
+            console.log(TAG + "update throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        resultSet.close();
+        expect(true).assertEqual(resultSet.isClosed)
+        resultSet1.close();
+        expect(true).assertEqual(resultSet1.isClosed)
+        resultSet = null
+        resultSet1 = null
+        done();
+        console.log(TAG + "************* testUpdateAsset0003 end *************");
+    })
+
+    /**
+     * @tc.name update asset
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateAsset_0040
+     * @tc.desc Update Asset normally, and the updated Asset.status should be ASSET_UPDATE
+     */
+    it('testUpdateAsset0004', 0, async function (done) {
+        console.log(TAG + "************* testUpdateAsset0004 start *************");
+        let valuesBucket = {
+            "data1": asset1
+        }
+        await rdbStore.insert("test", valuesBucket)
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates)
+        let id;
+        try {
+            expect(true).assertEqual(resultSet.goToFirstRow())
+            id = resultSet.getLong(resultSet.getColumnIndex("id"))
+        } catch (e) {
+            console.log(TAG + "insert throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        const asset5 =  {
+            name: "name1",
+            uri: "uri5",
+            createTime: "createTime5",
+            modifyTime: "modifyTime5",
+            size: "size5",
+            path: "path5",
+            status: data_relationalStore.AssetStatus.ASSET_NORMAL,
+        }
+        valuesBucket = {
+            "data1" : asset5,
+        }
+        predicates.equalTo("id", id);
+        await rdbStore.update(valuesBucket, predicates);
+        console.log(TAG + "************* testUpdateAsset0004 update success *************");
+        let predicates1 = await new data_relationalStore.RdbPredicates("test");
+        let resultSet1 = await rdbStore.query(predicates1);
+        console.log(TAG + "************* testUpdateAsset0004 query success *************");
+        try {
+            expect(true).assertEqual(resultSet1.goToFirstRow())
+            let asset = resultSet1.getAsset(resultSet1.getColumnIndex("data1"))
+            expect("uri5").assertEqual(asset.uri);
+            expect("createTime5").assertEqual(asset.createTime);
+            expect("modifyTime5").assertEqual(asset.modifyTime);
+            expect("size5").assertEqual(asset.size);
+            expect("path5").assertEqual(asset.path);
+            expect(data_relationalStore.AssetStatus.ASSET_UPDATE).assertEqual(asset.status);
+        } catch (e) {
+            console.log(TAG + "update throw error: " + e.code + ", message is " + e.message);
+            expect(null).assertFail();
+        }
+        resultSet.close();
+        expect(true).assertEqual(resultSet.isClosed)
+        resultSet1.close();
+        expect(true).assertEqual(resultSet1.isClosed)
+        resultSet = null
+        resultSet1 = null
+        done();
+        console.log(TAG + "************* testUpdateAsset0004 end *************");
+    })
 })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreDataChange.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreDataChange.test.js
index 7b7e08b9db948f7e85a69f840493e534f27cd03c..8af7561d3daf9584abe8a68ccb0245f0426fba56 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreDataChange.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreDataChange.test.js
@@ -197,8 +197,8 @@ describe('RdbStoreDataChangeTest', function () {
             expect(2).assertEqual(rowId);
         } catch (error) {
             console.error(TAG + `delete fail, code:${error.code}, message: ${error.message}`);
-            done();
             expect().assertFail();
+            done();
         }
         console.info(TAG + "************* testRdbStoreDataChange0003 end *************");
     })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreDistributedJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreDistributedJsunit.test.js
index 6eea12af139cd1ac4f6aa3f4c31c781f28ee021e..a8684cd21a2e490428b0e1b23bb794f05452b524 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreDistributedJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreDistributedJsunit.test.js
@@ -548,5 +548,39 @@ describe('rdbStoreDistributedTest', function () {
         }
         console.log(TAG + "************* testRdbStoreDistributed0025 end *************");
     })
+
+    /**
+     * @tc.name subscribe test
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Distributed_0026
+     * @tc.desc Abnormal testcase of setDistributedTables after RDB Closed
+     */
+    it('testRdbStoreDistributed0026', 0, async function (done) {
+        console.log(TAG + "************* testRdbStoreDistributed0026 start *************");
+
+        const config = {
+            "name": "AfterCloseTest.db",
+            securityLevel: data_relationalStore.SecurityLevel.S1,
+        }
+        const rdbStore = await data_relationalStore.getRdbStore(context, config);
+
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            expect(null).assertFail();
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.setDistributedTables(['employee'])
+        } catch (err) {
+            console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbStoreDistributed0026 end *************");
+    })
+
     console.log(TAG + "*************Unit Test End*************");
 })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByCursor.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByCursor.test.js
index 789e7cc37fb4322302a5c093fb9ac4e45b6d08d5..a07a477d6782966e81aa335a8e80756fef4c2b16 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByCursor.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByCursor.test.js
@@ -105,7 +105,7 @@ describe('rdbStoreQueryByCursorTest', function () {
         }
         let promise = rdbStore.query(predicates);
         await promise.then((resultSet) => {
-            expect(6).assertEqual(resultSet.columnCount);
+            expect(7).assertEqual(resultSet.columnCount);
             let deletedIndex = resultSet.getColumnIndex(relationalStore.Field.DELETED_FLAG_FIELD);
             expect(5).assertEqual(deletedIndex);
             let cursorIndex = resultSet.getColumnIndex(relationalStore.Field.CURSOR_FIELD);
@@ -119,7 +119,6 @@ describe('rdbStoreQueryByCursorTest', function () {
         });
         done();
     })
-0.
     /**
      * @tc.name query with cursor
      * @tc.number SUB_DDM_AppDataFWK_JSRDB_QUERY_WITH_CURSOR_0002
@@ -137,7 +136,7 @@ describe('rdbStoreQueryByCursorTest', function () {
         }
         let promise = rdbStore.query(predicates, ["data", "uuid"]);
         await promise.then((resultSet) => {
-            expect(4).assertEqual(resultSet.columnCount);
+            expect(5).assertEqual(resultSet.columnCount);
             expect(true).assertEqual(resultSet.goToFirstRow());
             expect(true).assertEqual(resultSet.goToNextRow());
             let cursor = resultSet.getLong(resultSet.getColumnIndex(relationalStore.Field.CURSOR_FIELD));
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByStep.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByStep.test.js
index 66c9eff49831bda0d37d000fd6010e438379a279..e9ada2e214badb7fd93cb81d40273bf934975192 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByStep.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreQueryByStep.test.js
@@ -354,9 +354,9 @@ describe('rdbStoreQueryByStepTest', function () {
     })
 
     /**
-     * @tc.number testRdbStoreQueryByStep0009
+     * @tc.number testRdbStoreQueryByStep0011
      * @tc.name Normal test case of queryByStep, query all data
-     * @tc.desc 1. Execute queryByStep, sql is 'select * from test'
+     * @tc.desc 1. Execute queryByStep, sql is 'select * from test where name = ""'
      * @tc.size MediumTest
      * @tc.type Function
      * @tc.level Level 2
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetRow.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetRow.test.js
index 75d29d13a587ad1ec3eeb06b0e003efe1427b53c..552de4625fec1c548c26fb356a6070a49ee67721 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetRow.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetRow.test.js
@@ -180,12 +180,66 @@ describe('rdbStoreResultSetGetRowTest', function () {
     })
 
     /**
-     * @tc.name rdb store resultSet insert undefined value and verify test
+     * @tc.name rdb store resultSet getRow test
+     * @tc.number rdbStoreResultSetGetRowTest0005
+     * @tc.desc insert blob: null
+     */
+    it('rdbStoreResultSetGetRowTest0005', 0, async function (done) {
+        console.log(TAG + "************* rdbStoreResultSetGetRowTest0005 start *************");
+        let valueBucket = {
+            "data1": "",
+            "data2": 10,
+            "data3": 1.0,
+            "data4": null,
+            "data5": true,
+        };
+        let rowId = await rdbStore.insert("test", valueBucket);
+        expect(1).assertEqual(rowId);
+
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates, ["data4"])
+        expect(true).assertEqual(resultSet.goToFirstRow());
+
+        let valueBucket_ret = resultSet.getRow();
+        expect(null).assertEqual(valueBucket_ret.data4);
+        done();
+        console.log(TAG + "************* rdbStoreResultSetGetRowTest0005 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getRow test
      * @tc.number rdbStoreResultSetGetRowTest0006
+     * @tc.desc insert blob: new Uint8Array()
+     */
+    it('rdbStoreResultSetGetRowTest0006', 0, async function (done) {
+        console.log(TAG + "************* rdbStoreResultSetGetRowTest0006 start *************");
+        let valueBucket = {
+            "data1": "",
+            "data2": 10,
+            "data3": 1.0,
+            "data4": new Uint8Array(),
+            "data5": true,
+        };
+        let rowId = await rdbStore.insert("test", valueBucket);
+        expect(1).assertEqual(rowId);
+
+        let predicates = await new data_relationalStore.RdbPredicates("test")
+        let resultSet = await rdbStore.query(predicates, ["data4"])
+        expect(true).assertEqual(resultSet.goToFirstRow());
+
+        let valueBucket_ret = resultSet.getRow();
+        expect(null).assertEqual(valueBucket_ret.data4);
+        done();
+        console.log(TAG + "************* rdbStoreResultSetGetRowTest0006 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet insert undefined value and verify test
+     * @tc.number rdbStoreResultSetGetRowTest0007
      * @tc.desc resultSet getRow test
      */
-    it('rdbStoreInsertUndefinedValueTest0006', 0, async function (done) {
-        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0006 start *************");
+    it('rdbStoreInsertUndefinedValueTest0007', 0, async function (done) {
+        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0007 start *************");
         let valueBucket = {
             data2: 10,
             data6: undefined
@@ -200,21 +254,21 @@ describe('rdbStoreResultSetGetRowTest', function () {
         let valueBucket_ret = resultSet.getRow();
         expect(10).assertEqual(valueBucket_ret["data2"]);
         done();
-        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0006 end   *************");
+        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0007 end   *************");
     })
 
     /**
      * @tc.name rdb store resultSet insert undefined value and verify test
-     * @tc.number rdbStoreResultSetGoToLastRow0001
+     * @tc.number rdbStoreResultSetGoToLastRow0008
      * @tc.desc resultSet goToFirstRow test
      */
-    it('rdbStoreInsertUndefinedValueTest0007', 0, async function () {
-        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0007 start *************");
+    it('rdbStoreInsertUndefinedValueTest0008', 0, async function () {
+        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0008 start *************");
         let predicates = await new data_relationalStore.RdbPredicates("test")
         let resultSet = await rdbStore.query(predicates)
         expect(false).assertEqual(resultSet.goToFirstRow());
         expect(false).assertEqual(resultSet.goToLastRow());
-        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0007 end   *************");
+        console.log(TAG + "************* rdbStoreInsertUndefinedValueTest0008 end   *************");
     })
     console.log(TAG + "*************Unit Test End*************");
 })
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetValue.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetValue.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a5bcf6c66fb06ddbc69c6f97a9c68ef049183d0
--- /dev/null
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreResultSetGetValue.test.js
@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+import relationalStore from '@ohos.data.relationalStore';
+import ability_featureAbility from '@ohos.ability.featureAbility'
+
+let context = ability_featureAbility.getContext()
+
+const TAG = "[RELATIONAL_STORE_JSKITS_TEST]"
+
+const STORE_CONFIG = {
+    name: "getValue_test.db",
+    securityLevel: relationalStore.SecurityLevel.S1,
+}
+let rdbStore;
+
+describe('rdbStoreResultSetGetValueTest', function () {
+    beforeAll(async function () {
+        console.info(TAG + 'beforeAll')
+        await relationalStore.deleteRdbStore(context, "getValue_test.db");
+        rdbStore = await relationalStore.getRdbStore(context, STORE_CONFIG);
+    })
+
+    beforeEach(async function () {
+        console.info(TAG + 'beforeEach')
+        await rdbStore.executeSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT, age INTEGER, salary REAL, blobType BLOB);");
+    })
+
+    afterEach(async function () {
+        console.info(TAG + 'afterEach')
+        await rdbStore.executeSql("DROP TABLE IF EXISTS test");
+    })
+
+    afterAll(async function () {
+        console.info(TAG + 'afterAll')
+        await relationalStore.deleteRdbStore(context, "getValue_test.db");
+    })
+
+    console.log(TAG + "*************Unit Test Begin*************");
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0001
+     * @tc.desc not insert blob
+     */
+    it('rdbStoreResultSetGetValueTest_0001', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0001 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': 18,
+            'salary': 100.5,
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('blobType')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0001 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0002
+     * @tc.desc insert blob: new Uint8Array()
+     */
+    it('rdbStoreResultSetGetValueTest_0002', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0002 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': 18,
+            'salary': 100.5,
+            'blobType': new Uint8Array()
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            let blobValue = resultSet.getValue(resultSet.getColumnIndex('blobType'));
+            expect(null).assertEqual(blobValue);
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0002 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0003
+     * @tc.desc insert blob: ''
+     */
+    it('rdbStoreResultSetGetValueTest_0003', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0003 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': 18,
+            'salary': 100.5,
+            'blobType': ''
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect('').assertEqual(resultSet.getValue(resultSet.getColumnIndex('blobType')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0003 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0004
+     * @tc.desc insert blob: null
+     */
+    it('rdbStoreResultSetGetValueTest_0004', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0004 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': 18,
+            'salary': 100.5,
+            'blobType': null
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('blobType')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0004 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0005
+     * @tc.desc insert string: ''
+     */
+    it('rdbStoreResultSetGetValueTest_0005', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0005 start *************");
+        let valueBucket = {
+            'name': '',
+            'age': 18,
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect('').assertEqual(resultSet.getValue(resultSet.getColumnIndex('name')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0005 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0006
+     * @tc.desc insert string: null
+     */
+    it('rdbStoreResultSetGetValueTest_0006', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0006 start *************");
+        let valueBucket = {
+            'name': null,
+            'age': 18,
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('name')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0006 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0007
+     * @tc.desc not insert string
+     */
+    it('rdbStoreResultSetGetValueTest_0007', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0007 start *************");
+        let valueBucket = {
+            'age': 18,
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('name')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0007 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0008
+     * @tc.desc insert number: ''
+     */
+    it('rdbStoreResultSetGetValueTest_0008', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0008 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': '',
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect('').assertEqual(resultSet.getValue(resultSet.getColumnIndex('age')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0008 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0009
+     * @tc.desc insert number: null
+     */
+    it('rdbStoreResultSetGetValueTest_0009', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0009 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'age': null,
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('age')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0009 end   *************");
+    })
+
+    /**
+     * @tc.name rdb store resultSet getValue test
+     * @tc.number rdbStoreResultSetGetValueTest_0010
+     * @tc.desc not insert number
+     */
+    it('rdbStoreResultSetGetValueTest_0010', 0, async function () {
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0010 start *************");
+        let valueBucket = {
+            'name': 'lisi',
+            'salary': 100.5,
+            'blobType': new Uint8Array([1, 2, 3])
+        };
+        try {
+            let rowId = await rdbStore.insert("test", valueBucket);
+            expect(1).assertEqual(rowId);
+        } catch (err) {
+            console.error(`### insert failed, code:${err.code}, message:${err.message}`)
+        }
+
+        try {
+            let resultSet = await rdbStore.querySql('SELECT * FROM test')
+            expect(true).assertEqual(resultSet.goToFirstRow());
+            expect(null).assertEqual(resultSet.getValue(resultSet.getColumnIndex('age')));
+        } catch (err) {
+            console.error(`### query failed, code:${err.code}, message:${err.message}`)
+        }
+        console.log(TAG + "************* rdbStoreResultSetGetValueTest_0010 end   *************");
+    })
+
+    console.log(TAG + "*************Unit Test End*************");
+})
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbStoreValueType.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbStoreValueType.test.js
index 24e62504d49b7d2bcb1c3cad6789ab9cacd2e6b7..59a3b3a2dce1ad3fe97a853e9b41bc20b95ff181 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbStoreValueType.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbStoreValueType.test.js
@@ -21,7 +21,7 @@ var context = featureAbility.getContext();
 
 const TAG = "[VALUE_TYPE_TEST]"
 
-const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS bigint_table(id INTEGER PRIMARY KEY AUTOINCREMENT, value1 UNLIMITED INT NOT NULL, value2 UNLIMITED INT, value3 VECS)";
+const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS bigint_table(id INTEGER PRIMARY KEY AUTOINCREMENT, value1 UNLIMITED INT NOT NULL, value2 UNLIMITED INT, value3 FLOATVECTOR)";
 
 const DROP_TABLE_TEST = "DROP TABLE IF EXISTS bigint_table";
 
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseJsunit.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..e032bfe55ea03f35535816834d90f8e6ae30905d
--- /dev/null
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseJsunit.test.js
@@ -0,0 +1,683 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+import relationalStore from '@ohos.data.relationalStore'
+import ability_featureAbility from '@ohos.ability.featureAbility'
+
+const TAG = "[RELATIONAL_STORE_JSKITS_TEST]";
+const STORE_NAME = "AfterCloseTest.db";
+const context = ability_featureAbility.getContext();
+
+async function createRdb() {
+    const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+        "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+    const STORE_CONFIG = {
+        name: STORE_NAME,
+        securityLevel: relationalStore.SecurityLevel.S1,
+    };
+    const rdbStore = await relationalStore.getRdbStore(context, STORE_CONFIG);
+    await rdbStore.executeSql(CREATE_TABLE_TEST);
+    var u8 = new Uint8Array([1, 2, 3]);
+    const valueBucket = {
+        "name": "zhangsan",
+        "age": 18,
+        "salary": 100.5,
+        "blobType": u8,
+    };
+    await rdbStore.insert('test', valueBucket);
+    return rdbStore;
+}
+
+describe('rdbStoreAfterCloseTest', function () {
+    beforeAll(async function () {
+        console.info(TAG + 'beforeAll')
+    })
+
+    beforeEach(async function () {
+        console.info(TAG + 'beforeEach');
+    })
+
+    afterEach(function () {
+        console.info(TAG + 'afterEach');
+    })
+
+    afterAll(async function () {
+        console.info(TAG + 'afterAll');
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0001
+     * @tc.name RDB Close test
+     * @tc.desc ececute after RDB closed
+     */
+    it('testRdbAfterClose0001', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0001 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.execute('SELECT * FROM test LIMIT 100');
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0001 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0002
+     * @tc.name RDB Close test
+     * @tc.desc executeSql after RDB closed
+     */
+    it('testRdbAfterClose0002', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0002 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.executeSql('SELECT * FROM test LIMIT 100');
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0002 end *************");
+    })
+    
+    /**
+     * @tc.number testRdbAfterClose0003
+     * @tc.name RDB Close test
+     * @tc.desc query after RDB closed
+     */
+    it('testRdbAfterClose0003', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0003 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            let predicates = new relationalStore.RdbPredicates("test");
+            predicates.equalTo('age', 18);
+            await rdbStore.query(predicates);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0003 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0004
+     * @tc.name RDB Close test
+     * @tc.desc querySql after RDB closed
+     */
+    it('testRdbAfterClose0004', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0004 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+        try {
+            await rdbStore.querySql("SELECT * FROM test LIMIT 100");
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message);
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0004 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0005
+     * @tc.name RDB Close test
+     * @tc.desc getModifyTime after RDB closed
+     */
+    it('testRdbAfterClose0005', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0005 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.getModifyTime('test', 'name', [1]);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0005 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0006
+     * @tc.name RDB Close test
+     * @tc.desc getModifyTime after RDB closed
+     */
+    it('testRdbAfterClose0006', 0, async function (done) {
+        console.log(TAG + "************* testRdbAfterClose0006 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.getModifyTime('test', 'name', [1], () => {});
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code);
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        done(); 
+        console.log(TAG + "************* testRdbAfterClose0006 end *************");
+    })
+    
+
+    /**
+     * @tc.number testRdbAfterClose0007
+     * @tc.name RDB Close test
+     * @tc.desc insert after RDB closed
+     */
+    it('testRdbAfterClose0007', 0, async function (done) {
+        console.log(TAG + "************* testRdbAfterClose0007 start *************");
+
+        const rdbStore = await createRdb();
+        var u8 = new Uint8Array([1, 2, 3])
+        try {
+            rdbStore.beginTransaction()
+            const valueBucket = {
+                "name": "lisi",
+                "age": 18,
+                "salary": 100.5,
+                "blobType": u8,
+            }
+            await rdbStore.insert("test", valueBucket)
+
+        } catch (e) {
+            console.log(TAG + e);
+            expect(null).assertFail()
+            console.log(TAG + "testRdbAfterClose0007 failed");
+        }
+
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            expect(null).assertFail();
+        }
+
+        try {
+            rdbStore.commit();
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbAfterClose0007 end *************");
+    })
+
+    /**
+     * @tc.number testRdbTransactionInsert0004
+     * @tc.name RDB Close test
+     * @tc.desc commit after RDB closed
+     */
+    it('testRdbAfterClose0008', 0, async function (done) {
+        console.log(TAG + "************* testRdbAfterClose0008 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            expect(null).assertFail();
+        }
+
+        try {
+            await rdbStore.commit(1);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbAfterClose0008 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0009
+     * @tc.name RDB Close test
+     * @tc.desc rollBack after RDB closed
+     */
+    it('testRdbAfterClose0009', 0, async function (done) {
+        console.log(TAG + "************* testRdbAfterClose0009 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            expect(null).assertFail();
+        }
+
+        try {
+            rdbStore.rollBack();
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbAfterClose0009 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0010
+     * @tc.name RDB Close test
+     * @tc.desc rollBack after RDB closed
+     */
+    it('testRdbAfterClose0010', 0, async function (done) {
+        console.log(TAG + "************* testRdbAfterClose0010 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            expect(null).assertFail();
+        }
+
+        try {
+            rdbStore.rollBack();
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        done()
+        console.log(TAG + "************* testRdbAfterClose0010 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0011
+     * @tc.name RDB Close test
+     * @tc.desc beginTransaction after RDB closed
+     */
+    it('testRdbAfterClose0011', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0011 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.beginTransaction();
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+
+        console.log(TAG + "************* testRdbAfterClose0011 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0012
+     * @tc.name RDB Close test
+     * @tc.desc beginTrans after RDB closed
+     */
+    it('testRdbAfterClose0012', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0012 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.beginTrans();
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+
+        console.log(TAG + "************* testRdbAfterClose0012 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0013
+     * @tc.name RDB Close test
+     * @tc.desc obtainDistributedTableName after RDB closed
+     */
+    it('testRdbAfterClose0013', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0013 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.obtainDistributedTableName('573f', 'test');
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0013 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0014
+     * @tc.name RDB Close test
+     * @tc.desc mount event after RDB closed
+     */
+    it('testRdbAfterClose0014', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0014 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.on('dataChange', relationalStore.SubscribeType.SUBSCRIBE_TYPE_REMOTE, (deviceIds) => {
+                console.log(TAG + 'deviceIds: ' + deviceIds);
+            });
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0014 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0015
+     * @tc.name RDB Close test
+     * @tc.desc unmount event after RDB closed
+     */
+    it('testRdbAfterClose0015', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0015 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.off('dataChange', relationalStore.SubscribeType.SUBSCRIBE_TYPE_REMOTE, (deviceIds) => {
+                console.log(TAG + 'deviceIds: ' + deviceIds);
+            });
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0015 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose00016
+     * @tc.name RDB Close test
+     * @tc.desc emit event after RDB closed
+     */
+    it('testRdbAfterClose0016', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose00016 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.emit('testRdbAfterClose0016');
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose00016 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0017
+     * @tc.name RDB Close test
+     * @tc.desc cleanDirtyData after RDB closed
+     */
+    it('testRdbAfterClose0017', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0017 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.cleanDirtyData('test')
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0017 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0018
+     * @tc.name RDB Close test
+     * @tc.desc lockRow after RDB closed
+     */
+    it('testRdbAfterClose0018', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0018 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            let predicates = new relationalStore.RdbPredicates("test");
+            predicates.equalTo('age', 18);
+            await rdbStore.lockRow(predicates);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0018 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0019
+     * @tc.name RDB Close test
+     * @tc.desc queryLockedRow after RDB closed
+     */
+    it('testRdbAfterClose0019', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0019 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            let predicates = new relationalStore.RdbPredicates("test");
+            predicates.equalTo('age', 18);
+            const resutlSet = await rdbStore.queryLockedRow(predicates);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0019 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0020
+     * @tc.name RDB Close test
+     * @tc.desc unlockRow after RDB closed
+     */
+    it('testRdbAfterClose0020', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0020 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            let predicates = new relationalStore.RdbPredicates("test");
+            predicates.equalTo('age', 18);
+            await rdbStore.unlockRow(predicates);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0020 end *************");
+    })
+
+    /**
+     * @tc.number testRdbAfterClose0021
+     * @tc.name RDB Close test
+     * @tc.desc attach after RDB closed
+     */
+    it('testRdbAfterClose0021', 0, async function () {
+        console.log(TAG + "************* testRdbAfterClose0021 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            await rdbStore.attach('//test/path', 'test1')
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbAfterClose0021 end *************");
+    })
+    console.log(TAG + "*************Unit Test End*************");
+})
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseSyncJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseSyncJsunit.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..8578c3d409c38be96f8093ff0dc0e16e6828b1e6
--- /dev/null
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreAfterCloseSyncJsunit.test.js
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+import relationalStore from '@ohos.data.relationalStore'
+import ability_featureAbility from '@ohos.ability.featureAbility'
+
+const TAG = "[RELATIONAL_STORE_JSKITS_TEST]";
+const STORE_NAME = "AfterCloseTest.db";
+const context = ability_featureAbility.getContext();
+
+async function createRdb() {
+    const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+        "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+    const STORE_CONFIG = {
+        name: STORE_NAME,
+        securityLevel: relationalStore.SecurityLevel.S1,
+    };
+    const rdbStore = await relationalStore.getRdbStore(context, STORE_CONFIG);
+    await rdbStore.executeSql(CREATE_TABLE_TEST);
+    var u8 = new Uint8Array([1, 2, 3]);
+    const valueBucket = {
+        "name": "zhangsan",
+        "age": 18,
+        "salary": 100.5,
+        "blobType": u8,
+    };
+    await rdbStore.insert('test', valueBucket);
+    return rdbStore;
+}
+
+describe('rdbStoreAfterCloseSyncTest', function () {
+    beforeAll(async function () {
+        console.info(TAG + 'beforeAll')
+    })
+
+    beforeEach(async function () {
+        console.info(TAG + 'beforeEach')
+    })
+
+    afterEach(function () {
+        console.info(TAG + 'afterEach')
+    })
+
+    afterAll(async function () {
+        console.info(TAG + 'afterAll')
+    })
+
+    /**
+     * @tc.number testSyncRdbAfterClose0001
+     * @tc.name RDB Close test
+     * @tc.desc executeSync after RDB closed
+     */
+    it('testSyncRdbAfterClose0001', 0, async function () {
+        console.log(TAG + "************* testSyncRdbAfterClose0001 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            rdbStore.executeSync('SELECT * FROM test LIMIT 100');
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncRdbAfterClose0001 end *************");
+    })
+
+    /**
+     * @tc.number testSyncRdbAfterClose0002
+     * @tc.name RDB Close test
+     * @tc.desc querySync after RDB closed
+     */
+    it('testSyncRdbAfterClose0002', 0, async function () {
+        console.log(TAG + "************* testSyncRdbAfterClose0002 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            let predicates = new relationalStore.RdbPredicates("test");
+            predicates.equalTo('age', 18);
+            rdbStore.querySync(predicates);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncRdbAfterClose0002 end *************");
+    })
+
+    /**
+     * @tc.number testSyncRdbAfterClose0003
+     * @tc.name RDB Close test
+     * @tc.desc querySqlSync after RDB closed
+     */
+    it('testSyncRdbAfterClose0003', 0, async function () {
+        console.log(TAG + "************* testSyncRdbAfterClose0003 start *************");
+
+        const rdbStore = await createRdb();
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+        try {
+            rdbStore.querySqlSync("SELECT * FROM test");
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message);
+            expect("14800014").assertEqual(err.code)
+        }
+        
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncRdbAfterClose0003 end *************");
+    })
+    console.log(TAG + "*************Unit Test End*************");
+})
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreBackupRestoreWithFAContextJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreBackupRestoreWithFAContextJsunit.test.js
index cc9cc04bf87304ec3a32de1d12ac5b6ff5b87bae..4869700cc574dffd21b49c2bcc835b262a85b02d 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreBackupRestoreWithFAContextJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreBackupRestoreWithFAContextJsunit.test.js
@@ -216,6 +216,82 @@ describe('rdbStoreBackupRestoreWithFAContextTest', function () {
             await console.log(TAG + "************* RdbBackupRestoreTest_0040 end *************")
         })
 
+        /**
+         * @tc.name RDB BackupRestore test
+         * @tc.number SUB_DDM_RDB_JS_RdbBackupRestoreTest_0050
+         * @tc.desc RDB backup function test
+         */
+        it('RdbBackupRestoreBackupTest_0050', 0, async function (done) {
+            console.log(TAG + "************* RdbBackupRestoreBackupTest_0050 start *************")
+
+            const STORE_NAME = "AfterCloseTest.db";
+            const rdbStore = await data_relationalStore.getRdbStore(
+                context,
+                {
+                    name: STORE_NAME,
+                    securityLevel: data_relationalStore.SecurityLevel.S1
+                }
+            )
+            try {
+                await rdbStore.close();
+                console.info(`${TAG} close succeeded`);
+            } catch (err) {
+                expect(null).assertFail();
+                console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            }
+
+            try {
+                let dbName = "QueryTest_bak.db"
+                await rdbStore.backup(dbName)
+            } catch (err) {
+                console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+                expect("14800014").assertEqual(err.code)
+            }
+            
+            await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+            done();
+            console.log(TAG + "************* RdbBackupRestoreBackupTest_0050 end *************")
+        })
+        /**
+         * @tc.name RDB BackupRestore test
+         * @tc.number SUB_DDM_RDB_JS_RdbBackupRestoreTest_0060
+         * @tc.desc RDB restore function test
+         */
+        it('RdbBackupRestoreBackupTest_0060', 0, async function (done) {
+            console.log(TAG + "************* RdbBackupRestoreBackupTest_0060 start *************")
+
+            const STORE_NAME = "AfterCloseTest.db";
+            const rdbStore = await data_relationalStore.getRdbStore(
+                context,
+                {
+                    name: STORE_NAME,
+                    securityLevel: data_relationalStore.SecurityLevel.S1
+                }
+            )
+
+            let dbName = "notExistName.db"
+            BackupTest(dbName);
+
+            try {
+                await rdbStore.close();
+                console.info(`${TAG} close succeeded`);
+            } catch (err) {
+                expect(null).assertFail();
+                console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+            }
+
+            try {
+                await rdbStore.restore(dbName)
+            } catch (err) {
+                console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+                expect("14800014").assertEqual(err.code)
+            }
+
+            await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+            done();
+            console.log(TAG + "************* RdbBackupRestoreBackupTest_0060 end *************")
+        })
+
         console.log(TAG + "*************Unit Test End*************")
     }
 )
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteJsunit.test.js
index b2456716e62e06daeba39cfc7a903ecf769c4603..94562e0b52f6cc8a975e54c4eab659fffaca5945 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteJsunit.test.js
@@ -365,5 +365,107 @@ describe('rdbStoreDeleteTest', function () {
         console.log(TAG + "************* testRdbStoreDelete0007 end *************");
     })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Delete_0080
+     * @tc.name Abnormal test case of delete, if rdbStore is already close
+     * @tc.desc 1.Configure predicates (Calling system application)
+     *          2.Close rdbStore
+     * 		    3.Execute delete
+     */
+    it('testRdbStoreDelete0008', 0, async function (done) {
+        console.log(TAG + "************* testRdbStoreDelete0008 start *************");
+        
+        const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+        const STORE_NAME = "AfterCloseTest.db";
+        const rdbStore = await data_relationalStore.getRdbStore(
+            context,
+            {
+                name: STORE_NAME,
+                securityLevel: data_relationalStore.SecurityLevel.S1
+            }
+        )
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
+        const u8 = new Uint8Array([1, 2, 3])
+        const valueBucket = {
+            "name": "zhangsan",
+            "age": 18,
+            "salary": 100.5,
+            "blobType": u8,
+        }
+        await rdbStore.insert("test", valueBucket);
+
+        await rdbStore.close().then(() => {
+            console.info(`${TAG} close succeeded`);
+        }).catch((err) => {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        let predicates = await new data_relationalStore.RdbPredicates("test");
+        predicates.equalTo("age", 18);
+        try {
+            const ret = await rdbStore.delete(predicates);
+            console.log(TAG + "delete done: " + ret);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message);
+            expect("14800014").assertEqual(err.code);
+        }
+        
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbStoreDelete0008 end *************");
+    })
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Delete_0080
+     * @tc.name Abnormal test case of delete, if rdbStore is already close
+     * @tc.desc 1.Configure predicates (Calling system application)
+     *          2.Close rdbStore
+     * 		    3.Execute delete
+     */
+    it('testRdbStoreDelete0009', 0, async function (done) {
+        console.log(TAG + "************* testRdbStoreDelete0009 start *************");
+                
+        const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+        const STORE_NAME = "AfterCloseTest.db";
+        const rdbStore = await data_relationalStore.getRdbStore(
+            context,
+            {
+                name: STORE_NAME,
+                securityLevel: data_relationalStore.SecurityLevel.S1
+            }
+        )
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
+        
+        var u8 = new Uint8Array([1, 2, 3])
+        const valueBucket = {
+            "name": "zhangsan",
+            "age": 18,
+            "salary": 100.5,
+            "blobType": u8,
+        }
+        await rdbStore.insert("test", valueBucket);
+
+        await rdbStore.close().then(() => {
+            console.info(`${TAG} close succeeded`);
+        }).catch((err) => {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        let predicates = new data_relationalStore.RdbPredicates("test");
+        predicates.equalTo("age", 18);
+        try {
+            rdbStore.delete(predicates, () => {});
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message);
+            expect("14800014").assertEqual(err.code);
+        }
+        
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testRdbStoreDelete0009 end *************");
+    })
     console.log(TAG + "*************Unit Test End*************");
 })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteSyncJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteSyncJsunit.test.js
index 340b5ba2df47f8278f781a13d0b16d0de0648b73..18f3d2db90c38c173332152413d1a2735e938ba9 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteSyncJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreDeleteSyncJsunit.test.js
@@ -339,5 +339,58 @@ describe('rdbStoreDeleteSyncTest', function () {
         console.log(TAG + "************* testSyncRdbStoreDelete0007 end *************");
     })
 
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Delete_0008
+     * @tc.name Abnormal test case of delete, if rdbStore is already close
+     * @tc.desc 1.Configure predicates (Calling system application)
+     *          2.Close rdbStore
+     * 		    3.Execute deleteSync
+     */
+    it('testSyncRdbStoreDelete0008', 0, async function (done) {
+        console.log(TAG + "************* testSyncRdbStoreDelete0008 start *************");
+
+        const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+        const STORE_NAME = "AfterCloseTest.db";
+        const rdbStore = await data_relationalStore.getRdbStore(
+            context,
+            {
+                name: STORE_NAME,
+                securityLevel: data_relationalStore.SecurityLevel.S1
+            }
+        )
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
+
+        var u8 = new Uint8Array([1, 2, 3])
+        const valueBucket = {
+            "name": "zhangsan",
+            "age": 18,
+            "salary": 100.5,
+            "blobType": u8,
+        }
+        await rdbStore.insert("test", valueBucket);
+
+        await rdbStore.close().then(() => {
+            console.info(`${TAG} close succeeded`);
+        }).catch((err) => {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        let predicates = new data_relationalStore.RdbPredicates("test");
+        predicates.equalTo("age", 18);
+        try {
+            const ret = rdbStore.deleteSync(predicates);
+            console.log(TAG + "delete done: " + ret);
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message);
+            expect("14800014").assertEqual(err.code);
+        }
+        
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        done();
+        console.log(TAG + "************* testSyncRdbStoreDelete0008 end *************");
+    })
     console.log(TAG + "*************Unit Test End*************");
 })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertJsunit.test.js
index 91d8ac00cf08297c7ce02ef6bce9a54fec2f0c26..1309567d827035496541eff7d71d30ea3c1f38ef 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertJsunit.test.js
@@ -584,7 +584,6 @@ describe('rdbStoreInsertTest', function () {
             } catch (err) {
                 console.log("catch err: failed, err: code=" + err.code + " message=" + err.message);
                 expect(14800032).assertEqual(err.code);
-                rdbStore.rollBack();
             }
         }
 
@@ -785,5 +784,51 @@ describe('rdbStoreInsertTest', function () {
         console.log(TAG + "************* testRdbStorebatchInsert001 end *************");
     })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_batchInsert_0002
+     * @tc.name Normal test case of batchInsert
+     * @tc.desc 1.Create valueBucket
+     *          2.Execute push
+     *          3.BatchInsert data
+     *          4.Query data
+     */
+    it('testRdbStoreBatchInsert002', 0, async function () {
+        console.log(TAG + "************* testRdbStoreBatchInsert002 start *************");
+
+        const STORE_NAME = "AfterCloseTest.db";
+        const STORE_CONFIG1 = {
+            name: STORE_NAME,
+            securityLevel: data_relationalStore.SecurityLevel.S1,
+        };
+        const rdbStore = await data_relationalStore.getRdbStore(context, STORE_CONFIG1);
+        await rdbStore.executeSql(CREATE_TABLE_TEST, null);
+        await rdbStore.close().then(() => {
+            console.info(`close succeeded`);
+        }).catch((err) => {
+            console.error(`close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        var u8 = new Uint8Array([1, 2, 3])
+        const valueBucket = {
+            "name": "zhangsan",
+            "age": 18,
+            "salary": 100.5,
+            "blobType": u8,
+        }
+        let valueBucketArray = new Array();
+        for (let i = 0; i < 100; i++) {
+            valueBucketArray.push(valueBucket);
+        }
+        try {
+            await rdbStore.batchInsert("test", valueBucketArray);
+        } catch (err) {
+            console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbStoreBatchInsert002 end *************");
+    })
+
     console.log(TAG + "*************Unit Test End*************");
 })
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertSyncJsUnit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertSyncJsUnit.test.js
index 0df64ff15857c096f06aa02010a3849cb0637d98..3a14233ec719178c723e042e2489d94e228bac5e 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertSyncJsUnit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreInsertSyncJsUnit.test.js
@@ -564,7 +564,6 @@ describe('rdbStoreInsertSyncTest', function () {
             } catch (err) {
                 console.log("catch err: failed, err: code=" + err.code + " message=" + err.message);
                 expect(14800032).assertEqual(err.code);
-                rdbStore.rollBack();
             }
         }
 
@@ -766,5 +765,50 @@ describe('rdbStoreInsertSyncTest', function () {
             console.log(TAG + "************* testRdbStoreSyncbatchInsert001 end *************");
         })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_batchInsert_0002
+     * @tc.name Normal test case of batchInsertSync
+     * @tc.desc 1.Create valueBucket
+     *          2.Execute push
+     *          3.BatchInsert data
+     *          4.Query data
+     */
+    it('testRdbStoreBatchInsertSync002', 0, async function () {
+        console.log(TAG + "************* testRdbStoreBatchInsertSync002 start *************");
+
+        const STORE_NAME = "AfterCloseTest.db";
+        const STORE_CONFIG1 = {
+            name: STORE_NAME,
+            securityLevel: data_relationalStore.SecurityLevel.S1,
+        };
+        const rdbStore = await data_relationalStore.getRdbStore(context, STORE_CONFIG1);
+        await rdbStore.executeSql(CREATE_TABLE_TEST, null);
+        await rdbStore.close().then(() => {
+            console.info(`close succeeded`);
+        }).catch((err) => {
+            console.error(`close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        var u8 = new Uint8Array([1, 2, 3])
+        const valueBucket = {
+            "name": "zhangsan",
+            "age": 18,
+            "salary": 100.5,
+            "blobType": u8,
+        }
+        let valueBucketArray = new Array();
+        for (let i = 0; i < 100; i++) {
+            valueBucketArray.push(valueBucket);
+        }
+        try {
+            await rdbStore.batchInsertSync("test", valueBucketArray);
+        } catch (err) {
+            console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbStoreBatchInsertSync002 end *************");
+    })
     console.log(TAG + "*************Unit Test End*************");
 })
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstorePluginLibsJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstorePluginLibsJsunit.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..6648c2224518d18d64b4e5d3a0702c473fc70c96
--- /dev/null
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstorePluginLibsJsunit.test.js
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+import data_relationalStore from '@ohos.data.relationalStore'
+import ability_featureAbility from '@ohos.ability.featureAbility'
+
+var context = ability_featureAbility.getContext()
+
+const TAG = "[RELATIONAL_STORE_JSKITS_TEST]"
+
+var storeConfig = {
+    name: "PluginLibsTest.db",
+    securityLevel: data_relationalStore.SecurityLevel.S1,
+    pluginLibs: []
+}
+
+var rdbStore = undefined;
+
+describe('rdbStorePluginLibsTest', function () {
+    beforeAll(async function () {
+        console.info(TAG + 'beforeAll')
+    })
+
+    beforeEach(async function () {
+        console.info(TAG + 'beforeEach')
+    })
+
+    afterEach(async function () {
+        console.info(TAG + 'afterEach')
+        rdbStore = null
+        await data_relationalStore.deleteRdbStore(context, "PluginLibsTest.db");
+    })
+
+    afterAll(async function () {
+        console.info(TAG + 'afterAll')
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0001
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0001
+     * @tc.desc Test pluginLibs are empty
+     */
+    it('testPluginLibs0001', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0001 start *************");
+        try {
+            storeConfig.pluginLibs = [ "", "" ]
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect().assertFail();
+        }
+        console.log(TAG + "************* testPluginLibs0001 end   *************");
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0002
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0002
+     * @tc.desc Test pluginLib is current path
+     */
+    it('testPluginLibs0002', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0002 start *************");
+        try {
+            storeConfig.pluginLibs = [ "./" ]
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+            expect().assertFail();
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect(14800021).assertEqual(e.code);
+        }
+        console.log(TAG + "************* testPluginLibs0002 end   *************");
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0003
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0003
+     * @tc.desc Test pluginLib is no exist
+     */
+    it('testPluginLibs0003', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0003 start *************");
+        try {
+            storeConfig.pluginLibs = [ "/data/errPath/err.so" ]
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+            expect().assertFail();
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect(14800010).assertEqual(e.code);
+        }
+        console.log(TAG + "************* testPluginLibs0003 end   *************");
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0004
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0004
+     * @tc.desc Test pluginLib as other app path
+     */
+    it('testPluginLibs0004', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0004 start *************");
+        try {
+            storeConfig.pluginLibs = [ "/data/app/el1/bundle/public/" ]
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+            expect().assertFail();
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect(14800010).assertEqual(e.code);
+        }
+        console.log(TAG + "************* testPluginLibs0004 end   *************");
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0005
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0005
+     * @tc.desc Test pluginLib as current app dir
+     */
+    it('testPluginLibs0005', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0005 start *************");
+        try {
+            let path = await context.getFilesDir();
+            storeConfig.pluginLibs = [ String(path) ]
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+            expect().assertFail();
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect(14800021).assertEqual(e.code);
+        }
+        console.log(TAG + "************* testPluginLibs0005 end   *************");
+    })
+
+    /**
+     * @tc.name TEST_PLUGIN_LIBS_0006
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_RdbStore_plugin_Libs_0006
+     * @tc.desc Test plugin libs count exceeds 16
+     */
+    it('testPluginLibs0006', 0, async function () {
+        console.log(TAG + "************* testPluginLibs0006 start *************");
+        try {
+            let path = new Array(17).fill("").map((_, index) => `dir${index + 1}`)
+            storeConfig.pluginLibs = path
+            rdbStore = await data_relationalStore.getRdbStore(context, storeConfig);
+            expect().assertFail();
+        } catch (e) {
+            console.log("getRdbStore err: failed, err: code=" + e.code + " message=" + e.message)
+            expect(14800000).assertEqual(e.code);
+        }
+        console.log(TAG + "************* testPluginLibs0006 end   *************");
+    })
+    console.log(TAG + "*************Unit Test End*************");
+})
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreRdbstoreJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreRdbstoreJsunit.test.js
index fac50ce064039a6a0ece1ad42b34ab22986f1b02..f5348f80ae4b55e70ad93587776063af35dfb3f0 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreRdbstoreJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreRdbstoreJsunit.test.js
@@ -239,7 +239,6 @@ describe('rdbStoreTest', function () {
         try {
             await data_relationalStore.getRdbStore(context, config2);
         } catch (err) {
-            expect(14800017).assertEqual(err.code)
             console.log(TAG + "************* testRdbStore0009 end   *************");
         }
     })
@@ -267,11 +266,11 @@ describe('rdbStoreTest', function () {
         data_relationalStore.getRdbStore(context, config2, async (err, rdbStore) => {
             if (err) {
                 done()
-                expect(14800017).assertEqual(err.code)
                 console.log(TAG + "************* testRdbStore0010 end   *************");
             } else {
                 console.log("Get RdbStore successfully.")
-                expect(false).assertTrue()
+                expect(true).assertTrue()
+                done()
             }
         })
     })
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteJsunit.test.js
index 4260a80475089c03dbcaf9f7681a1b0cfc79ca44..65bcc727b37783046a4bf52996da732e41e4da11 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteJsunit.test.js
@@ -129,8 +129,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("SELECT * FROM test");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute select sql failed, code:${err.code}, message: ${err.message}`);
         }
         done();
@@ -262,8 +262,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("ATTACH DATABASE 'execute_attach_test.db' AS 'attach.db'");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute attach sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -271,8 +271,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("DETACH DATABASE 'attach.db'");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute detach sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -280,8 +280,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("BEGIN TRANSACTION");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute begin transaction sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -289,8 +289,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("COMMIT");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute commit sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -298,8 +298,8 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("ROLLBACK");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute rollback sql failed, code:${err.code}, message: ${err.message}`);
         }
         done();
@@ -491,7 +491,7 @@ describe('rdbStoreExcuteTest', function () {
             await rdbStore.execute("PRAGMA table_info(test)");
             expect(null).assertFail();
         } catch (err) {
-            expect(14800000).assertEqual(err.code);
+            expect(14800021).assertEqual(err.code);
             console.error(`get table info failed, code:${err.code}, message: ${err.message}`);
         }
         done();
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSqlJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSqlJsunit.test.js
index ec28f3901b124d22c9320db07c5de3b2eae04579..84a0e3fda7296023673686cd458c3f8fd1828c0d 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSqlJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSqlJsunit.test.js
@@ -22,12 +22,12 @@ const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIM
     "name TEXT NOT NULL, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
 
 const STORE_CONFIG = {
-    name: "ExcuteSqlTest.db",
+    name: "ExecuteSqlTest.db",
     securityLevel: data_relationalStore.SecurityLevel.S1,
 }
 var rdbStore = undefined;
 
-describe('rdbStoreExcuteSqlTest', function () {
+describe('rdbStoreExecuteSqlTest', function () {
     beforeAll(async function () {
         console.info(TAG + 'beforeAll')
         rdbStore = await data_relationalStore.getRdbStore(context, STORE_CONFIG);
@@ -46,18 +46,18 @@ describe('rdbStoreExcuteSqlTest', function () {
     afterAll(async function () {
         console.info(TAG + 'afterAll')
         rdbStore = null
-        await data_relationalStore.deleteRdbStore(context, "ExcuteSqlTest.db");
+        await data_relationalStore.deleteRdbStore(context, "ExecuteSqlTest.db");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0010
-     * @tc.name Normal test case of ExcuteSql
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0010
+     * @tc.name Normal test case of ExecuteSql
      * @tc.desc 1.Insert data
      *          2.ExecuteSql(delete age = "18" OR "20")
      *          3.QuerySql
      */
-    it('ExcuteSqlTest0001', 0, async function (done) {
-        console.log(TAG + "************* ExcuteSqlTest0001 start *************");
+    it('ExecuteSqlTest0001', 0, async function (done) {
+        console.log(TAG + "************* ExecuteSqlTest0001 start *************");
         var u8 = new Uint8Array([1, 2, 3])
         {
             const valueBucket = {
@@ -100,18 +100,18 @@ describe('rdbStoreExcuteSqlTest', function () {
             expect(null).assertFail();
         })
         await querySqlPromise
-        console.log(TAG + "************* ExcuteSqlTest0001 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0001 end   *************");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0020
-     * @tc.name Normal test case of ExcuteSql
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0020
+     * @tc.name Normal test case of ExecuteSql
      * @tc.desc 1.Insert data
      *          2.ExecuteSql(delete name = "lisi")
      *          3.QuerySql
      */
-    it('ExcuteSqlTest0002', 0, async function (done) {
-        console.log(TAG + "************* ExcuteSqlTest0002 start *************");
+    it('ExecuteSqlTest0002', 0, async function (done) {
+        console.log(TAG + "************* ExecuteSqlTest0002 start *************");
         var u8 = new Uint8Array([2, 3, 4])
         {
             const valueBucket = {
@@ -153,19 +153,19 @@ describe('rdbStoreExcuteSqlTest', function () {
             expect(null).assertFail();
         })
         await querySqlPromise
-        console.log(TAG + "************* ExcuteSqlTest0002 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0002 end   *************");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0030
-     * @tc.name Normal test case of ExcuteSql
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0030
+     * @tc.name Normal test case of ExecuteSql
      * @tc.desc 1.Insert data (param is long string)
      *          2.Query data
      *          3.ExecuteSql (delete age = 19 AND name = nameStr)
      *          4.Query data
      */
-    it('ExcuteSqlTest0003', 0, async function (done) {
-        console.log(TAG + "************* ExcuteSqlTest0003 start *************");
+    it('ExecuteSqlTest0003', 0, async function (done) {
+        console.log(TAG + "************* ExecuteSqlTest0003 start *************");
         var u8 = new Uint8Array([3, 4, 5])
         var nameStr = "lisi" + "e".repeat(2000) + "zhangsan"
         {
@@ -240,17 +240,17 @@ describe('rdbStoreExcuteSqlTest', function () {
             })
             await querySqlPromise
         }
-        console.log(TAG + "************* ExcuteSqlTest0003 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0003 end   *************");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0040
-     * @tc.name Normal test case of ExcuteSql, drop table
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0040
+     * @tc.name Normal test case of ExecuteSql, drop table
      * @tc.desc 1.Insert data
      *          2.ExecuteSql (drop table)
      */
-    it('ExcuteSqlTest0004', 0, async function (done) {
-        console.log(TAG + "************* ExcuteSqlTest0004 start *************");
+    it('ExecuteSqlTest0004', 0, async function (done) {
+        console.log(TAG + "************* ExecuteSqlTest0004 start *************");
         var u8 = new Uint8Array([3, 4, 5])
         {
             const valueBucket = {
@@ -284,34 +284,34 @@ describe('rdbStoreExcuteSqlTest', function () {
         }
         await rdbStore.executeSql("DROP TABLE IF EXISTS test")
         done();
-        console.log(TAG + "************* ExcuteSqlTest0004 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0004 end   *************");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0050
-     * @tc.name Normal test case of excuteSql and querySql, PRAGMA user_version
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0050
+     * @tc.name Normal test case of executeSql and querySql, PRAGMA user_version
      * @tc.desc 1.Set user_version
      *          2.Get user_version
      */
-    it('ExcuteSqlTest0005', 0, async function () {
-        console.log(TAG + "************* ExcuteSqlTest0005 start *************");
+    it('ExecuteSqlTest0005', 0, async function () {
+        console.log(TAG + "************* ExecuteSqlTest0005 start *************");
         // 2 is used to set the store version
         await rdbStore.executeSql("PRAGMA user_version = 2")
         let resultSet = await rdbStore.querySql("PRAGMA user_version");
         resultSet.goToFirstRow();
         expect(2).assertEqual(resultSet.getLong(0))
         resultSet.close();
-        console.log(TAG + "************* ExcuteSqlTest0005 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0005 end   *************");
     })
 
     /**
-     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExcuteSql_0060
-     * @tc.name Normal test case of excuteSql and querySql, PRAGMA table_info
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0060
+     * @tc.name Normal test case of executeSql and querySql, PRAGMA table_info
      * @tc.desc 1.Get table_info
      *          2.Check table_info
      */
-    it('ExcuteSqlTest0006', 0, async function () {
-        console.log(TAG + "************* ExcuteSqlTest0006 start *************");
+    it('ExecuteSqlTest0006', 0, async function () {
+        console.log(TAG + "************* ExecuteSqlTest0006 start *************");
         let resultSet = await rdbStore.querySql("PRAGMA table_info(test)");
         resultSet.goToFirstRow();
         expect(0).assertEqual(resultSet.getLong(0))
@@ -335,7 +335,29 @@ describe('rdbStoreExcuteSqlTest', function () {
         expect("blobType").assertEqual(resultSet.getString(1))
         expect("BLOB").assertEqual(resultSet.getString(2))
         resultSet.close();
-        console.log(TAG + "************* ExcuteSqlTest0006 end   *************");
+        console.log(TAG + "************* ExecuteSqlTest0006 end   *************");
+    })
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_ExecuteSql_0070
+     * @tc.name Normal test case of executeSql, if spaces before the sql
+     * @tc.desc 1.Set user_version
+     *          2.Get user_version
+     */
+    it('ExecuteSqlTest0007', 0, async function () {
+        console.log(TAG + "************* ExecuteSqlTest0007 start *************");
+        // 2 is used to set the store version
+        await rdbStore.executeSql("   PRAGMA user_version = 2")
+        let resultSet = await rdbStore.querySql("PRAGMA user_version");
+        resultSet.goToFirstRow();
+        expect(2).assertEqual(resultSet.getLong(0))
+
+        await rdbStore.executeSql("\r\nPRAGMA user_version = 3")
+        resultSet = await rdbStore.querySql("PRAGMA user_version");
+        resultSet.goToFirstRow();
+        expect(3).assertEqual(resultSet.getLong(0))
+        resultSet.close();
+        console.log(TAG + "************* ExecuteSqlTest0007 end   *************");
     })
 
     console.log(TAG + "*************Unit Test End*************");
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSyncJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSyncJsunit.test.js
index 1c136bc0c69059ce016513618466d94250fb0af7..48631b76611cf838ad54654ac2e4ee1f689843db 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSyncJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreStoreExcuteSyncJsunit.test.js
@@ -42,13 +42,14 @@ describe('rdbStoreExcuteTest', function () {
     })
 
     beforeEach(async function () {
-        await rdbStore.executeSql(CREATE_TABLE_TEST);
         console.info(TAG + 'beforeEach')
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
     })
 
     afterEach(async function () {
         console.info(TAG + 'afterEach')
-        await rdbStore.executeSql("DROP TABLE IF EXISTS test")
+        await rdbStore.executeSql("DROP TABLE IF EXISTS test");
+        await rdbStore.executeSql("DROP TABLE IF EXISTS test2");
     })
 
     afterAll(async function () {
@@ -129,8 +130,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("SELECT * FROM test");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute select sql failed, code:${err.code}, message: ${err.message}`);
         }
         done();
@@ -262,8 +263,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("ATTACH DATABASE 'execute_attach_test.db' AS 'attach.db'");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute attach sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -271,8 +272,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("DETACH DATABASE 'attach.db'");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute detach sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -280,8 +281,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("BEGIN TRANSACTION");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute begin transaction sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -289,8 +290,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("COMMIT");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute commit sql failed, code:${err.code}, message: ${err.message}`);
         }
 
@@ -298,8 +299,8 @@ describe('rdbStoreExcuteTest', function () {
             rdbStore.executeSync("ROLLBACK");
             expect(null).assertFail();
         } catch (err) {
-            // 14800000: inner error
-            expect(14800000).assertEqual(err.code);
+            // 14800021: SQLite: Generic error.
+            expect(14800021).assertEqual(err.code);
             console.error(`execute rollback sql failed, code:${err.code}, message: ${err.message}`);
         }
         done();
@@ -343,7 +344,6 @@ describe('rdbStoreExcuteTest', function () {
      * @tc.desc 1. Create table
      *          2. Insert data
      *          3. Query data
-     *          4. Drop table
      */
     it('testSyncExecute0012', 0, async function (done) {
         console.info(TAG + "************* testSyncExecute0012 start *************");
@@ -460,5 +460,125 @@ describe('rdbStoreExcuteTest', function () {
         console.info(TAG + "************* testSyncExecute0016 end   *************");
     })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Execute_0017
+     * @tc.name AbNormal test case of Execute, if sql is invalid
+     * @tc.desc 1. Insert data
+     *          2. Check returned value
+     */
+    it('testSyncExecute0017', 0, async function (done) {
+        console.info(TAG + "************* testSyncExecute0017 start *************");
+        try {
+            rdbStore.executeSync("11111");
+            expect().assertFail();
+        } catch (err) {
+            expect(14800021).assertEqual(err.code);
+            console.error(`insert data failed, code:${err.code}, message: ${err.message}`);
+        }
+        done();
+        console.info(TAG + "************* testSyncExecute0017 end   *************");
+    })
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Execute_0018
+     * @tc.name Normal test case of Execute, if special characters before the sql
+     * @tc.desc 1. Create table
+     *          2. Insert data
+     *          3. Query data
+     */
+    it('testSyncExecute0018', 0, async function (done) {
+        console.info(TAG + "************* testSyncExecute0018 start *************");
+        try {
+            rdbStore.executeSync("   CREATE TABLE IF NOT EXISTS test2 (" +
+                "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+                "name TEXT NOT NULL, age INTEGER, salary REAL, blobType BLOB)");
+
+            let ret = rdbStore.executeSync("\r\nINSERT INTO test2(name, age, salary) VALUES (?, ?, ?)", ['tt', 28, 50000]);
+            expect(1).assertEqual(ret);
+
+            let resultSet = await rdbStore.querySql("SELECT * FROM test2");
+            expect(1).assertEqual(resultSet.rowCount)
+            resultSet.close();
+        } catch (err) {
+            expect(null).assertFail();
+            console.error(`execute sql failed, code:${err.code}, message: ${err.message}`);
+        }
+        done();
+        console.info(TAG + "************* testSyncExecute0018 end   *************");
+    })
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Insert_0010
+     * @tc.name Abnormal test case of sync
+     * @tc.desc 1.Close rdbStore
+     *          2.Call beginTransaction
+     */
+    it('testSyncExecute0019', 0, async function () {
+        console.log(TAG + "************* testSyncExecute0019 start *************");
+
+        const STORE_NAME = "AfterCloseTest.db"
+        const config = {
+            "name": STORE_NAME,
+            securityLevel: relationalStore.SecurityLevel.S1,
+        }
+        const rdbStore = await relationalStore.getRdbStore(context, config);
+
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            const predicates = new relationalStore.RdbPredicates('test');
+            predicates.inDevices(['573f'])
+            await rdbStore.sync(relationalStore.SyncMode.SYNC_MODE_PUSH, predicates)
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncExecute0019 end *************");
+    })
+
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Insert_0020
+     * @tc.name Normal test case of ExecuteSql
+     * @tc.desc 1.Close rdbStore
+     *          2.Call beginTransaction
+     */
+    it('testSyncExecute0020', 0, async function () {
+        console.log(TAG + "************* testSyncExecute0020 start *************");
+
+        const STORE_NAME = "AfterCloseTest.db"
+        const config = {
+            "name": STORE_NAME,
+            securityLevel: relationalStore.SecurityLevel.S1,
+        }
+        const rdbStore = await relationalStore.getRdbStore(context, config);
+
+        try {
+            await rdbStore.close();
+            console.info(`${TAG} close succeeded`);
+        } catch (err) {
+            console.error(`${TAG} close failed, code is ${err.code},message is ${err.message}`);
+        }
+
+        try {
+            const predicates = new relationalStore.RdbPredicates('test');
+            predicates.inDevices(['573f'])
+            await rdbStore.cloudSync(relationalStore.SyncMode.SYNC_MODE_PUSH, () => {})
+            expect(null).assertFail();
+        } catch (err) {
+            console.log(TAG + "catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+
+        await relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncExecute0020 end *************");
+    })
     console.info(TAG + "*************Unit Test End*************");
 })
\ No newline at end of file
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateJsunit.test.js
index 7a7bd86aa75723fa81342abf224f64875805cce4..bee4341e1198ab686e94d268168b60f442b1f54d 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateJsunit.test.js
@@ -432,6 +432,73 @@ describe('rdbStoreUpdateTest', function () {
         console.log(TAG + "************* testRdbStoreUpdate0008 end *************");
     })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Update_0009
+     * @tc.name Abnormal test case of update, if rdbStore is already close
+     * @tc.desc 1.Create value
+     *          2.Close rdbStore
+     *          3.Configure predicates
+     *          4.Execute update
+     */
+    it('testRdbStoreUpdate0009', 0, async function () {
+        console.log(TAG + "************* testRdbStoreUpdate0009 start *************");
+
+        const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+        const STORE_NAME = "AfterCloseTest.db";
+        const rdbStore = await data_relationalStore.getRdbStore(
+            context,
+            {
+                name: STORE_NAME,
+                securityLevel: data_relationalStore.SecurityLevel.S1
+            }
+        )
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
+
+
+        var u8 = new Uint8Array([1, 2, 3]);
+        try {
+            const valueBucket = {
+                "name": "zhangsan",
+                "age": 18,
+                "salary": 100.5,
+                "blobType": u8,
+            }
+            let ret = await rdbStore.insert("test", valueBucket);
+            expect(ret > -1).assertTrue();
+        } catch (err) {
+            console.log(TAG + `failed, err: ${JSON.stringify(err)}`)
+            expect().assertFail()
+        }
+        
+        await rdbStore.close().then(() => {
+            console.info(`close succeeded`);
+        }).catch((err) => {
+            console.error(`close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        try {
+            var u8 = new Uint8Array([4, 5, 6])
+            const valueBucket = {
+                "name": "lisi",
+                "age": 20,
+                "salary": 200.5,
+                "blobType": u8,
+            }
+            let predicates = new data_relationalStore.RdbPredicates("test")
+            predicates.equalTo("id", "1")
+            let ret = await rdbStore.update(valueBucket, predicates)
+            expect(1).assertEqual(ret);
+            console.log(TAG + "update done: " + ret);
+        } catch (err) {
+            console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testRdbStoreUpdate0009 end   *************");
+    })
+
     /**
      * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateWithConflictResolution_0001
      * @tc.name Normal test case of update
diff --git a/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateSyncJsunit.test.js b/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateSyncJsunit.test.js
index 9f8557f5fffbdf436872e868ec01444409440aff..9562b107a5bf697cb70fb9817a21f3f78fc7406a 100644
--- a/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateSyncJsunit.test.js
+++ b/relational_store/test/js/relationalstore/unittest/src/RdbstoreUpdateSyncJsunit.test.js
@@ -432,6 +432,71 @@ describe('rdbStoreUpdateSyncTest', function () {
         console.log(TAG + "************* testSyncRdbStoreUpdate0008 end *************");
     })
 
+    /**
+     * @tc.number SUB_DDM_AppDataFWK_JSRDB_Update_0009
+     * @tc.name Abnormal test case of updateSync, if rdbStore is already close
+     * @tc.desc 1.Create value
+     *          2.Close rdbStore
+     *          3.Configure predicates
+     *          4.Execute update
+     */
+    it('testSyncRdbStoreUpdate0009', 0, async function () {
+        console.log(TAG + "************* testSyncRdbStoreUpdate0009 start *************");
+
+        const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "name TEXT UNIQUE, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
+        const STORE_NAME = "AfterCloseTest.db";
+        const rdbStore = await data_relationalStore.getRdbStore(
+            context,
+            {
+                name: STORE_NAME,
+                securityLevel: data_relationalStore.SecurityLevel.S1
+            }
+        )
+        await rdbStore.executeSql(CREATE_TABLE_TEST);
+
+        var u8 = new Uint8Array([1, 2, 3]);
+        try {
+            const valueBucket = {
+                "name": "zhangsan",
+                "age": 18,
+                "salary": 100.5,
+                "blobType": u8,
+            }
+            await rdbStore.insert("test", valueBucket)
+        } catch (err) {
+            console.log(TAG + `failed, err: ${JSON.stringify(err)}`)
+            expect().assertFail()
+        }
+        
+        await rdbStore.close().then(() => {
+            console.info(`close succeeded`);
+        }).catch((err) => {
+            console.error(`close failed, code is ${err.code},message is ${err.message}`);
+        })
+
+        try {
+            var u8 = new Uint8Array([4, 5, 6])
+            const valueBucket = {
+                "name": "lisi",
+                "age": 20,
+                "salary": 200.5,
+                "blobType": u8,
+            }
+            let predicates = new data_relationalStore.RdbPredicates("test")
+            predicates.equalTo("id", "1")
+            let ret = rdbStore.updateSync(valueBucket, predicates)
+            expect(1).assertEqual(ret);
+            console.log(TAG + "update done: " + ret);
+        } catch (err) {
+            console.log("catch err: failed, err: code=" + err.code + " message=" + err.message)
+            expect("14800014").assertEqual(err.code)
+        }
+        
+        await data_relationalStore.deleteRdbStore(context, STORE_NAME);
+        console.log(TAG + "************* testSyncRdbStoreUpdate0009 end   *************");
+    })
+
     /**
      * @tc.number SUB_DDM_AppDataFWK_JSRDB_UpdateWithConflictResolution_0001
      * @tc.name Normal test case of update
diff --git a/relational_store/test/native/appdatafwk/unittest/serializable_test.cpp b/relational_store/test/native/appdatafwk/unittest/serializable_test.cpp
index 958350f74d2ebf95bfb174a555aaecb31e91ca2e..4744e929a51fb690bca4710a513148bb005870ba 100644
--- a/relational_store/test/native/appdatafwk/unittest/serializable_test.cpp
+++ b/relational_store/test/native/appdatafwk/unittest/serializable_test.cpp
@@ -13,10 +13,12 @@
  * limitations under the License.
  */
 #define LOG_TAG "SerializableTest"
-#include <type_traits>
-#include "logger.h"
 #include "serializable.h"
+
+#include <type_traits>
+
 #include "gtest/gtest.h"
+#include "logger.h"
 
 using namespace testing::ext;
 namespace OHOS::Test {
@@ -54,16 +56,16 @@ public:
             GetValue(node, GET_NAME(colRow), colRow);
             return true;
         }
-        bool operator == (const Normal &ref) const
+        bool operator==(const Normal &ref) const
         {
-            return name == ref.name && count == ref.count && status == ref.status && value == ref.value
-                && isClear == ref.isClear && cols == ref.cols;
+            return name == ref.name && count == ref.count && status == ref.status && value == ref.value &&
+                   isClear == ref.isClear && cols == ref.cols;
         }
     };
 
     struct NormalEx final : public Serializable {
     public:
-        std::vector<Normal> normals {Normal(), Normal()};
+        std::vector<Normal> normals{ Normal(), Normal() };
         Normal normal;
         int32_t count = 123;
         std::string name = "wdt";
@@ -124,7 +126,7 @@ HWTEST_F(SerializableTest, GetNormalVal, TestSize.Level2)
     normal.status = 12;
     normal.value = -56;
     normal.isClear = true;
-    normal.cols = {"adfasdfas"};
+    normal.cols = { "adfasdfas" };
     auto jstr = to_string(normal.Marshall());
     Normal normal1;
     normal1.Unmarshall(jstr);
@@ -152,7 +154,7 @@ HWTEST_F(SerializableTest, DeleteSerializable, TestSize.Level2)
 HWTEST_F(SerializableTest, GetMutilVal, TestSize.Level2)
 {
     NormalEx normalEx;
-    normalEx.normals = {Normal()};
+    normalEx.normals = { Normal() };
     normalEx.name = "normalEx";
     auto jstr = to_string(normalEx.Marshall());
     NormalEx normal1;
@@ -172,4 +174,52 @@ HWTEST_F(SerializableTest, IsJson, TestSize.Level1)
     ASSERT_FALSE(Serializable::IsJson(str));
     ASSERT_TRUE(Serializable::IsJson(jsonStr));
 }
+
+/**
+* @tc.name: ToJson_01
+* @tc.desc: to json.
+* @tc.type: FUNC
+*/
+HWTEST_F(SerializableTest, ToJson_01, TestSize.Level1)
+{
+    std::string jsonStr = "{\"key\":\"value\"}";
+    Serializable::json result = Serializable::ToJson(jsonStr);
+    ASSERT_FALSE(result.is_discarded());
+}
+
+/**
+* @tc.name: ToJson_02
+* @tc.desc: to json.
+* @tc.type: FUNC
+*/
+HWTEST_F(SerializableTest, ToJson_02, TestSize.Level1)
+{
+    std::string jsonStr = "invalid_json";
+    Serializable::json result = Serializable::ToJson(jsonStr);
+    ASSERT_FALSE(result.is_discarded());
+}
+
+/**
+* @tc.name: ToJson_03
+* @tc.desc: to json.
+* @tc.type: FUNC
+*/
+HWTEST_F(SerializableTest, ToJson_03, TestSize.Level1)
+{
+    std::string jsonStr = "";
+    Serializable::json result = Serializable::ToJson(jsonStr);
+    ASSERT_TRUE(result.empty());
+}
+
+/**
+* @tc.name: ToJson_04
+* @tc.desc: to json.
+* @tc.type: FUNC
+*/
+HWTEST_F(SerializableTest, ToJson_04, TestSize.Level1)
+{
+    std::string jsonStr = "{invalid_json}";
+    Serializable::json result = Serializable::ToJson(jsonStr);
+    ASSERT_FALSE(result.is_discarded());
+}
 } // namespace OHOS::Test
\ No newline at end of file
diff --git a/relational_store/test/native/dataability/unittest/data_ability_predicates_test.cpp b/relational_store/test/native/dataability/unittest/data_ability_predicates_test.cpp
index ed94a1713c87058fd2c1c2e9d89df0ef2b78962f..d1c664d759b1edf55e2b09a252a668bf84673e69 100644
--- a/relational_store/test/native/dataability/unittest/data_ability_predicates_test.cpp
+++ b/relational_store/test/native/dataability/unittest/data_ability_predicates_test.cpp
@@ -13,12 +13,14 @@
  * limitations under the License.
  */
 
+#include "data_ability_predicates.h"
+
 #include <gtest/gtest.h>
+
 #include <vector>
 
-#include "data_ability_predicates.h"
-#include "refbase.h"
 #include "predicates_utils.h"
+#include "refbase.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -61,11 +63,13 @@ HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_002, TestSize.Level1)
     DataAbilityPredicates *predicates1 = new DataAbilityPredicates();
 
     predicates1->EqualTo("stringValue", "ABCDEFGHIJKLMN")
-            ->BeginWrap()
-            ->EqualTo("integerValue", "1")
-            ->Or()
-            ->EqualTo("integerValue", MAX)
-            ->EndWrap()->OrderByDesc("integerValue")->Limit(2);
+        ->BeginWrap()
+        ->EqualTo("integerValue", "1")
+        ->Or()
+        ->EqualTo("integerValue", MAX)
+        ->EndWrap()
+        ->OrderByDesc("integerValue")
+        ->Limit(2);
 
     EXPECT_EQ(true, predicates1->GetLimit() == 2);
 
@@ -96,7 +100,7 @@ HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_003, TestSize.Level1)
 {
     DataAbilityPredicates *predicates = new DataAbilityPredicates();
     predicates->SetWhereClause("`name` = ? ");
-    std::vector<std::string> whereArgsArray = {"zhangsan", "lisi"};
+    std::vector<std::string> whereArgsArray = { "zhangsan", "lisi" };
     predicates->SetWhereArgs(whereArgsArray);
     predicates->SetOrder("ASC");
     OHOS::Parcel outParcel(0);
@@ -202,7 +206,7 @@ HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_009, TestSize.Level1)
 {
     DataAbilityPredicates *predicates = new DataAbilityPredicates();
     predicates->SetWhereClause("`name` = ? ");
-    std::vector<std::string> whereArgsArray = {"zhangsan", "lisi"};
+    std::vector<std::string> whereArgsArray = { "zhangsan", "lisi" };
     predicates->SetWhereArgs(whereArgsArray);
     predicates->SetOrder("ASC");
     OHOS::Parcel outParcel(0);
@@ -228,7 +232,7 @@ HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_009, TestSize.Level1)
 HWTEST_F(DataAbilityPredicatesTest, DataAbilityPredicates_010, TestSize.Level1)
 {
     DataAbilityPredicates *predicates = new DataAbilityPredicates();
-    std::vector<std::string> group = {"salary"};
+    std::vector<std::string> group = { "salary" };
     predicates->GreaterThan("age", "20")->OrderByAsc("age")->GroupBy(group)->Limit(3)->Offset(1);
 
     OHOS::Parcel outParcel(0);
diff --git a/relational_store/test/native/rdb/BUILD.gn b/relational_store/test/native/rdb/BUILD.gn
index 2ae2a3ab08de1864a21482e2e3c3d91bf4be261e..8ea7afb22b88928045cc5888ac9f76f01d100a7b 100644
--- a/relational_store/test/native/rdb/BUILD.gn
+++ b/relational_store/test/native/rdb/BUILD.gn
@@ -23,6 +23,7 @@ config("module_private_config") {
     "${relational_store_common_path}/include",
     "${relational_store_native_path}/rdb/include",
     "${relational_store_innerapi_path}/rdb/include",
+    "${relational_store_native_path}/dfx/include",
     "${relational_store_native_path}/rdb/src",
     "${relational_store_innerapi_path}/appdatafwk/include",
     "//commonlibrary/c_utils/base/include",
@@ -73,12 +74,17 @@ ohos_unittest("NativeRdbTest") {
   module_out_path = module_output_path
 
   sources = [
+    "unittest/big_integer_test.cpp",
     "unittest/cache_result_set_test.cpp",
     "unittest/common.cpp",
+    "unittest/connection_test.cpp",
+    "unittest/raw_data_parser_test.cpp",
+    "unittest/rd_utils_test.cpp",
     "unittest/rdb_attach_test.cpp",
     "unittest/rdb_bigint_test.cpp",
     "unittest/rdb_delete_test.cpp",
     "unittest/rdb_distributed_test.cpp",
+    "unittest/rdb_double_write_test.cpp",
     "unittest/rdb_encrypt_decrypt_test.cpp",
     "unittest/rdb_execute_test.cpp",
     "unittest/rdb_get_store_test.cpp",
@@ -89,6 +95,8 @@ ohos_unittest("NativeRdbTest") {
     "unittest/rdb_predicates_join_test.cpp",
     "unittest/rdb_predicates_test.cpp",
     "unittest/rdb_read_only_test.cpp",
+    "unittest/rdb_security_manager_test.cpp",
+    "unittest/rdb_sql_utils_test.cpp",
     "unittest/rdb_sqlite_shared_result_set_test.cpp",
     "unittest/rdb_step_result_get_row_test.cpp",
     "unittest/rdb_step_result_set_test.cpp",
@@ -104,24 +112,29 @@ ohos_unittest("NativeRdbTest") {
     "unittest/rdb_utils_test.cpp",
     "unittest/rdb_value_bucket_test.cpp",
     "unittest/rdb_wal_limit_test.cpp",
+    "unittest/value_object_test.cpp",
   ]
 
   sources += [
+    "../../../frameworks/native/rdb/mock/src/rdb_fault_hiview_reporter.cpp",
     "../../../frameworks/native/rdb/src/base_transaction.cpp",
     "../../../frameworks/native/rdb/src/connection.cpp",
+    "../../../frameworks/native/rdb/src/connection_pool.cpp",
     "../../../frameworks/native/rdb/src/grd_api_manager.cpp",
     "../../../frameworks/native/rdb/src/raw_data_parser.cpp",
     "../../../frameworks/native/rdb/src/rd_connection.cpp",
     "../../../frameworks/native/rdb/src/rd_statement.cpp",
     "../../../frameworks/native/rdb/src/rd_utils.cpp",
     "../../../frameworks/native/rdb/src/rdb_local_db_observer.cpp",
+    "../../../frameworks/native/rdb/src/rdb_manager_impl.cpp",
+    "../../../frameworks/native/rdb/src/rdb_notifier_stub.cpp",
     "../../../frameworks/native/rdb/src/rdb_security_manager.cpp",
+    "../../../frameworks/native/rdb/src/rdb_service_proxy.cpp",
     "../../../frameworks/native/rdb/src/rdb_sql_statistic.cpp",
     "../../../frameworks/native/rdb/src/result_set_proxy.cpp",
     "../../../frameworks/native/rdb/src/share_block.cpp",
     "../../../frameworks/native/rdb/src/shared_block_serializer_info.cpp",
     "../../../frameworks/native/rdb/src/sqlite_connection.cpp",
-    "../../../frameworks/native/rdb/src/sqlite_connection_pool.cpp",
     "../../../frameworks/native/rdb/src/sqlite_global_config.cpp",
     "../../../frameworks/native/rdb/src/sqlite_shared_result_set.cpp",
     "../../../frameworks/native/rdb/src/sqlite_sql_builder.cpp",
@@ -141,6 +154,7 @@ ohos_unittest("NativeRdbTest") {
     "huks:libhukssdk",
     "ipc:ipc_core",
     "kv_store:distributeddb",
+    "samgr:samgr_proxy",
   ]
 
   deps = [
@@ -169,7 +183,9 @@ group("fuzztest") {
   deps = []
   deps += [
     "fuzztest/rdbimpl_fuzzer:fuzztest",
+    "fuzztest/rdbrdutils_fuzzer:fuzztest",
     "fuzztest/rdbstore_fuzzer:fuzztest",
+    "fuzztest/rdstatement_fuzzer:fuzztest",
   ]
 }
 
diff --git a/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test.cpp b/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test.cpp
index 08c72d10717b1d50952799311706c000d671000a..c4feffa721bd4f46bd155c337290e7e8abd91e70 100644
--- a/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test.cpp
+++ b/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test.cpp
@@ -15,10 +15,13 @@
 
 #include <gtest/gtest.h>
 
+#include <regex>
 #include <string>
 #include <vector>
+
 #include "device_manager.h"
 #include "device_manager_callback.h"
+#include "distributed_major.h"
 #include "dm_device_info.h"
 #include "hilog/log.h"
 #include "rdb_errno.h"
@@ -28,10 +31,6 @@
 #include "rdb_types.h"
 #include "result_set_proxy.h"
 
-#include <regex>
-
-#include "distributed_major.h"
-
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
 using namespace OHOS::DistributedRdb;
@@ -39,9 +38,9 @@ using namespace testing::ext;
 using namespace OHOS::DistributeSystemTest;
 using namespace OHOS::DistributedHardware;
 using namespace OHOS::HiviewDFX;
-namespace  {
+namespace {
 const int MSG_LENGTH = 100;
-constexpr HiLogLabel LABEL = {LOG_CORE, 0, "DistributedTest"};
+constexpr HiLogLabel LABEL = { LOG_CORE, 0, "DistributedTest" };
 static const std::string RDB_TEST_PATH = "/data/test/";
 constexpr const char *PKG_NAME = "rdb_store_distributed_test";
 class DistributedTest : public DistributeTest {
@@ -53,7 +52,7 @@ public:
 
     static const std::string DATABASE_NAME;
     static std::shared_ptr<RdbStore> store_;
-    static std::vector <DmDeviceInfo> deviceInfos_;
+    static std::vector<DmDeviceInfo> deviceInfos_;
     static void InitDevManager();
 };
 
@@ -63,17 +62,31 @@ std::vector<DmDeviceInfo> DistributedTest::deviceInfos_;
 
 class DMStateCallback : public DeviceStateCallback {
 public:
-    explicit DMStateCallback() {}
-    void OnDeviceOnline(const DmDeviceInfo &deviceInfo) override {}
-    void OnDeviceOffline(const DmDeviceInfo &deviceInfo) override {}
-    void OnDeviceChanged(const DmDeviceInfo &deviceInfo) override {}
-    void OnDeviceReady(const DmDeviceInfo &deviceInfo) override {}
+    explicit DMStateCallback()
+    {
+    }
+    void OnDeviceOnline(const DmDeviceInfo &deviceInfo) override
+    {
+    }
+    void OnDeviceOffline(const DmDeviceInfo &deviceInfo) override
+    {
+    }
+    void OnDeviceChanged(const DmDeviceInfo &deviceInfo) override
+    {
+    }
+    void OnDeviceReady(const DmDeviceInfo &deviceInfo) override
+    {
+    }
 };
 
 class DmDeathCallback : public DmInitCallback {
 public:
-    explicit DmDeathCallback() {}
-    void OnRemoteDied() override {}
+    explicit DmDeathCallback()
+    {
+    }
+    void OnRemoteDied() override
+    {
+    }
 };
 
 void DistributedTest::InitDevManager()
@@ -92,10 +105,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string DistributedTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                                + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                              "name TEXT NOT NULL, age INTEGER, salary "
-                                                                              "REAL, blobType BLOB)");
+const std::string DistributedTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int DistributedTestOpenCallback::OnCreate(RdbStore &store_)
 {
@@ -131,7 +144,8 @@ void DistributedTest::SetUp(void)
 }
 
 void DistributedTest::TearDown(void)
-{}
+{
+}
 
 /**
  * @tc.name: RemoteQuery001
@@ -145,12 +159,11 @@ HWTEST_F(DistributedTest, RemoteQuery001, TestSize.Level1)
     int ret;
     std::string returvalue;
     std::string msgBuf = "recall function message test.";
-    ret = SendMessage(AGENT_NO::ONE, msgBuf, MSG_LENGTH,
-        [&](const std::string &szreturnbuf, int rlen)->bool {
+    ret = SendMessage(AGENT_NO::ONE, msgBuf, MSG_LENGTH, [&](const std::string &szreturnbuf, int rlen) -> bool {
         returvalue = szreturnbuf;
         return true;
     });
-    std::vector<std::string> tables = {"test"};
+    std::vector<std::string> tables = { "test" };
     DeviceManager::GetInstance().GetTrustedDeviceList(PKG_NAME, "", deviceInfos_);
     int errCode = E_ERROR;
     std::string test = store_->ObtainDistributedTableName(deviceInfos_[0].networkId, tables[0], errCode);
@@ -164,7 +177,6 @@ HWTEST_F(DistributedTest, RemoteQuery001, TestSize.Level1)
     EXPECT_EQ(returvalue, "zhangsan");
 }
 
-
 /**
  * @tc.name: ResultSetProxy001
  * @tc.desc: Abnormal testcase of distributed ResultSetProxy, if resultSet is Empty
@@ -206,7 +218,7 @@ HWTEST_F(DistributedTest, ResultSetProxy001, TestSize.Level1)
     errCode = resultSet->IsColumnNull(1, isNull);
     EXPECT_NE(E_OK, errCode);
 }
-}
+} // namespace
 
 int main(int argc, char *argv[])
 {
diff --git a/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test_agent.cpp b/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test_agent.cpp
index 00ce01bda943c7edeaa05eda41ed2db2a112b5a2..694dc7acca25d1f804f67b43da384ee5c31ac8c8 100644
--- a/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test_agent.cpp
+++ b/relational_store/test/native/rdb/distributedtest/rdb_store_impl_test/distributed_test_agent.cpp
@@ -15,9 +15,11 @@
 
 #include <gtest/gtest.h>
 
+#include <regex>
 #include <string>
 #include <vector>
-#include <regex>
+
+#include "distributed_agent.h"
 #include "hilog/log.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
@@ -25,8 +27,6 @@
 #include "rdb_store_impl.h"
 #include "rdb_types.h"
 
-#include "distributed_agent.h"
-
 using namespace testing;
 using namespace OHOS;
 using namespace OHOS::NativeRdb;
@@ -35,7 +35,7 @@ using namespace OHOS::DistributedRdb;
 using namespace OHOS::HiviewDFX;
 
 namespace {
-constexpr HiLogLabel LABEL = {LOG_CORE, 0, "DistributedTestAgent"};
+constexpr HiLogLabel LABEL = { LOG_CORE, 0, "DistributedTestAgent" };
 static const std::string RDB_TEST_PATH = "/data/test/";
 static constexpr int AGE = 18;
 static constexpr double SALARY = 100.5;
@@ -56,7 +56,6 @@ public:
 const std::string DistributedTestAgent::DATABASE_NAME = RDB_TEST_PATH + "distributed_rdb.db";
 std::shared_ptr<RdbStore> DistributedTestAgent::store_ = nullptr;
 
-
 class DistributedTestOpenCallback : public RdbOpenCallback {
 public:
     int OnCreate(RdbStore &store) override;
@@ -64,10 +63,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string DistributedTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                                + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                              "name TEXT NOT NULL, age INTEGER, salary "
-                                                                              "REAL, blobType BLOB)");
+const std::string DistributedTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int DistributedTestOpenCallback::OnCreate(RdbStore &store)
 {
@@ -80,10 +79,12 @@ int DistributedTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int
 }
 
 DistributedTestAgent::DistributedTestAgent()
-{}
+{
+}
 
 DistributedTestAgent::~DistributedTestAgent()
-{}
+{
+}
 
 bool DistributedTestAgent::SetUp()
 {
@@ -112,10 +113,10 @@ int DistributedTestAgent::OnProcessMsg(const std::string &strMsg, int len, std::
     values.PutString("name", std::string("zhangsan"));
     values.PutInt("age", AGE);
     values.PutDouble("salary", SALARY);
-    values.PutBlob("blobType", std::vector<uint8_t> { 1, 2, 3 });
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
     int status = -2;
 
-    std::vector<std::string> tables = {"test"};
+    std::vector<std::string> tables = { "test" };
     store_->SetDistributedTables(tables);
 
     status = store_->Insert(id, "test", values);
@@ -125,8 +126,8 @@ int DistributedTestAgent::OnProcessMsg(const std::string &strMsg, int len, std::
     predicate.InAllDevices();
 
     std::shared_ptr<ResultSet> resultSet =
-        store_->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string> { "zhangsan" });
-    if (resultSet!= nullptr) {
+        store_->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
+    if (resultSet != nullptr) {
         int position;
         int columnIndex;
         std::string strVal;
@@ -140,7 +141,7 @@ int DistributedTestAgent::OnProcessMsg(const std::string &strMsg, int len, std::
     }
     return strReturnValue.size();
 }
-}
+} // namespace
 
 int main()
 {
diff --git a/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/BUILD.gn
index 2f6508fdf3f87bda52491c61f17962b0728fd756..7b03f3c3c097a58f722e956977eadfefde70d117 100644
--- a/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/BUILD.gn
+++ b/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/BUILD.gn
@@ -23,20 +23,19 @@ ohos_fuzztest("RdbImplFuzzTest") {
   include_dirs = [
     "${relational_store_native_path}/rdb/include",
     "${relational_store_innerapi_path}/rdb/include",
-    "//foundation/distributeddatamgr/kv_store/frameworks/innerkitsimpl/rdb",
-    "//foundation/distributeddatamgr/kv_store/frameworks/innerkitsimpl/rdb/include",
-    "//commonlibrary/c_utils/base/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
     "${common_tool_path}/",
     "//third_party/sqlite/include",
-    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
     "//third_party/jsoncpp/include/json",
     "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
     "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
     "//third_party/jsoncpp/include/json",
     "//third_party/grpc/src/core/lib/json",
-    "//foundation/systemabilitymgr/safwk/services/safwk/include",
-    "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include",
-    "//base/security/dataclassification/interfaces/innerkits/datatransmitmgr/include",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
     "//third_party/json/single_include",
     "//third_party/googletest/googletest/include/gtest",
   ]
@@ -54,8 +53,8 @@ ohos_fuzztest("RdbImplFuzzTest") {
   sources = [ "rdbimpl_fuzzer.cpp" ]
 
   deps = [
-    "//foundation/distributeddatamgr/kv_store/frameworks/libs/distributeddb:distributeddb",
-    "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
     "//third_party/jsoncpp:jsoncpp",
   ]
 
diff --git a/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/project.xml
index be92381e05fc528d2fba5603365ee6df71b5b840..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec 100644
--- a/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/project.xml
+++ b/relational_store/test/native/rdb/fuzztest/rdbimpl_fuzzer/project.xml
@@ -18,7 +18,7 @@
     <!-- maximum length of a test input -->
     <max_len>1000</max_len>
     <!-- maximum total time in seconds to run the fuzzer -->
-    <max_total_time>30</max_total_time>
+    <max_total_time>300</max_total_time>
     <!-- memory usage limit in Mb -->
     <rss_limit_mb>4096</rss_limit_mb>
   </fuzztest>
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..64301965b8e952f8a02e7fc35d529163c3f474d4
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/BUILD.gn
@@ -0,0 +1,27 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+group("fuzztest") {
+  testonly = true
+  deps = [
+    "rddbopen_fuzzer:fuzztest",
+    "rddbrepair_fuzzer:fuzztest",
+    "transfergrderrno_fuzzer:fuzztest",
+    "transfergrdtypetocoltype_fuzzer:fuzztest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..772d2847f081292e39db60ad3cd3a0648ba454af
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RddbopenFuzzTest") {
+  module_out_path = "relational_store/relational_store"
+
+  include_dirs = [
+    "${relational_store_native_path}/rdb/include",
+    "${relational_store_innerapi_path}/rdb/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
+    "${common_tool_path}/",
+    "//third_party/sqlite/include",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
+    "//third_party/json/single_include",
+    "//third_party/googletest/googletest/include/gtest",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "${relational_store_base_path}/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer"
+
+  sources = [ "rddbopen_fuzzer.cpp" ]
+
+  deps = [
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "//third_party/jsoncpp:jsoncpp",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:dataobs_manager",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RddbopenFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/corpus/init b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a48423641f5459d5cad9793b03f429c8d8e5c000
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.cpp
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rd_utils.h"
+#include "rdb_errno.h"
+#include "rdb_store_config.h"
+#include "rdb_store_impl.h"
+
+#define DOUBLE_SIZE 8
+#define INT_SIZE 4
+
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+namespace OHOS {
+
+uint32_t ConvertToUint32(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || (size < sizeof(uint32_t))) {
+        return 0;
+    }
+    return *(reinterpret_cast<const uint32_t *>(ptr));
+}
+
+int32_t ConvertToInt32(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || (size < sizeof(int32_t))) {
+        return 0;
+    }
+    return *(reinterpret_cast<const int32_t *>(ptr));
+}
+
+int64_t ConvertToInt64(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || (size < sizeof(int64_t))) {
+        return 0;
+    }
+    return *(reinterpret_cast<const int64_t *>(ptr));
+}
+
+double ConvertToDouble(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || size < DOUBLE_SIZE) {
+        return 0;
+    }
+    double fa = 0;
+    uint8_t uc[DOUBLE_SIZE];
+    for (int i = 0; i < DOUBLE_SIZE; i++) {
+        uc[i] = ptr[i];
+    }
+    errno_t err = memcpy_s(&fa, DOUBLE_SIZE, uc, DOUBLE_SIZE);
+    if (err < 0) {
+        return 0;
+    }
+    return fa;
+}
+
+float ConvertToFloat(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || size < INT_SIZE) {
+        return 0;
+    }
+    float fa = 0;
+    uint8_t uc[INT_SIZE];
+    for (int i = 0; i < INT_SIZE; i++) {
+        uc[i] = ptr[i];
+    }
+    errno_t err = memcpy_s(&fa, INT_SIZE, uc, INT_SIZE);
+    if (err < 0) {
+        return 0;
+    }
+    return fa;
+}
+
+void RdDbOpenFuzzer(const uint8_t *data, size_t size)
+{
+    uint32_t unit32t = ConvertToUint32(data, size);
+    int32_t nit32t = ConvertToInt32(data, size);
+    int32_t nit64t = ConvertToInt64(data, size);
+    double doubleValue = ConvertToDouble(data, size);
+    GRD_DB *dbHandle_ = nullptr;
+    RdUtils::RdDbOpen(reinterpret_cast<const char *>(data), reinterpret_cast<const char *>(data), unit32t, &dbHandle_);
+    GRD_SqlStmt *stmtHandle = nullptr;
+    RdUtils::RdSqlPrepare(dbHandle_, reinterpret_cast<const char *>(data), size, &stmtHandle, nullptr);
+    RdUtils::RdSqlReset(stmtHandle);
+    RdUtils::RdSqlFinalize(stmtHandle);
+    RdUtils::RdSqlBindBlob(stmtHandle, unit32t, static_cast<const void *>(data), size, nullptr);
+    RdUtils::RdSqlBindText(stmtHandle, unit32t, static_cast<const void *>(data), size, nullptr);
+    RdUtils::RdSqlBindInt(stmtHandle, unit32t, nit32t);
+    RdUtils::RdSqlBindInt64(stmtHandle, unit32t, nit64t);
+    RdUtils::RdSqlBindDouble(stmtHandle, unit32t, doubleValue);
+    RdUtils::RdSqlBindNull(stmtHandle, unit32t);
+    float ft = ConvertToFloat(data, size);
+    float ftVec[1];
+    ftVec[0] = ft;
+    RdUtils::RdSqlBindFloatVector(stmtHandle, unit32t, ftVec, 1, nullptr);
+    RdUtils::RdDbClose(dbHandle_, unit32t);
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::RdDbOpenFuzzer(data, size);
+    return 0;
+}
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.h b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ec5dc5d03685ab632e4426c842ea311f8eb48d0
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbopen_fuzzer/rddbopen_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
+#define TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "transfergrdtypetocoltype_fuzzer"
+
+#endif // TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..718d50aecced404f6d079460538794d983cd3c0a
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RddbrepairFuzzerTest") {
+  module_out_path = "relational_store/relational_store"
+
+  include_dirs = [
+    "${relational_store_native_path}/rdb/include",
+    "${relational_store_innerapi_path}/rdb/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
+    "${common_tool_path}/",
+    "//third_party/sqlite/include",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
+    "//third_party/json/single_include",
+    "//third_party/googletest/googletest/include/gtest",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "${relational_store_base_path}/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer"
+
+  sources = [ "rddbrepair_fuzzer.cpp" ]
+
+  deps = [
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "//third_party/jsoncpp:jsoncpp",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:dataobs_manager",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RddbrepairFuzzerTest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/corpus/init b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c95c225ddb286caf07046d4615c16e050e0bb396
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rdb_store_config.h"
+#include "rdb_errno.h"
+#include "rdb_store_impl.h"
+#include "rd_utils.h"
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+namespace OHOS {
+
+void rddbrepairFuzzer(const uint8_t *data, size_t size)
+{
+    RdUtils::RdDbRepair(reinterpret_cast<const char *>(data), reinterpret_cast<const char *>(data));
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::rddbrepairFuzzer(data, size);
+    return 0;
+}
+
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.h b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a95b06c469c929051b4410701b1195aebfe4ffc
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/rddbrepair_fuzzer/rddbrepair_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RDDBREPAIR_FUZZER_H
+#define RDDBREPAIR_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "rddbrepair_fuzzer"
+
+#endif // RDDBREPAIR_FUZZER_H
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..9ebe4ea45b1bf2d3e7c6e41ad801406187a00e50
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RdbRdUtilsTransferGrdErrnoFuzzTest") {
+  module_out_path = "relational_store/relational_store"
+
+  include_dirs = [
+    "${relational_store_native_path}/rdb/include",
+    "${relational_store_innerapi_path}/rdb/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
+    "${common_tool_path}/",
+    "//third_party/sqlite/include",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
+    "//third_party/json/single_include",
+    "//third_party/googletest/googletest/include/gtest",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "${relational_store_base_path}/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer"
+
+  sources = [ "transfergrderrno_fuzzer.cpp" ]
+
+  deps = [
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "//third_party/jsoncpp:jsoncpp",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:dataobs_manager",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RdbRdUtilsTransferGrdErrnoFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/corpus/init b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b96efc1dfde5ca86a6f1539b0df8ae5759935665
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rdb_store_config.h"
+#include "rdb_errno.h"
+#include "rdb_store_impl.h"
+#include "rd_utils.h"
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+namespace OHOS {
+
+uint32_t ConvertToUint32(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || (size < sizeof(uint32_t))) {
+        return 0;
+    }
+    return *(reinterpret_cast<const uint32_t *>(ptr));
+}
+
+void RdUtilsTransferGrdErrnoFuzz(const uint8_t *data, size_t size)
+{
+    int err = ConvertToUint32(data, size);
+    RdUtils::TransferGrdErrno(err);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::RdUtilsTransferGrdErrnoFuzz(data, size);
+    return 0;
+}
+
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.h b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f11ac7c37f8caff94ee9192adbc67c8d1e419f7
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrderrno_fuzzer/transfergrderrno_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TRANSFER_GRD_FUZZER_H
+#define TRANSFER_GRD_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "transfergrderrno_fuzzer"
+
+#endif // TRANSFER_GRD_FUZZER_H
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..a897d9835ae44c82f9a20f8eab8d8d85a8b142c8
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("TransferGrdTypeToColTypeFuzzTest") {
+  module_out_path = "relational_store/relational_store"
+
+  include_dirs = [
+    "${relational_store_native_path}/rdb/include",
+    "${relational_store_innerapi_path}/rdb/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
+    "${common_tool_path}/",
+    "//third_party/sqlite/include",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
+    "//third_party/json/single_include",
+    "//third_party/googletest/googletest/include/gtest",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "${relational_store_base_path}/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer"
+
+  sources = [ "transfergrdtypetocoltype_fuzzer.cpp" ]
+
+  deps = [
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "//third_party/jsoncpp:jsoncpp",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:dataobs_manager",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":TransferGrdTypeToColTypeFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/corpus/init b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5fc3b633b35861a1cec0681d991da1a097dbfd78
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rdb_store_config.h"
+#include "rdb_errno.h"
+#include "rdb_store_impl.h"
+#include "rd_utils.h"
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+namespace OHOS {
+
+uint32_t ConvertToUint32(const uint8_t *ptr, size_t size)
+{
+    if (ptr == nullptr || (size < sizeof(uint32_t))) {
+        return 0;
+    }
+    return *(reinterpret_cast<const uint32_t *>(ptr));
+}
+
+void transferGrdTypeToColTypeFuzzer(const uint8_t *data, size_t size)
+{
+    int err = ConvertToUint32(data, size);
+    RdUtils::TransferGrdTypeToColType(err);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::transferGrdTypeToColTypeFuzzer(data, size);
+    return 0;
+}
+
diff --git a/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.h b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ec5dc5d03685ab632e4426c842ea311f8eb48d0
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdbrdutils_fuzzer/transfergrdtypetocoltype_fuzzer/transfergrdtypetocoltype_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
+#define TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "transfergrdtypetocoltype_fuzzer"
+
+#endif // TRANSFERGRDTYPETOCOLTYPE_FUZZER_H
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdbstore_fuzzer/rdbstore_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdbstore_fuzzer/rdbstore_fuzzer.cpp
index 575eb6b888badb7787ed65a328920430e1392a42..4c6599924732914511d34ffb108ea18591521839 100644
--- a/relational_store/test/native/rdb/fuzztest/rdbstore_fuzzer/rdbstore_fuzzer.cpp
+++ b/relational_store/test/native/rdb/fuzztest/rdbstore_fuzzer/rdbstore_fuzzer.cpp
@@ -13,11 +13,12 @@
  * limitations under the License.
  */
 
-#include "rdb_store.h"
-#include "rdb_helper.h"
+#include "rdbstore_fuzzer.h"
+
 #include "rdb_errno.h"
+#include "rdb_helper.h"
 #include "rdb_open_callback.h"
-#include "rdbstore_fuzzer.h"
+#include "rdb_store.h"
 
 using namespace OHOS;
 using namespace OHOS::NativeRdb;
@@ -92,7 +93,7 @@ bool RdbStoreFuzzTest::InsertData(std::shared_ptr<RdbStore> &store, const uint8_
     values.PutString("name", valName);
     values.PutInt("age", valAge);
     values.PutDouble("salary", valSalary);
-    values.PutBlob("blobType", std::vector<uint8_t> (data, data + size));
+    values.PutBlob("blobType", std::vector<uint8_t>(data, data + size));
 
     return store->Insert(id, tableName, values);
 }
@@ -166,10 +167,9 @@ bool RdbUpdateFuzz(const uint8_t *data, size_t size)
     values.PutString("name", valName);
     values.PutInt("age", valAge);
     values.PutDouble("salary", valSalary);
-    values.PutBlob("blobType", std::vector<uint8_t> (data, data + size));
+    values.PutBlob("blobType", std::vector<uint8_t>(data, data + size));
 
-    errCode = store->Update(changedRows, tableName, values, whereClause,
-        std::vector<std::string> { valName });
+    errCode = store->Update(changedRows, tableName, values, whereClause, std::vector<std::string>{ valName });
     if (errCode != E_OK) {
         result = false;
     }
@@ -342,39 +342,39 @@ void RdbQueryFuzz1(const uint8_t *data, size_t size)
     AbsRdbPredicates predicates(tableName);
 
     predicates.EqualTo("name", ValueObject(valName));
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.NotEqualTo("name", ValueObject(valName));
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.Contains("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.BeginsWith("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.EndsWith("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.Like("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.NotLike("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.NotContains("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
 
     predicates.Clear();
     predicates.Glob("name", valName);
-    store->Query(predicates, {vectorElem});
+    store->Query(predicates, { vectorElem });
     store->ExecuteSql("DELETE FROM test");
 }
 
@@ -395,8 +395,8 @@ void RdbQueryFuzz2(const uint8_t *data, size_t size)
     std::string valName(data, data + size);
     ValueObject valAge(std::string(data, data + size));
     ValueObject valAgeChange(std::string(data, data + size));
-    std::vector<std::string> bindaArgs({std::string(data, data + size)});
-    std::vector<ValueObject> vectorElem({std::string(data, data + size)});
+    std::vector<std::string> bindaArgs({ std::string(data, data + size) });
+    std::vector<ValueObject> vectorElem({ std::string(data, data + size) });
 
     AbsRdbPredicates predicates(tableName);
 
@@ -433,10 +433,10 @@ void RdbQueryFuzz2(const uint8_t *data, size_t size)
     store->Query(predicates, bindaArgs);
     store->ExecuteSql("DELETE FROM test");
 }
-}
+} // namespace OHOS
 
 /* Fuzzer entry point */
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     /* Run your code on data */
     OHOS::RdbStoreFuzzTest::SetUpTestCase();
diff --git a/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/BUILD.gn b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..fbd874f35b00f37e2ac689068a8e8092ea5f31a3
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/relational_store/relational_store.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("RdStatementFuzzTest") {
+  module_out_path = "relational_store/relational_store"
+
+  include_dirs = [
+    "${relational_store_native_path}/rdb/include",
+    "${relational_store_innerapi_path}/rdb/include",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb",
+    "${distributeddata_base_path}/kv_store/frameworks/innerkitsimpl/rdb/include",
+    "${common_tool_path}/",
+    "//third_party/sqlite/include",
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb/common/include/relational",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/skia/third_party/externals/spirv-headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/skia/third_party/externals/swiftshader/third_party/SPIRV-Headers/tools/buildHeaders/jsoncpp/dist/json",
+    "//third_party/jsoncpp/include/json",
+    "//third_party/grpc/src/core/lib/json",
+    "${foundation_systemabilitymgr_path}/safwk/services/safwk/include",
+    "${foundation_systemabilitymgr_path}/samgr/interfaces/innerkits/samgr_proxy/include",
+    "${base_security_dataclassification_path}/interfaces/innerkits/datatransmitmgr/include",
+    "//third_party/json/single_include",
+    "//third_party/googletest/googletest/include/gtest",
+  ]
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  fuzz_config_file = "${relational_store_base_path}/test/native/rdb/fuzztest/rdstatement_fuzzer"
+
+  sources = [ "rdstatement_fuzzer.cpp" ]
+
+  deps = [
+    "${distributeddata_base_path}/kv_store/frameworks/libs/distributeddb:distributeddb",
+    "${distributeddata_base_path}/relational_store/interfaces/inner_api/rdb:native_rdb_static",
+    "//third_party/jsoncpp:jsoncpp",
+  ]
+
+  external_deps = [
+    "ability_base:zuri",
+    "ability_runtime:dataobs_manager",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":RdStatementFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/corpus/init b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..bc977bd9738ee9a70b362067f57a9c63d3adb801
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/corpus/init
@@ -0,0 +1,14 @@
+# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FUZZ
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/project.xml b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8ad2cfde8f8bda4beb6cabbe7efd8bc3c54eec
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.cpp b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93aa52c9d46628c8cf93b1a2aa6f5b7015d9f01e
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rdb_store_config.h"
+#include "rdb_errno.h"
+#include "rdb_store_impl.h"
+#include "rd_statement.h"
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+namespace OHOS {
+void RdStatementPrepareFuzz(const uint8_t *data, size_t size)
+{
+    auto stmt = std::make_shared<RdStatement>();
+    std::string sqlString(reinterpret_cast<const char *>(data), size);
+    stmt->Prepare(sqlString);
+}
+}
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::RdStatementPrepareFuzz(data, size);
+    return 0;
+}
+
diff --git a/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.h b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..930edddd7181295ddac6c0a0a639b697c6e67d63
--- /dev/null
+++ b/relational_store/test/native/rdb/fuzztest/rdstatement_fuzzer/rdstatement_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RDSTATEMENT_FUZZER_H
+#define RDSTATEMENT_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "rdstatement_fuzzer"
+
+#endif // RDSTATEMENT_FUZZER_H
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/big_integer_test.cpp b/relational_store/test/native/rdb/unittest/big_integer_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7070f9ace9c5d704f8bd39fc424958dbd54b2da3
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/big_integer_test.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "big_integer.h"
+
+#include <gtest/gtest.h>
+
+#include <climits>
+#include <string>
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+namespace Test {
+class BigIntegerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp(void){};
+    void TearDown(void){};
+};
+
+void BigIntegerTest::SetUpTestCase(void)
+{
+}
+
+void BigIntegerTest::TearDownTestCase(void)
+{
+}
+
+/**
+ * @tc.name: RdbStore_SqliteUtils_001
+ * @tc.desc: test func third line
+bool BigInteger::operator==(const BigInteger& other)
+{
+    if (sign_ != other.sign_) {
+        return false;
+    }
+    return value_ == other.value_;
+}
+ * @tc.type: FUNC
+ */
+HWTEST_F(BigIntegerTest, Big_Integer_001, TestSize.Level1)
+{
+    BigInteger bigInt1 = BigInteger(100);
+    BigInteger bigInt2 = BigInteger(-100);
+    EXPECT_FALSE(bigInt1 == bigInt2);
+}
+} // namespace Test
diff --git a/relational_store/test/native/rdb/unittest/connection_test.cpp b/relational_store/test/native/rdb/unittest/connection_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b8ea5612719a2c1db78968ceac9071503f5c585
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/connection_test.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "connection.h"
+
+#include <gtest/gtest.h>
+
+#include <climits>
+#include <string>
+
+#include "grd_type_export.h"
+#include "rdb_errno.h"
+#include "rdb_store_config.h"
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+
+namespace Test {
+class ConnectionTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp(void){};
+    void TearDown(void){};
+};
+
+void ConnectionTest::SetUpTestCase(void)
+{
+}
+
+void ConnectionTest::TearDownTestCase(void)
+{
+}
+
+/**
+ * @tc.name: Connection_Test_001
+ * @tc.desc: Normal testCase of sqlite_utils for IsSpecial, if sqlType is special
+ * @tc.type: FUNC
+ */
+HWTEST_F(ConnectionTest, Connection_Test_001, TestSize.Level1)
+{
+    RdbStoreConfig config("/data/test/connection_ut_test.db");
+    config.SetDBType(OHOS::NativeRdb::DBType::DB_BUTT);
+    auto [errCode, connection] = Connection::Create(config, true);
+    EXPECT_EQ(errCode, E_INVALID_ARGS);
+    EXPECT_EQ(connection, nullptr);
+
+    config.SetDBType(OHOS::NativeRdb::DBType::DB_SQLITE);
+    auto [errCode1, connection1] = Connection::Create(config, true);
+    EXPECT_EQ(errCode1, E_OK);
+    EXPECT_NE(connection1, nullptr);
+}
+
+/**
+ * @tc.name: Connection_Test_002
+ * @tc.desc: Normal testCase of sqlite_utils for IsSpecial, if sqlType is special
+ * @tc.type: FUNC
+ */
+HWTEST_F(ConnectionTest, Connection_Test_002, TestSize.Level1)
+{
+    RdbStoreConfig config("/data/test/connection_ut_test.db");
+    config.SetDBType(OHOS::NativeRdb::DBType::DB_BUTT);
+    int ret = Connection::Repair(config);
+    EXPECT_EQ(ret, E_INVALID_ARGS);
+
+    config.SetDBType(OHOS::NativeRdb::DBType::DB_SQLITE);
+    ret = Connection::Repair(config);
+    EXPECT_EQ(ret, E_NOT_SUPPORT);
+}
+} // namespace Test
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_rd_test.cpp b/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_rd_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9a99944e21c4f4c0a78890a6a6d3b269714dfce
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_rd_test.cpp
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <iostream>
+#include <string>
+#include <string_view>
+
+#include "../common.h"
+#include "block_data.h"
+#include "executor_pool.h"
+#include "rd_utils.h"
+#include "rdb_errno.h"
+#include "rdb_helper.h"
+#include "rdb_open_callback.h"
+#include "shared_block.h"
+#include "sqlite_shared_result_set.h"
+#include "step_result_set.h"
+
+using namespace testing::ext;
+using namespace OHOS;
+using namespace OHOS::NativeRdb;
+
+namespace Test {
+class RdbMultiThreadConnectionRdTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static const std::string databaseName;
+
+    static constexpr int32_t MAX_THREAD = 5;
+    static constexpr int32_t MIN_THREAD = 0;
+
+    std::shared_ptr<RdbStore> store_;
+    std::shared_ptr<ExecutorPool> executors_;
+
+    RdbMultiThreadConnectionRdTest();
+};
+
+const std::string RdbMultiThreadConnectionRdTest::databaseName = RDB_TEST_PATH + "execute_test.db";
+
+class Callback : public RdbOpenCallback {
+public:
+    int OnCreate(RdbStore &store) override;
+    int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
+};
+
+int Callback::OnCreate(RdbStore &store)
+{
+    return E_OK;
+}
+
+int Callback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
+{
+    return E_OK;
+}
+
+RdbMultiThreadConnectionRdTest::RdbMultiThreadConnectionRdTest()
+{
+    executors_ = std::make_shared<ExecutorPool>(MAX_THREAD, MIN_THREAD);
+    store_ = nullptr;
+    RdbHelper::DeleteRdbStore(databaseName);
+    RdbStoreConfig config(databaseName);
+    config.SetIsVector(true);
+    config.SetSecurityLevel(SecurityLevel::S4);
+    Callback helper;
+    int errCode = E_OK;
+    store_ = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store_, nullptr);
+    EXPECT_EQ(errCode, E_OK);
+}
+
+void RdbMultiThreadConnectionRdTest::SetUpTestCase(void)
+{
+}
+
+void RdbMultiThreadConnectionRdTest::TearDownTestCase(void)
+{
+}
+
+void RdbMultiThreadConnectionRdTest::SetUp(void)
+{
+}
+
+void RdbMultiThreadConnectionRdTest::TearDown(void)
+{
+    executors_ = nullptr;
+    store_ = nullptr;
+    RdbHelper::DeleteRdbStore(RdbMultiThreadConnectionRdTest::databaseName);
+}
+
+/**
+ * @tc.name: MultiThread_Connection_0001
+ *           test if two threads can begin trans and commit in order without conflicting
+ * @tc.desc: 1.thread 1: begin trans and commit
+ *           2.thread 2: begin trans and commit
+ * @tc.type: FUNC
+ * @tc.author: zhangjiaxi
+ */
+HWTEST_F(RdbMultiThreadConnectionRdTest, MultiThread_BeginTransTest_0001, TestSize.Level2)
+{
+    auto taskId1 = executors_->Execute([store = store_]() {
+        std::pair<int, int64_t> res;
+        int32_t errCode = E_OK;
+        for (int i = 0; i < 2000; i++) {
+            res = store->BeginTrans();
+            EXPECT_EQ(res.first, E_OK);
+            errCode = store->Commit(res.second);
+            EXPECT_EQ(errCode, E_OK);
+        }
+    });
+
+    auto taskId2 = executors_->Execute([store = store_]() {
+        std::pair<int, int64_t> res;
+        int32_t errCode = E_OK;
+        for (int i = 0; i < 2000; i++) {
+            res = store->BeginTrans();
+            EXPECT_EQ(res.first, E_OK);
+            errCode = store->Commit(res.second);
+            EXPECT_EQ(errCode, E_OK);
+        }
+    });
+    executors_->Remove(taskId1, true);
+    executors_->Remove(taskId2, true);
+    EXPECT_NE(taskId1, taskId2);
+}
+
+/**
+ * @tc.name: MultiThread_Connection_0002
+ *           test if two threads can begin trans and rollback in order without conflicting
+ * @tc.desc: 1.thread 1: begin trans and rollback
+ *           2.thread 2: begin trans and rollback
+ * @tc.type: FUNC
+ * @tc.author: zhangjiaxi
+ */
+HWTEST_F(RdbMultiThreadConnectionRdTest, MultiThread_BeginTransTest_0002, TestSize.Level2)
+{
+    auto taskId1 = executors_->Execute([store = store_]() {
+        std::pair<int, int64_t> res;
+        int32_t errCode = E_OK;
+        for (int i = 0; i < 2000; i++) {
+            res = store->BeginTrans();
+            EXPECT_EQ(res.first, E_OK);
+            errCode = store->RollBack(res.second);
+            EXPECT_EQ(errCode, E_OK);
+        }
+    });
+
+    auto taskId2 = executors_->Execute([store = store_]() {
+        std::pair<int, int64_t> res;
+        int32_t errCode = E_OK;
+        for (int i = 0; i < 2000; i++) {
+            res = store->BeginTrans();
+            EXPECT_EQ(res.first, E_OK);
+            errCode = store->RollBack(res.second);
+            EXPECT_EQ(errCode, E_OK);
+        }
+    });
+    executors_->Remove(taskId1, true);
+    executors_->Remove(taskId2, true);
+    EXPECT_NE(taskId1, taskId2);
+}
+} // namespace Test
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_test.cpp b/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_test.cpp
index 7cd8e8e8faeba0fddbb26b9ddde6ff3f14728aa3..e42b3214f0dee23b162218846ed925f0f17f2492 100644
--- a/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_test.cpp
+++ b/relational_store/test/native/rdb/unittest/multiThread/rdb_connection_test.cpp
@@ -134,8 +134,8 @@ HWTEST_F(RdbMultiThreadConnectionTest, MultiThread_Connection_0001, TestSize.Lev
     auto taskId1 = executors_->Execute([store = store_, block1]() {
         constexpr const char *createTable = "CREATE TABLE test";
         constexpr const char *createTableColumn = " (id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER, salary REAL, "
-                                          "blobType BLOB)";
+                                                  "name TEXT NOT NULL, age INTEGER, salary REAL, "
+                                                  "blobType BLOB)";
         int32_t errCode = E_ERROR;
         for (uint32_t i = 0; i < 2000; i++) {
             errCode = store->ExecuteSql(createTable + std::to_string(i) + createTableColumn);
@@ -154,11 +154,12 @@ HWTEST_F(RdbMultiThreadConnectionTest, MultiThread_Connection_0001, TestSize.Lev
             int rowCount = -1;
             errCode = resultSet->GetRowCount(rowCount);
             resultSet->Close();
-            if (errCode != E_OK) {
+            if (errCode != E_OK && errCode != E_SQLITE_SCHEMA) {
                 break;
             }
         }
-        block2->SetValue(errCode);
+        auto code = (errCode == E_OK || errCode == E_SQLITE_SCHEMA) ? E_OK : errCode;
+        block2->SetValue(code);
     });
 
     EXPECT_EQ(block1->GetValue(), E_OK);
@@ -180,8 +181,8 @@ HWTEST_F(RdbMultiThreadConnectionTest, MultiThread_Connection_0002, TestSize.Lev
     auto taskId1 = executors_->Execute([store = store_, block1]() {
         constexpr const char *createTable = "CREATE TABLE test";
         constexpr const char *createTableColumn = " (id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER, salary REAL, "
-                                          "blobType BLOB)";
+                                                  "name TEXT NOT NULL, age INTEGER, salary REAL, "
+                                                  "blobType BLOB)";
         int32_t errCode = E_ERROR;
         for (uint32_t i = 0; i < 2000; i++) {
             errCode = store->ExecuteSql(createTable + std::to_string(i) + createTableColumn);
@@ -200,11 +201,12 @@ HWTEST_F(RdbMultiThreadConnectionTest, MultiThread_Connection_0002, TestSize.Lev
             int rowCount = -1;
             errCode = resultSet->GetRowCount(rowCount);
             resultSet->Close();
-            if (errCode != E_OK) {
+            if (errCode != E_OK && errCode != E_SQLITE_SCHEMA) {
                 break;
             }
         }
-        block2->SetValue(errCode);
+        auto code = (errCode == E_OK || errCode == E_SQLITE_SCHEMA) ? E_OK : errCode;
+        block2->SetValue(code);
     });
 
     EXPECT_EQ(block1->GetValue(), E_OK);
diff --git a/relational_store/test/native/rdb/unittest/raw_data_parser_test.cpp b/relational_store/test/native/rdb/unittest/raw_data_parser_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..348b0902f9015663119556bacb6f78e13ade1fc5
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/raw_data_parser_test.cpp
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "RdbBigIntTest"
+#include "raw_data_parser.h"
+
+#include <gtest/gtest.h>
+
+#include "value_object.h"
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+namespace Test {
+class RawDataParserTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+void RawDataParserTest::SetUpTestCase(void)
+{
+}
+
+void RawDataParserTest::TearDownTestCase(void)
+{
+}
+
+void RawDataParserTest::SetUp(void)
+{
+}
+
+void RawDataParserTest::TearDown(void)
+{
+}
+
+/**
+ * @tc.name: BigInt_Parser
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RawDataParserTest, BigInt_Parser, TestSize.Level1)
+{
+    std::vector<uint64_t> u64Val(2 + rand() % 100, 0);
+    for (int i = 0; i < u64Val.size(); ++i) {
+        uint64_t high = uint64_t(rand());
+        uint64_t low = uint64_t(rand());
+        u64Val[i] = (high << 32) | low;
+    }
+    BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
+    auto rawData = RawDataParser::PackageRawData(value1);
+    for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+        std::vector<uint8_t> noAlign(rawData.size() + i, 0);
+        noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
+        BigInteger parsedValue1;
+        RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedValue1);
+        ASSERT_TRUE(value1 == parsedValue1);
+    }
+}
+/**
+ * @tc.name: Float32_Parser
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RawDataParserTest, Float32_Parser, TestSize.Level1)
+{
+    std::vector<float> floats(15, 9.65);
+    auto rawData = RawDataParser::PackageRawData(floats);
+    for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+        std::vector<uint8_t> noAlign(rawData.size() + i, 0);
+        noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
+        std::vector<float> parsedFloats;
+        RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedFloats);
+        ASSERT_TRUE(floats.size() == parsedFloats.size());
+    }
+}
+/**
+ * @tc.name: Asset_Parser
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RawDataParserTest, Asset_Parser, TestSize.Level1)
+{
+    ValueObject::Asset asset;
+    asset.id = "100";
+    asset.name = "IMG_1690.png";
+    asset.uri = "file://data/args/header/IMG_1690.png";
+    asset.createTime = "2024-07-05 20:37.982158265 +8:00";
+    asset.modifyTime = "2024-07-05 20:37.982158265 +8:00";
+    asset.size = "4194304";
+    asset.hash = "2024-07-05 20:37.982158265 +8:00_4194304";
+    asset.path = "photos/header/IMG_1690.png";
+    auto rawData = RawDataParser::PackageRawData(asset);
+    for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+        std::vector<uint8_t> noAlign(rawData.size() + i, 0);
+        noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
+        ValueObject::Asset parsedAsset;
+        RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedAsset);
+        ASSERT_TRUE(parsedAsset.id == asset.id);
+        ASSERT_TRUE(parsedAsset.name == asset.name);
+        ASSERT_TRUE(parsedAsset.uri == asset.uri);
+        ASSERT_TRUE(parsedAsset.createTime == asset.createTime);
+        ASSERT_TRUE(parsedAsset.modifyTime == asset.modifyTime);
+        ASSERT_TRUE(parsedAsset.size == asset.size);
+        ASSERT_TRUE(parsedAsset.hash == asset.hash);
+        ASSERT_TRUE(parsedAsset.path == asset.path);
+    }
+}
+/**
+ * @tc.name: Assets_Parser
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RawDataParserTest, Assets_Parser, TestSize.Level1)
+{
+    ValueObject::Assets assets(1);
+    assets[0].id = "100";
+    assets[0].name = "IMG_1690.png";
+    assets[0].uri = "file://data/args/header/IMG_1690.png";
+    assets[0].createTime = "2024-07-05 20:37.982158265 +8:00";
+    assets[0].modifyTime = "2024-07-05 20:37.982158265 +8:00";
+    assets[0].size = "4194304";
+    assets[0].hash = "2024-07-05 20:37.982158265 +8:00_4194304";
+    assets[0].path = "photos/header/IMG_1690.png";
+    auto rawData = RawDataParser::PackageRawData(assets);
+    for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+        std::vector<uint8_t> noAlign(rawData.size() + i, 0);
+        noAlign.insert(noAlign.begin() + i, rawData.begin(), rawData.end());
+        ValueObject::Assets parsedAssets;
+        RawDataParser::ParserRawData(noAlign.data() + i, noAlign.size() - i, parsedAssets);
+        ASSERT_TRUE(parsedAssets[0].id == assets[0].id);
+        ASSERT_TRUE(parsedAssets[0].name == assets[0].name);
+        ASSERT_TRUE(parsedAssets[0].uri == assets[0].uri);
+        ASSERT_TRUE(parsedAssets[0].createTime == assets[0].createTime);
+        ASSERT_TRUE(parsedAssets[0].modifyTime == assets[0].modifyTime);
+        ASSERT_TRUE(parsedAssets[0].size == assets[0].size);
+        ASSERT_TRUE(parsedAssets[0].hash == assets[0].hash);
+        ASSERT_TRUE(parsedAssets[0].path == assets[0].path);
+    }
+}
+} // namespace Test
diff --git a/relational_store/test/native/rdb/unittest/rd_utils_test.cpp b/relational_store/test/native/rdb/unittest/rd_utils_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a204a3bc8967ed1061232d3f22e5dc03b55aa16
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/rd_utils_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rd_utils.h"
+
+#include <gtest/gtest.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <climits>
+#include <string>
+
+#include "grd_type_export.h"
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+
+namespace Test {
+class RdUtilsTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp(void){};
+    void TearDown(void){};
+};
+
+void RdUtilsTest::SetUpTestCase(void)
+{
+}
+
+void RdUtilsTest::TearDownTestCase(void)
+{
+}
+
+/**
+ * @tc.name: RdUtils_Test_001
+ * @tc.desc: Normal testCase of sqlite_utils for IsSpecial, if sqlType is special
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdUtilsTest, RdUtils_Test_001, TestSize.Level1)
+{
+    EXPECT_EQ(RdUtils::TransferGrdErrno(1), 1);
+    EXPECT_EQ(RdUtils::TransferGrdErrno(0), E_OK);
+    EXPECT_EQ(RdUtils::TransferGrdErrno(-9999), E_ERROR);
+}
+
+HWTEST_F(RdUtilsTest, RdUtils_Test_002, TestSize.Level1)
+{
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_INTEGER), ColumnType::TYPE_INTEGER);
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_FLOAT), ColumnType::TYPE_FLOAT);
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_TEXT), ColumnType::TYPE_STRING);
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_BLOB), ColumnType::TYPE_BLOB);
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_FLOATVECTOR), ColumnType::TYPE_FLOAT32_ARRAY);
+    EXPECT_EQ(RdUtils::TransferGrdTypeToColType(GRD_DB_DATATYPE_NULL), ColumnType::TYPE_NULL);
+}
+} // namespace Test
diff --git a/relational_store/test/native/rdb/unittest/rdb_attach_test.cpp b/relational_store/test/native/rdb/unittest/rdb_attach_test.cpp
index 6ed381e5f82d3d559c232bdff08fe74252ae9d79..84705522688fc40f0247efca7dfebc04a0ff5045 100644
--- a/relational_store/test/native/rdb/unittest/rdb_attach_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_attach_test.cpp
@@ -352,8 +352,7 @@ void RdbAttachTest::DeleteCheck(std::shared_ptr<RdbStore> &store) const
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(changedRows, 1);
 
-    std::shared_ptr<ResultSet> resultSet =
-        store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
+    std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
     EXPECT_NE(resultSet, nullptr);
     int count = 0;
     resultSet->GetRowCount(count);
@@ -366,8 +365,7 @@ void RdbAttachTest::DeleteCheck(std::shared_ptr<RdbStore> &store) const
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(changedRows2, 1);
 
-    std::shared_ptr<ResultSet> resultSet2 =
-        store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
+    std::shared_ptr<ResultSet> resultSet2 = store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
     EXPECT_NE(resultSet2, nullptr);
     int count2 = 0;
     resultSet2->GetRowCount(count2);
@@ -385,8 +383,7 @@ void RdbAttachTest::UpdateCheck(std::shared_ptr<RdbStore> &store) const
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(changedRows, 1);
 
-    std::shared_ptr<ResultSet> resultSet =
-        store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
+    std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test1 where name = 'lisi_update1'");
     EXPECT_NE(resultSet, nullptr);
     int count = 0;
     resultSet->GetRowCount(count);
@@ -401,8 +398,7 @@ void RdbAttachTest::UpdateCheck(std::shared_ptr<RdbStore> &store) const
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(changedRows2, 1);
 
-    std::shared_ptr<ResultSet> resultSet2 =
-        store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
+    std::shared_ptr<ResultSet> resultSet2 = store->QuerySql("SELECT * FROM test2 where name = 'lisi_update2'");
     EXPECT_NE(resultSet2, nullptr);
     int count2 = 0;
     resultSet2->GetRowCount(count2);
diff --git a/relational_store/test/native/rdb/unittest/rdb_bigint_test.cpp b/relational_store/test/native/rdb/unittest/rdb_bigint_test.cpp
index 9d160d8c8eb3e3ed2fca037265ab959b8deece49..4effadfc2493b87676e08621f8b016974383d4f9 100644
--- a/relational_store/test/native/rdb/unittest/rdb_bigint_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_bigint_test.cpp
@@ -14,7 +14,7 @@
  */
 #define LOG_TAG "RdbBigIntTest"
 #include <gtest/gtest.h>
-#include "rdb_helper.h"
+
 #include "common.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
@@ -31,11 +31,11 @@ public:
 protected:
     class RdbCallback : public RdbOpenCallback {
     public:
-        int OnCreate(RdbStore& store) override
+        int OnCreate(RdbStore &store) override
         {
             return E_OK;
         }
-        int OnUpgrade(RdbStore& store, int oldVersion, int newVersion) override
+        int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override
         {
             return E_OK;
         }
@@ -45,7 +45,7 @@ protected:
     static constexpr const char* DATABASE_NAME = "bigint_test.db";
     static constexpr const char* CREATE_TABLE =
         "CREATE TABLE IF NOT EXISTS bigint_table(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-        "value1 UNLIMITED INT NOT NULL, value2 UNLIMITED INT, value3 VECS)";
+        "value1 UNLIMITED INT NOT NULL, value2 UNLIMITED INT, value3 FLOATVECTOR)";
     static constexpr const char* DROP_TABLE = "DROP TABLE IF EXISTS bigint_table";
     static std::shared_ptr<RdbStore> rdbStore_;
 };
@@ -154,8 +154,8 @@ HWTEST_F(RdbBigIntTest, Insert_Step_BigInt_INT64, TestSize.Level1)
 HWTEST_F(RdbBigIntTest, Insert_BigInt_INT128, TestSize.Level1)
 {
     int64_t outRowId = -1;
-    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
-    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
+    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
+    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
     ValuesBucket bucket;
     bucket.Put("value1", value1);
     bucket.Put("value2", value2);
@@ -190,8 +190,8 @@ HWTEST_F(RdbBigIntTest, Insert_BigInt_INT128, TestSize.Level1)
 HWTEST_F(RdbBigIntTest, GetValue_BigInt_INT128, TestSize.Level1)
 {
     int64_t outRowId = -1;
-    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
-    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
+    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
+    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
     ValuesBucket bucket;
     bucket.Put("value1", value1);
     bucket.Put("value2", value2);
@@ -226,8 +226,8 @@ HWTEST_F(RdbBigIntTest, GetValue_BigInt_INT128, TestSize.Level1)
 HWTEST_F(RdbBigIntTest, Insert_Step_BigInt_INT128, TestSize.Level1)
 {
     int64_t outRowId = -1;
-    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
-    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{158, 0xDEADDEADDEADDEAD});
+    BigInteger value1 = BigInteger(0, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
+    BigInteger value2 = BigInteger(1, std::vector<uint64_t>{ 158, 0xDEADDEADDEADDEAD });
     ValuesBucket bucket;
     bucket.Put("value1", value1);
     bucket.Put("value2", value2);
@@ -266,7 +266,7 @@ HWTEST_F(RdbBigIntTest, Insert_BigInt_INTRand, TestSize.Level1)
     for (int i = 0; i < u64Val.size(); ++i) {
         uint64_t high = uint64_t(rand());
         uint64_t low = uint64_t(rand());
-        u64Val[i] = (high << 32) |  low;
+        u64Val[i] = (high << 32) | low;
     }
     BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
     BigInteger value2 = BigInteger(1, std::vector<uint64_t>(u64Val));
@@ -308,7 +308,7 @@ HWTEST_F(RdbBigIntTest, Insert_Step_BigInt_INTRand, TestSize.Level1)
     for (int i = 0; i < u64Val.size(); ++i) {
         uint64_t high = uint64_t(rand());
         uint64_t low = uint64_t(rand());
-        u64Val[i] = (high << 32) |  low;
+        u64Val[i] = (high << 32) | low;
     }
     BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
     BigInteger value2 = BigInteger(1, std::vector<uint64_t>(u64Val));
@@ -350,7 +350,7 @@ HWTEST_F(RdbBigIntTest, Insert_Floats, TestSize.Level1)
     for (int i = 0; i < u64Val.size(); ++i) {
         uint64_t high = uint64_t(rand());
         uint64_t low = uint64_t(rand());
-        u64Val[i] = (high << 32) |  low;
+        u64Val[i] = (high << 32) | low;
     }
     BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
     BigInteger value2 = BigInteger(1, std::vector<uint64_t>(u64Val));
@@ -388,7 +388,7 @@ HWTEST_F(RdbBigIntTest, Insert_Step_Floats, TestSize.Level1)
     for (int i = 0; i < u64Val.size(); ++i) {
         uint64_t high = uint64_t(rand());
         uint64_t low = uint64_t(rand());
-        u64Val[i] = (high << 32) |  low;
+        u64Val[i] = (high << 32) | low;
     }
     BigInteger value1 = BigInteger(0, std::vector<uint64_t>(u64Val));
     BigInteger value2 = BigInteger(1, std::vector<uint64_t>(u64Val));
@@ -413,4 +413,4 @@ HWTEST_F(RdbBigIntTest, Insert_Step_Floats, TestSize.Level1)
         }
     }
 }
-}
+} // namespace Test
diff --git a/relational_store/test/native/rdb/unittest/rdb_delete_test.cpp b/relational_store/test/native/rdb/unittest/rdb_delete_test.cpp
index 827273773d9167fb848b4cef70b4848c2db2211c..6ccbe1a202e982fe9c8a465faca0e3b274ea6acd 100644
--- a/relational_store/test/native/rdb/unittest/rdb_delete_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_delete_test.cpp
@@ -46,10 +46,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-std::string const DeleteTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                              + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                            "name TEXT NOT NULL, age INTEGER, salary "
-                                                                            "REAL, blobType BLOB)");
+std::string const DeleteTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int DeleteTestOpenCallback::OnCreate(RdbStore &store)
 {
diff --git a/relational_store/test/native/rdb/unittest/rdb_distributed_test.cpp b/relational_store/test/native/rdb/unittest/rdb_distributed_test.cpp
index 087b1288da07865df63f6141fd229ae67a4d5d35..aeaa88e36561ec584c31803c3be834675bba037b 100644
--- a/relational_store/test/native/rdb/unittest/rdb_distributed_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_distributed_test.cpp
@@ -13,11 +13,11 @@
  * limitations under the License.
  */
 
+#include <fcntl.h>
 #include <gtest/gtest.h>
-
-#include <sys/types.h>
 #include <sys/stat.h>
-#include <fcntl.h>
+#include <sys/types.h>
+
 #include <iostream>
 #include <string>
 
@@ -35,14 +35,16 @@ public:
     static void SetUpTestCase();
     static void TearDownTestCase();
     void SetUp();
-    void TearDown() {}
+    void TearDown()
+    {
+    }
 
     void InsertValue(std::shared_ptr<RdbStore> &store);
     void CheckResultSet(std::shared_ptr<RdbStore> &store);
 
     static constexpr int ddmsGroupId_ = 1000;
     static const std::string DRDB_NAME;
-    static const  std::string DRDB_PATH;
+    static const std::string DRDB_PATH;
 };
 
 const std::string RdbStoreDistributedTest::DRDB_NAME = "distributed_rdb.db";
@@ -50,7 +52,7 @@ const std::string RdbStoreDistributedTest::DRDB_PATH = "/data/test/";
 
 class TestOpenCallback : public RdbOpenCallback {
 public:
-    int OnCreate(RdbStore& store) override
+    int OnCreate(RdbStore &store) override
     {
         std::string sql = "CREATE TABLE IF NOT EXISTS employee ("
                           "id INTEGER PRIMARY KEY AUTOINCREMENT,"
@@ -62,12 +64,12 @@ public:
         return 0;
     }
 
-    int OnOpen(RdbStore& store) override
+    int OnOpen(RdbStore &store) override
     {
         return 0;
     }
 
-    int OnUpgrade(RdbStore& store, int currentVersion, int targetVersion) override
+    int OnUpgrade(RdbStore &store, int currentVersion, int targetVersion) override
     {
         return 0;
     }
@@ -113,7 +115,7 @@ void RdbStoreDistributedTest::InsertValue(std::shared_ptr<RdbStore> &store)
 
     values.PutInt("id", 1);
     values.PutString("name", std::string("zhangsan"));
-    values.PutInt("age", 18); // 18 age
+    values.PutInt("age", 18);          // 18 age
     values.PutDouble("salary", 100.5); // 100.5
     values.PutBlob("data", std::vector<uint8_t>{ 1, 2, 3 });
     EXPECT_EQ(E_OK, store->Insert(id, "employee", values));
@@ -220,6 +222,7 @@ HWTEST_F(RdbStoreDistributedTest, RdbStore_Distributed_Test_004, TestSize.Level2
     EXPECT_NE(E_OK, errCode);
 
     std::string path = RdbStoreDistributedTest::DRDB_PATH + "test.db";
+    RdbHelper::DeleteRdbStore(path);
     RdbStoreConfig config(path);
     TestOpenCallback callback;
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, callback, errCode);
diff --git a/relational_store/test/native/rdb/unittest/rdb_double_write_test.cpp b/relational_store/test/native/rdb/unittest/rdb_double_write_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b93d5dc8977777a150a0dd55455f8783a07a6c15
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/rdb_double_write_test.cpp
@@ -0,0 +1,1143 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "RdbDoubleWriteTest"
+#include <gtest/gtest.h>
+
+#include <fstream>
+#include <string>
+#include "sys/types.h"
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "logger.h"
+#include "common.h"
+#include "sqlite_utils.h"
+#include "file_ex.h"
+#include "rdb_common.h"
+#include "rdb_errno.h"
+#include "rdb_helper.h"
+#include "rdb_open_callback.h"
+ 
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+using namespace OHOS::Rdb;
+ 
+class RdbDoubleWriteTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    void CheckResultSet(std::shared_ptr<RdbStore> &store);
+    void CheckAge(std::shared_ptr<ResultSet> &resultSet);
+    void CheckSalary(std::shared_ptr<ResultSet> &resultSet);
+    void CheckBlob(std::shared_ptr<ResultSet> &resultSet);
+    void CheckNumber(std::shared_ptr<RdbStore> &store, int num, int errCode = E_OK,
+        const std::string &tableName = "test");
+    void Insert(int64_t start, int count, bool isSlave = false, int dataSize = 0);
+    void WaitForBackupFinish(int32_t expectStatus, int maxTimes = 400);
+    void TryInterruptBackup();
+    void InitDb();
+
+    static const std::string DATABASE_NAME;
+    static const std::string SLAVE_DATABASE_NAME;
+    static std::shared_ptr<RdbStore> store;
+    static std::shared_ptr<RdbStore> slaveStore;
+    static std::shared_ptr<RdbStore> store3;
+
+    enum SlaveStatus : uint32_t {
+        UNDEFINED,
+        DB_NOT_EXITS,
+        BACKING_UP,
+        BACKUP_INTERRUPT,
+        BACKUP_FINISHED,
+    };
+};
+ 
+const std::string RdbDoubleWriteTest::DATABASE_NAME = RDB_TEST_PATH + "insert_test.db";
+const std::string RdbDoubleWriteTest::SLAVE_DATABASE_NAME = RDB_TEST_PATH + "insert_test_slave.db";
+std::shared_ptr<RdbStore> RdbDoubleWriteTest::store = nullptr;
+std::shared_ptr<RdbStore> RdbDoubleWriteTest::slaveStore = nullptr;
+std::shared_ptr<RdbStore> RdbDoubleWriteTest::store3 = nullptr;
+const int BLOB_SIZE = 3;
+const uint8_t EXPECTED_BLOB_DATA[] {1, 2, 3};
+const int CHECKAGE = 18;
+const double CHECKCOLUMN = 100.5;
+ 
+class DoubleWriteTestOpenCallback : public RdbOpenCallback {
+public:
+    int OnCreate(RdbStore &store) override;
+    int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
+    static const std::string CREATE_TABLE_TEST;
+};
+ 
+const std::string DoubleWriteTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
+ 
+int DoubleWriteTestOpenCallback::OnCreate(RdbStore &store)
+{
+    return store.ExecuteSql(CREATE_TABLE_TEST);
+}
+ 
+int DoubleWriteTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
+{
+    return E_OK;
+}
+ 
+void RdbDoubleWriteTest::SetUpTestCase(void)
+{
+}
+ 
+void RdbDoubleWriteTest::TearDownTestCase(void)
+{
+}
+ 
+void RdbDoubleWriteTest::SetUp(void)
+{
+}
+ 
+void RdbDoubleWriteTest::TearDown(void)
+{
+    store = nullptr;
+    slaveStore = nullptr;
+    RdbHelper::DeleteRdbStore(RdbDoubleWriteTest::DATABASE_NAME);
+}
+
+void RdbDoubleWriteTest::InitDb()
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    DoubleWriteTestOpenCallback helper;
+    RdbDoubleWriteTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::store, nullptr);
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    store->ExecuteSql("DELETE FROM test");
+    slaveStore->ExecuteSql("DELETE FROM test");
+}
+ 
+/**
+ * @tc.name: RdbStore_DoubleWrite_001
+ * @tc.desc: test RdbStore doubleWrite
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_001, TestSize.Level1)
+{
+    InitDb();
+    int64_t id;
+    ValuesBucket values;
+ 
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 18);
+    values.PutDouble("salary", 100.5);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, id);
+ 
+    values.Clear();
+    values.PutInt("id", 2);
+    values.PutString("name", std::string("lisi"));
+    values.PutInt("age", 18);
+    values.PutDouble("salary", 100.5);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(2, id);
+ 
+    values.Clear();
+    values.PutInt("id", 3);
+    values.PutString("name", std::string("lisi"));
+    values.PutInt("age", 20L);
+    values.PutDouble("salary", 100.5f);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(3, id);
+
+    RdbDoubleWriteTest::CheckResultSet(slaveStore);
+}
+
+void RdbDoubleWriteTest::Insert(int64_t start, int count, bool isSlave, int dataSize)
+{
+    ValuesBucket values;
+    int64_t id = start;
+    int ret = E_OK;
+    for (int i = 0; i < count; i++) {
+        values.Clear();
+        values.PutInt("id", id);
+        if (dataSize > 0) {
+            values.PutString("name", std::string(dataSize, 'a'));
+        } else {
+            values.PutString("name", std::string("zhangsan"));
+        }
+        values.PutInt("age", CHECKAGE);
+        values.PutDouble("salary", CHECKCOLUMN);
+        values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+        if (isSlave) {
+            ret = slaveStore->Insert(id, "test", values);
+        } else {
+            ret = store->Insert(id, "test", values);
+        }
+        EXPECT_EQ(ret, E_OK);
+        id++;
+    }
+}
+
+void RdbDoubleWriteTest::WaitForBackupFinish(int32_t expectStatus, int maxTimes)
+{
+    int32_t curStatus = store->GetBackupStatus();
+    int tryTimes = 0;
+    while (curStatus != expectStatus && (++tryTimes <= maxTimes)) {
+        usleep(50000); // 50000 delay
+        curStatus = store->GetBackupStatus();
+    }
+    LOG_INFO("----------cur backup Status:%{public}d---------", curStatus);
+    ASSERT_EQ(curStatus, expectStatus);
+}
+
+void RdbDoubleWriteTest::TryInterruptBackup()
+{
+    int err = store->InterruptBackup();
+    int tryTimes = 0;
+    while (err != E_OK && (++tryTimes <= 1000)) { // 1000 is try time
+        usleep(10000); // 10000 delay
+        err = store->InterruptBackup();
+    }
+    EXPECT_EQ(err, E_OK);
+    LOG_INFO("----------interrupt backup---------");
+}
+ 
+void RdbDoubleWriteTest::CheckResultSet(std::shared_ptr<RdbStore> &store)
+{
+    std::shared_ptr<ResultSet> resultSet =
+        store->QuerySql("SELECT * FROM test WHERE name = ?", std::vector<std::string>{ "zhangsan" });
+    EXPECT_NE(resultSet, nullptr);
+ 
+    int columnIndex;
+    int intVal;
+    std::string strVal;
+    ColumnType columnType;
+    int position;
+    int ret = resultSet->GetRowIndex(position);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(position, -1);
+ 
+    ret = resultSet->GetColumnType(0, columnType);
+    EXPECT_EQ(ret, E_ROW_OUT_RANGE);
+ 
+    ret = resultSet->GoToFirstRow();
+    EXPECT_EQ(ret, E_OK);
+ 
+    ret = resultSet->GetColumnIndex("id", columnIndex);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnIndex, 0);
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
+    ret = resultSet->GetInt(columnIndex, intVal);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, intVal);
+ 
+    ret = resultSet->GetColumnIndex("name", columnIndex);
+    EXPECT_EQ(ret, E_OK);
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnType, ColumnType::TYPE_STRING);
+    ret = resultSet->GetString(columnIndex, strVal);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ("zhangsan", strVal);
+ 
+    RdbDoubleWriteTest::CheckAge(resultSet);
+    RdbDoubleWriteTest::CheckSalary(resultSet);
+    RdbDoubleWriteTest::CheckBlob(resultSet);
+ 
+    ret = resultSet->GoToNextRow();
+    EXPECT_EQ(ret, E_ROW_OUT_RANGE);
+ 
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_ROW_OUT_RANGE);
+ 
+    ret = resultSet->Close();
+    EXPECT_EQ(ret, E_OK);
+}
+ 
+void RdbDoubleWriteTest::CheckAge(std::shared_ptr<ResultSet> &resultSet)
+{
+    int columnIndex;
+    int intVal;
+    ColumnType columnType;
+    int ret = resultSet->GetColumnIndex("age", columnIndex);
+    EXPECT_EQ(ret, E_OK);
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnType, ColumnType::TYPE_INTEGER);
+    ret = resultSet->GetInt(columnIndex, intVal);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(CHECKAGE, intVal);
+}
+ 
+void RdbDoubleWriteTest::CheckSalary(std::shared_ptr<ResultSet> &resultSet)
+{
+    int columnIndex;
+    double dVal;
+    ColumnType columnType;
+    int ret = resultSet->GetColumnIndex("salary", columnIndex);
+    EXPECT_EQ(ret, E_OK);
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnType, ColumnType::TYPE_FLOAT);
+    ret = resultSet->GetDouble(columnIndex, dVal);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(CHECKCOLUMN, dVal);
+}
+ 
+void RdbDoubleWriteTest::CheckBlob(std::shared_ptr<ResultSet> &resultSet)
+{
+    int columnIndex;
+    std::vector<uint8_t> blob;
+    ColumnType columnType;
+    int ret = resultSet->GetColumnIndex("blobType", columnIndex);
+    EXPECT_EQ(ret, E_OK);
+    ret = resultSet->GetColumnType(columnIndex, columnType);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(columnType, ColumnType::TYPE_BLOB);
+    ret = resultSet->GetBlob(columnIndex, blob);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(BLOB_SIZE, static_cast<int>(blob.size()));
+    for (int i = 0; i < BLOB_SIZE; i++) {
+        EXPECT_EQ(EXPECTED_BLOB_DATA[i], blob[i]);
+    }
+}
+ 
+void RdbDoubleWriteTest::CheckNumber(std::shared_ptr<RdbStore> &store, int num, int errCode,
+    const std::string &tableName)
+{
+    std::shared_ptr<ResultSet> resultSet =
+        store->QuerySql("SELECT * FROM " + tableName);
+    ASSERT_NE(resultSet, nullptr);
+    int countNum;
+    int ret = resultSet->GetRowCount(countNum);
+    EXPECT_EQ(ret, errCode);
+    EXPECT_EQ(num, countNum);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_003
+ * @tc.desc: test RdbStore execute
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_003, TestSize.Level1)
+{
+    InitDb();
+ 
+    int64_t id;
+    ValuesBucket values;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 25);
+    values.PutDouble("salary", CHECKCOLUMN);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    auto [ret2, outValue2] = store->Execute("UPDATE test SET age= 18 WHERE id = 1");
+    EXPECT_EQ(E_OK, ret2);
+    
+    RdbDoubleWriteTest::CheckResultSet(slaveStore);
+}
+ 
+/**
+ * @tc.name: RdbStore_DoubleWrite_004
+ * @tc.desc: test RdbStore updata
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_004, TestSize.Level1)
+{
+    InitDb();
+ 
+    int64_t id;
+ 
+    ValuesBucket values;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 25);
+    values.PutDouble("salary", 100.5);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+ 
+    int changedRows;
+    values.Clear();
+    values.PutInt("age", 18);
+    ret = store->Update(changedRows, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, changedRows);
+    
+    RdbDoubleWriteTest::CheckResultSet(slaveStore);
+}
+ 
+/**
+ * @tc.name: RdbStore_DoubleWrite_005
+ * @tc.desc: test RdbStore delete
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_005, TestSize.Level1)
+{
+    InitDb();
+ 
+    ValuesBucket values;
+    int64_t id;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 18);
+    values.PutDouble("salary", 100.5);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, id);
+ 
+    values.Clear();
+    values.PutInt("id", 2);
+    values.PutString("name", std::string("lisi"));
+    values.PutInt("age", 18);
+    values.PutDouble("salary", 100.5);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(2, id);
+ 
+    values.Clear();
+    values.PutInt("id", 3);
+    values.PutString("name", std::string("lisi"));
+    values.PutInt("age", 20L);
+    values.PutDouble("salary", 100.5f);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(3, id);
+ 
+    int deletedRows;
+    ret = store->Delete(deletedRows, "test", "id = 2");
+    ret = store->Delete(deletedRows, "test", "id = 3");
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, deletedRows);
+    
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 1);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_007
+ * @tc.desc: open SINGLE db, write, close, open MAIN_REPLICA db, check slave
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_007, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::SINGLE);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+
+    store = nullptr;
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    RdbDoubleWriteTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::store, nullptr);
+
+    WaitForBackupFinish(BACKUP_FINISHED);
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+
+    RdbDoubleWriteTest::CheckNumber(RdbDoubleWriteTest::slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_008
+ * @tc.desc: open MAIN_REPLICA db, write, close, corrupt, reopen db allow rebuild, db returns to normal
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_008, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_008 insert finish");
+
+    store = nullptr;
+
+    std::fstream file(DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open() == true);
+    file.seekp(30, std::ios::beg);
+    ASSERT_TRUE(file.good() == true);
+    char bytes[2] = {0x6, 0x6};
+    file.write(bytes, 2);
+    ASSERT_TRUE(file.good() == true);
+    file.close();
+    LOG_INFO("RdbStore_DoubleWrite_008 corrupt db finish");
+
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    config.SetAllowRebuild(true);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    RebuiltType rebuiltType;
+    store->GetRebuilt(rebuiltType);
+    EXPECT_EQ(rebuiltType, RebuiltType::REPAIRED);
+    LOG_INFO("RdbStore_DoubleWrite_008 reopen db finish");
+
+    RdbDoubleWriteTest::CheckNumber(store, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_009
+ * @tc.desc: open MAIN_REPLICA db, write, slave db has 100 more data than main db, restore, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_009, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    Insert(id, 100);
+    id = 200;
+    Insert(id, 100, true);
+    RdbDoubleWriteTest::CheckNumber(store, 100);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 200);
+    EXPECT_EQ(store->Restore(std::string(""), {}), E_OK);
+    RdbDoubleWriteTest::CheckNumber(store, 200);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_010
+ * @tc.desc: open MAIN_REPLICA db, write, close all, corrupt slave, open MAIN_REPLICA db, slave returns to normal
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_010, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_010 insert finish");
+
+    slaveStore = nullptr;
+    store = nullptr;
+
+    std::fstream file(SLAVE_DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open() == true);
+    file.seekp(30, std::ios::beg);
+    ASSERT_TRUE(file.good() == true);
+    char bytes[2] = {0x6, 0x6};
+    file.write(bytes, 2);
+    ASSERT_TRUE(file.good() == true);
+    file.close();
+    LOG_INFO("RdbStore_DoubleWrite_010 corrupt db finish");
+
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_010 reopen main db finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_010 reopen slave db finish");
+
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_011
+ * @tc.desc: open MAIN_REPLICA db, write, close slave, corrupt slave, backup, check slave
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_011, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_011 insert finish");
+
+    slaveStore = nullptr;
+
+    std::fstream file(SLAVE_DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open() == true);
+    file.seekp(30, std::ios::beg);
+    ASSERT_TRUE(file.good() == true);
+    char bytes[2] = {0x6, 0x6};
+    file.write(bytes, 2);
+    ASSERT_TRUE(file.good() == true);
+    file.close();
+    LOG_INFO("RdbStore_DoubleWrite_011 corrupt db finish");
+
+    EXPECT_EQ(store->Backup(std::string(""), {}), E_OK);
+    LOG_INFO("RdbStore_DoubleWrite_011 backup db finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    int errCode;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_011 reopen slave db finish");
+
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_012
+ * @tc.desc: test RdbStore transaction
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_012, TestSize.Level1)
+{
+    InitDb();
+
+    int err = store->BeginTransaction();
+    EXPECT_EQ(err, E_OK);
+    int64_t id;
+    ValuesBucket values;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 25);
+    values.PutDouble("salary", CHECKCOLUMN);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+    auto [ret2, outValue2] = store->Execute("UPDATE test SET age= 18 WHERE id = 1");
+    EXPECT_EQ(E_OK, ret2);
+    err = store->Commit();
+    EXPECT_EQ(err, E_OK);
+
+    RdbDoubleWriteTest::CheckResultSet(slaveStore);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_013
+ * @tc.desc: open MANUAL_TRIGGER db, open slave, write, slave is empty, backup, check slave, write, check slave
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_013, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MANUAL_TRIGGER);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_013 reopen main db finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_013 reopen slave db finish");
+
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_013 insert finish");
+
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 0);
+
+    errCode = store->Backup(std::string(""), {});
+    EXPECT_EQ(errCode, E_OK);
+    LOG_INFO("RdbStore_DoubleWrite_013 backup finish");
+
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+
+    id = 1000;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_013 insert finish");
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 200); // 200 is all count
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_014
+ * @tc.desc: open MANUAL_TRIGGER db, write, backup, open slave, check slave, write, check slave
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_014, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MANUAL_TRIGGER);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_014 reopen main db finish");
+
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_014 insert finish");
+
+    errCode = store->Backup(std::string(""), {});
+    EXPECT_EQ(errCode, E_OK);
+    LOG_INFO("RdbStore_DoubleWrite_014 backup finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_014 reopen slave db finish");
+
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+
+    id = 1000;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_014 insert finish");
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 200); // 200 is all count
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_015
+ * @tc.desc: open MAIN_REPLICA db, write, close, corrupt, slave create table, open MAIN_REPLICA db. check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_015, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    ValuesBucket values;
+    for (int i = 0; i < count; i++) {
+        id++;
+        values.Clear();
+        values.PutInt("id", id);
+        values.PutString("name", std::string("zhangsan"));
+        values.PutInt("age", 18);
+        values.PutDouble("salary", 100.5);
+        values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+        int ret = store->Insert(id, "test", values);
+        EXPECT_EQ(ret, E_OK);
+    }
+    LOG_INFO("RdbStore_DoubleWrite_015 insert finish");
+
+    store = nullptr;
+
+    std::fstream file(DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open() == true);
+    file.seekp(30, std::ios::beg);
+    ASSERT_TRUE(file.good() == true);
+    char bytes[2] = {0x6, 0x6};
+    file.write(bytes, 2);
+    ASSERT_TRUE(file.good() == true);
+    file.close();
+    LOG_INFO("RdbStore_DoubleWrite_015 corrupt db finish");
+
+    int errCode = slaveStore->ExecuteSql("CREATE TABLE IF NOT EXISTS xx (id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        "name TEXT NOT NULL, age INTEGER, salary REAL, blobType BLOB)");
+    EXPECT_EQ(errCode, E_OK);
+    EXPECT_EQ(slaveStore->Insert(id, "xx", values), E_OK);
+
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    config.SetAllowRebuild(true);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_015 reopen db finish");
+
+    RdbDoubleWriteTest::CheckNumber(store, 1, E_OK, std::string("xx"));
+    RdbDoubleWriteTest::CheckNumber(store, count);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, 1, E_OK, std::string("xx"));
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_016
+ * @tc.desc: open MAIN_REPLICA db, write, close, delete db file, reopen, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_016, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_016 insert finish");
+
+    store = nullptr;
+    LOG_INFO("RdbStore_DoubleWrite_016 close finish");
+
+    SqliteUtils::DeleteFile(DATABASE_NAME);
+    SqliteUtils::DeleteFile(DATABASE_NAME + "-shm");
+    SqliteUtils::DeleteFile(DATABASE_NAME + "-wal");
+    LOG_INFO("RdbStore_DoubleWrite_016 delete db file finish");
+
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    class Callback016 : public RdbOpenCallback {
+    public:
+        int OnCreate(RdbStore &store) override {
+            return E_OK;
+        }
+        int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override {
+            return E_OK;
+        };
+    };
+    Callback016 helper;
+    int errCode;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_016 reopen db finish");
+
+    WaitForBackupFinish(BACKUP_FINISHED);
+
+    RdbDoubleWriteTest::CheckNumber(store, count);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_017
+ * @tc.desc: open MAIN_REPLICA db, write, close, reopen, corrupt db, restore, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_017, TestSize.Level1)
+{
+    InitDb();
+    int64_t id = 10;
+    int count = 100;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_017 insert finish");
+
+    store = nullptr;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    config.SetAllowRebuild(true);
+    DoubleWriteTestOpenCallback helper;
+    int errCode;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_017 reopen db finish");
+
+    std::fstream file(DATABASE_NAME, std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.is_open() == true);
+    file.seekp(0, std::ios::beg);
+    ASSERT_TRUE(file.good() == true);
+    char bytes[2] = {0x6, 0x6};
+    file.write(bytes, 2);
+    ASSERT_TRUE(file.good() == true);
+    file.close();
+    LOG_INFO("RdbStore_DoubleWrite_017 corrupt db finish");
+
+    EXPECT_EQ(store->Restore(std::string(""), {}), E_OK);
+    LOG_INFO("RdbStore_DoubleWrite_017 restore db finish");
+
+    RdbDoubleWriteTest::CheckNumber(store, count);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_018
+ * @tc.desc: open MAIN_REPLICA db, update slave, insert, M succ && S failed,
+ *           check failureFlag, backup, check failureFlag
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_018, TestSize.Level1)
+{
+    InitDb();
+
+    int64_t id;
+    ValuesBucket values;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 25);
+    values.PutDouble("salary", CHECKCOLUMN);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+
+    auto [ret2, outValue2] = slaveStore->Execute("UPDATE test SET id = 3 WHERE id = 1");
+    EXPECT_EQ(E_OK, ret2);
+
+    int64_t id2;
+    ValuesBucket values2;
+    values2.PutInt("id", 3);
+    values2.PutString("name", std::string("zhangsan"));
+    values2.PutInt("age", 25);
+    values2.PutDouble("salary", CHECKCOLUMN);
+    values2.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret3 = store->Insert(id2, "test", values2);
+    EXPECT_EQ(E_OK, ret3);
+    std::string failureFlagPath = RdbDoubleWriteTest::DATABASE_NAME + + "-slaveFailure";
+    bool isFlagFileExists = OHOS::FileExists(failureFlagPath);
+    ASSERT_TRUE(isFlagFileExists);
+    ASSERT_TRUE(store->IsSlaveDiffFromMaster());
+
+    int errCode;
+    errCode = store->Backup(std::string(""), {});
+    EXPECT_EQ(errCode, E_OK);
+    isFlagFileExists = OHOS::FileExists(failureFlagPath);
+    ASSERT_FALSE(isFlagFileExists);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_019
+ * @tc.desc: open MAIN_REPLICA db, update slave, insert, M succ && S failed,
+ *           check failureFlag, reopen, check failureFlag
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_019, TestSize.Level1)
+{
+    InitDb();
+
+    int64_t id;
+    ValuesBucket values;
+    values.PutInt("id", 1);
+    values.PutString("name", std::string("zhangsan"));
+    values.PutInt("age", 25);
+    values.PutDouble("salary", CHECKCOLUMN);
+    values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret = store->Insert(id, "test", values);
+    EXPECT_EQ(ret, E_OK);
+
+    auto [ret2, outValue2] = slaveStore->Execute("UPDATE test SET id = 3 WHERE id = 1");
+    EXPECT_EQ(E_OK, ret2);
+
+    int64_t id2;
+    ValuesBucket values2;
+    values2.PutInt("id", 3);
+    values2.PutString("name", std::string("zhangsan"));
+    values2.PutInt("age", 25);
+    values2.PutDouble("salary", CHECKCOLUMN);
+    values2.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
+    int ret3 = store->Insert(id2, "test", values2);
+    EXPECT_EQ(E_OK, ret3);
+    std::string failureFlagPath = RdbDoubleWriteTest::DATABASE_NAME + + "-slaveFailure";
+    bool isFlagFileExists = OHOS::FileExists(failureFlagPath);
+    ASSERT_TRUE(isFlagFileExists);
+    ASSERT_TRUE(store->IsSlaveDiffFromMaster());
+
+    store = nullptr;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    config.SetAllowRebuild(true);
+    DoubleWriteTestOpenCallback helper;
+    int errCode;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    WaitForBackupFinish(BACKUP_FINISHED);
+    store = nullptr;
+    isFlagFileExists = OHOS::FileExists(failureFlagPath);
+    ASSERT_FALSE(isFlagFileExists);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_022
+ * @tc.desc: open SINGLE db, write, close, reopen MAIN_REPLICA db, wait for backup, insert, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_022, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::SINGLE);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+
+    int64_t id = 10;
+    int strSize = 1024 * 100;
+    int count = 2000;
+    Insert(id, count, false, strSize);
+    LOG_INFO("RdbStore_DoubleWrite_022 insert finish");
+
+    store = nullptr;
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_022 reopen db finish");
+
+    WaitForBackupFinish(BACKUP_FINISHED);
+
+    id = 6666;
+    Insert(id, count);
+    LOG_INFO("RdbStore_DoubleWrite_022 insert db finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_022 reopen slave db finish");
+
+    RdbDoubleWriteTest::CheckNumber(store, count + count);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count + count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_023
+ * @tc.desc: open MANUAL_TRIGGER db, write, backup async, interrupt, backup async, wait finish, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_023, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::MANUAL_TRIGGER);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_023 reopen finish");
+
+    int64_t id = 10;
+    int strSize = 1024 * 100;
+    int count = 2000;
+    Insert(id, count, false, strSize);
+    LOG_INFO("RdbStore_DoubleWrite_023 insert finish");
+
+    std::thread thread([this]() {
+        LOG_INFO("RdbStore_DoubleWrite_023 t1 backup begin");
+        EXPECT_EQ(store->Backup(std::string(""), {}), E_BACKUP_INTERRUPT);
+        LOG_INFO("RdbStore_DoubleWrite_023 t1 backup end");
+    });
+    LOG_INFO("RdbStore_DoubleWrite_023 begin interrupt");
+    TryInterruptBackup();
+    LOG_INFO("RdbStore_DoubleWrite_023 interrupt end");
+    EXPECT_EQ(store->GetBackupStatus(), SlaveStatus::BACKUP_INTERRUPT);
+    thread.join();
+
+    std::thread thread1([this]() {
+        LOG_INFO("RdbStore_DoubleWrite_023 t2 backup begin");
+        EXPECT_EQ(store->Backup(std::string(""), {}), E_OK);
+        LOG_INFO("RdbStore_DoubleWrite_023 t2 backup end");
+    });
+    WaitForBackupFinish(BACKUP_FINISHED);
+    LOG_INFO("RdbStore_DoubleWrite_023 wait finish");
+    thread1.join();
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_023 reopen slave db finish");
+
+    RdbDoubleWriteTest::CheckNumber(store, count);
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_024
+ * @tc.desc: open SINGLE db, write, close, reopen MAIN_REPLICA db, wait for backup, insert, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_024, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::SINGLE);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+
+    int64_t id = 10;
+    int strSize = 1024 * 200;
+    int count = 1000;
+    Insert(id, count, false, strSize);
+    LOG_INFO("RdbStore_DoubleWrite_024 insert finish");
+
+    store = nullptr;
+    LOG_INFO("RdbStore_DoubleWrite_024 close finish");
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_024 reopen db finish");
+
+    store = nullptr;
+    LOG_INFO("RdbStore_DoubleWrite_024 close again");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_024 reopen slave");
+    RdbDoubleWriteTest::CheckNumber(slaveStore, count);
+}
+
+/**
+ * @tc.name: RdbStore_DoubleWrite_025
+ * @tc.desc: open SINGLE db, write, close, reopen MAIN_REPLICA db, insert, wait for backup, check count
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbDoubleWriteTest, RdbStore_DoubleWrite_025, TestSize.Level1)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbDoubleWriteTest::DATABASE_NAME);
+    config.SetHaMode(HAMode::SINGLE);
+    DoubleWriteTestOpenCallback helper;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+
+    int64_t id = 10;
+    int strSize = 1024 * 200;
+    int count = 1000;
+    Insert(id, count, false, strSize);
+    LOG_INFO("RdbStore_DoubleWrite_025 insert finish");
+
+    store = nullptr;
+    LOG_INFO("RdbStore_DoubleWrite_025 close finish");
+    config.SetHaMode(HAMode::MAIN_REPLICA);
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    ASSERT_NE(store, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_025 reopen db finish");
+
+    id = 6666;
+    LOG_INFO("RdbStore_DoubleWrite_025 begin insert");
+    Insert(id, count, false, strSize);
+    LOG_INFO("RdbStore_DoubleWrite_025 insert end");
+
+    WaitForBackupFinish(BACKUP_FINISHED, 1000); // 1000 is max retry time
+    LOG_INFO("RdbStore_DoubleWrite_025 wait finish");
+
+    RdbStoreConfig slaveConfig(RdbDoubleWriteTest::SLAVE_DATABASE_NAME);
+    DoubleWriteTestOpenCallback slaveHelper;
+    RdbDoubleWriteTest::slaveStore = RdbHelper::GetRdbStore(slaveConfig, 1, slaveHelper, errCode);
+    EXPECT_NE(RdbDoubleWriteTest::slaveStore, nullptr);
+    LOG_INFO("RdbStore_DoubleWrite_025 reopen slave");
+
+    RdbDoubleWriteTest::CheckNumber(store, count + count);
+    std::shared_ptr<ResultSet> resultSet = slaveStore->QuerySql("SELECT * FROM test");
+    ASSERT_NE(resultSet, nullptr);
+    int countNum;
+    EXPECT_EQ(resultSet->GetRowCount(countNum), errCode);
+    EXPECT_GT(countNum, count);
+    EXPECT_LE(countNum, count + count);
+}
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_encrypt_decrypt_test.cpp b/relational_store/test/native/rdb/unittest/rdb_encrypt_decrypt_test.cpp
index d1836d23b81c27f4dd1e313a0012317a9bc93b7a..d2faa3d007daa55ba978b867c5e9f41e8d56a964 100644
--- a/relational_store/test/native/rdb/unittest/rdb_encrypt_decrypt_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_encrypt_decrypt_test.cpp
@@ -347,9 +347,9 @@ HWTEST_F(RdbEncryptTest, AbnomalRdbStore_RdbPassword_001, TestSize.Level2)
     RdbPassword password1;
     RdbPassword password2;
     int errCode = E_OK;
-    uint8_t inputData[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    uint8_t inputData[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
     std::ostringstream ss;
-    std::copy(inputData, inputData+sizeof(inputData), std::ostream_iterator<int>(ss));
+    std::copy(inputData, inputData + sizeof(inputData), std::ostream_iterator<int>(ss));
 
     // if size_t > 128
     errCode = password1.SetValue(inputData, 256);
diff --git a/relational_store/test/native/rdb/unittest/rdb_execute_test.cpp b/relational_store/test/native/rdb/unittest/rdb_execute_test.cpp
index 12c768d0ee5d06e90a52c6e3e7f067122e0eb110..821397db7b3c1f1a84715c1f979d1ce6de3eff0e 100644
--- a/relational_store/test/native/rdb/unittest/rdb_execute_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_execute_test.cpp
@@ -319,7 +319,7 @@ HWTEST_F(RdbExecuteTest, RdbStore_Execute_009, TestSize.Level1)
     EXPECT_EQ(E_OK, ret);
     EXPECT_EQ(ValueObjectType::TYPE_INT, outValue.GetType());
 
-    int64_t outputResult {0};
+    int64_t outputResult{ 0 };
     outValue.GetLong(outputResult);
     EXPECT_EQ(5, outputResult);
 
@@ -349,8 +349,8 @@ HWTEST_F(RdbExecuteTest, RdbStore_Execute_0011, TestSize.Level1)
 {
     std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
 
-    std::vector<ValueObject> args = {
-        ValueObject(std::string("tt")), ValueObject(int(28)), ValueObject(double(50000.0)) };
+    std::vector<ValueObject> args = { ValueObject(std::string("tt")), ValueObject(int(28)),
+        ValueObject(double(50000.0)) };
     auto [ret, outValue] = store->Execute("INSERT INTO test(name, age, salary) VALUES (?, ?, ?);", args);
     EXPECT_EQ(E_OK, ret);
     EXPECT_EQ(ValueObjectType::TYPE_INT, outValue.GetType());
diff --git a/relational_store/test/native/rdb/unittest/rdb_get_store_test.cpp b/relational_store/test/native/rdb/unittest/rdb_get_store_test.cpp
index e9300c8ca04dce4849a2b89c973ec85202fd1138..496aa616bedd2225ab6acd703d5f6254141c4da0 100644
--- a/relational_store/test/native/rdb/unittest/rdb_get_store_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_get_store_test.cpp
@@ -195,13 +195,13 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_001, TestSize.Level1)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_001
+ * @tc.name: RdbStore_GetStore_002
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00101, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_002, TestSize.Level1)
 {
     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS);
     GetOpenCallback helper;
@@ -216,13 +216,13 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00101, TestSize.Level1)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_001
+ * @tc.name: RdbStore_GetStore_003
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00102, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_003, TestSize.Level1)
 {
     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
     GetOpenCallback helper;
@@ -247,13 +247,13 @@ std::shared_ptr<RdbStore> RdbGetStoreTest::CreateGetRDB(int version)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_002
+ * @tc.name: RdbStore_GetStore_004
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_002, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_004, TestSize.Level1)
 {
     std::shared_ptr<RdbStore> store1 = CreateGetRDB(1);
 
@@ -317,26 +317,26 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_002, TestSize.Level1)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_003
+ * @tc.name: RdbStore_GetStore_005
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_003, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_005, TestSize.Level1)
 {
     sleep(1);
     CreateRDB(2);
 }
 
 /**
- * @tc.name: RdbStore_GetStore_001
+ * @tc.name: RdbStore_GetStore_006
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00103, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_006, TestSize.Level1)
 {
     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_STATUS);
     GetOpenCallback helper;
@@ -351,13 +351,13 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00103, TestSize.Level1)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_001
+ * @tc.name: RdbStore_GetStore_007
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00104, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_007, TestSize.Level1)
 {
     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
     GetOpenCallback helper;
@@ -372,13 +372,13 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00104, TestSize.Level1)
 }
 
 /**
- * @tc.name: RdbStore_GetStore_001
+ * @tc.name: RdbStore_GetStore_008
  * @tc.desc: createRDB
  * @tc.type: FUNC
  * @tc.require: issue
  * @tc.author: lcl
  */
-HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00106, TestSize.Level1)
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_008, TestSize.Level1)
 {
     RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME_MINUS);
     config.SetCustomDir("SetCustomDirTest/");
@@ -387,3 +387,84 @@ HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_00106, TestSize.Level1)
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
     EXPECT_NE(store, nullptr);
 }
+
+/**
+ * @tc.name: RdbStore_GetStore_009
+ * @tc.desc: get database with quick_check
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbGetStoreTest, GetDatabase_009, TestSize.Level0)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
+    config.SetIntegrityCheck(IntegrityCheck::QUICK);
+    GetOpenCallback helper;
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+}
+
+/**
+ * @tc.name: RdbStore_GetStore_010
+ * @tc.desc: get database with quick_check
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_010, TestSize.Level0)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
+    config.SetIntegrityCheck(IntegrityCheck::FULL);
+    GetOpenCallback helper;
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_NE(store, nullptr);
+}
+
+/**
+ * @tc.name: RdbStore_GetStore_011
+ * @tc.desc: use libs as relative path to get rdbStore
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_011, TestSize.Level0)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
+    std::vector<std::string> paths = { "./" };
+    config.SetPluginLibs(paths);
+    GetOpenCallback helper;
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_SQLITE_ERROR);
+    EXPECT_EQ(store, nullptr);
+}
+
+/**
+ * @tc.name: RdbStore_GetStore_012
+ * @tc.desc: use libs as empty path to get rdbStore
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_012, TestSize.Level0)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
+    std::vector<std::string> paths = { "", "" };
+    config.SetPluginLibs(paths);
+    GetOpenCallback helper;
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_OK);
+    EXPECT_NE(store, nullptr);
+}
+
+/**
+ * @tc.name: RdbStore_GetStore_013
+ * @tc.desc: use libs as invalid path to get rdbStore
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbGetStoreTest, RdbStore_GetStore_013, TestSize.Level0)
+{
+    int errCode = E_OK;
+    RdbStoreConfig config(RdbGetStoreTest::MAIN_DATABASE_NAME);
+    std::vector<std::string> paths = { "", "/data/errPath/libErr.so" };
+    config.SetPluginLibs(paths);
+    GetOpenCallback helper;
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
+    EXPECT_EQ(store, nullptr);
+}
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_insert_test.cpp b/relational_store/test/native/rdb/unittest/rdb_insert_test.cpp
index 5c7ad643ca278aaf72a000bd36f394425c37d7d9..5e8d09c0f1342e82116c1075e9e8bd72d193b3e9 100644
--- a/relational_store/test/native/rdb/unittest/rdb_insert_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_insert_test.cpp
@@ -51,10 +51,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string InsertTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                              + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                            "name TEXT NOT NULL, age INTEGER, salary "
-                                                                            "REAL, blobType BLOB)");
+const std::string InsertTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int InsertTestOpenCallback::OnCreate(RdbStore &store)
 {
diff --git a/relational_store/test/native/rdb/unittest/rdb_open_callback_test.cpp b/relational_store/test/native/rdb/unittest/rdb_open_callback_test.cpp
index 0f53ad5a167683fe27e24681f2e789881af7291e..6e8e894de4f4895d4687179abeb84bc1f11715c0 100644
--- a/relational_store/test/native/rdb/unittest/rdb_open_callback_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_open_callback_test.cpp
@@ -72,8 +72,8 @@ public:
 
 std::string OpenCallbackA::CreateTableSQL(const std::string &tableName)
 {
-    return "CREATE TABLE IF NOT EXISTS " + tableName
-           + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)";
+    return "CREATE TABLE IF NOT EXISTS " + tableName +
+           " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)";
 }
 
 std::string OpenCallbackA::DropTableSQL(const std::string &tableName)
@@ -279,8 +279,8 @@ public:
 
 std::string OpenCallbackB::CreateTableSQL(const std::string &tableName)
 {
-    return "CREATE TABLE IF NOT EXISTS " + tableName
-           + " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)";
+    return "CREATE TABLE IF NOT EXISTS " + tableName +
+           " (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)";
 }
 
 std::string OpenCallbackB::DropTableSQL(const std::string &tableName)
diff --git a/relational_store/test/native/rdb/unittest/rdb_predicates_join_b_test.cpp b/relational_store/test/native/rdb/unittest/rdb_predicates_join_b_test.cpp
index eeccf2577185293e7f767ce1ad18ead52b1f2f20..e027706f7caa1425b74e7d715fd325d7b15119ee 100644
--- a/relational_store/test/native/rdb/unittest/rdb_predicates_join_b_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_predicates_join_b_test.cpp
@@ -17,18 +17,19 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <string>
-#include <vector>
-#include <sstream>
+
 #include <algorithm>
 #include <ctime>
+#include <sstream>
+#include <string>
+#include <vector>
 
+#include "abs_predicates.h"
 #include "common.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
 #include "rdb_open_callback.h"
 #include "rdb_predicates.h"
-#include "abs_predicates.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -56,18 +57,19 @@ protected:
 
 const std::string RdbStorePredicateJoinBTest::DATABASE_NAME = RDB_TEST_PATH + "predicates_join_b_test.db";
 
-const std::string CREATE_TABLE_DEPT_SQL = std::string("CREATE TABLE IF NOT EXISTS dept ") +
-      std::string("(id INTEGER PRIMARY KEY , dName TEXT , loc TEXT)");
+const std::string CREATE_TABLE_DEPT_SQL =
+    std::string("CREATE TABLE IF NOT EXISTS dept ") + std::string("(id INTEGER PRIMARY KEY , dName TEXT , loc TEXT)");
 const std::string CREATE_TABLE_JOB_SQL = std::string("CREATE TABLE IF NOT EXISTS job ") +
-      std::string("(id INTEGER PRIMARY KEY , jName TEXT , description TEXT)");
-const std::string CREATE_TABLE_EMP_SQL = std::string("CREATE TABLE IF NOT EXISTS emp ") +
-      std::string("(id INTEGER PRIMARY KEY ,eName TEXT, jobId INTEGER , ") +
-      std::string("mgr INTEGER, joinDate TEXT, salary REAL, bonus REAL, deptId INTEGER,") +
-      std::string("FOREIGN KEY (jobId) REFERENCES job (id) ON UPDATE NO ACTION ON DELETE CASCADE,") +
-      std::string("FOREIGN KEY (deptId) REFERENCES dept (id) ON UPDATE NO ACTION ON DELETE CASCADE)");
-const std::string CREATE_TABLE_SALARYGRADE_SQL = std::string("CREATE TABLE IF NOT EXISTS salarygrade") +
-      std::string("(grade INTEGER PRIMARY KEY,loSalary INTEGER, hiSalary INTEGER)");
-
+                                         std::string("(id INTEGER PRIMARY KEY , jName TEXT , description TEXT)");
+const std::string CREATE_TABLE_EMP_SQL =
+    std::string("CREATE TABLE IF NOT EXISTS emp ") +
+    std::string("(id INTEGER PRIMARY KEY ,eName TEXT, jobId INTEGER , ") +
+    std::string("mgr INTEGER, joinDate TEXT, salary REAL, bonus REAL, deptId INTEGER,") +
+    std::string("FOREIGN KEY (jobId) REFERENCES job (id) ON UPDATE NO ACTION ON DELETE CASCADE,") +
+    std::string("FOREIGN KEY (deptId) REFERENCES dept (id) ON UPDATE NO ACTION ON DELETE CASCADE)");
+const std::string CREATE_TABLE_SALARYGRADE_SQL =
+    std::string("CREATE TABLE IF NOT EXISTS salarygrade") +
+    std::string("(grade INTEGER PRIMARY KEY,loSalary INTEGER, hiSalary INTEGER)");
 
 class PredicateJoinBTestOpenCallback : public RdbOpenCallback {
 public:
@@ -75,7 +77,6 @@ public:
     int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
 };
 
-
 int PredicateJoinBTestOpenCallback::OnCreate(RdbStore &store)
 {
     return E_OK;
@@ -91,7 +92,9 @@ void RdbStorePredicateJoinBTest::SetUpTestCase(void)
     RdbHelper::DeleteRdbStore(RdbStorePredicateJoinBTest::DATABASE_NAME);
 }
 
-void RdbStorePredicateJoinBTest::TearDownTestCase(void) {}
+void RdbStorePredicateJoinBTest::TearDownTestCase(void)
+{
+}
 
 void RdbStorePredicateJoinBTest::SetUp(void)
 {
@@ -128,7 +131,7 @@ void RdbStorePredicateJoinBTest::GenerateAllTables()
 
 void RdbStorePredicateJoinBTest::InsertDeptDates()
 {
-    int64_t  id;
+    int64_t id;
     ValuesBucket values;
 
     values.PutInt("id", 10);
@@ -157,7 +160,7 @@ void RdbStorePredicateJoinBTest::InsertDeptDates()
 
 void RdbStorePredicateJoinBTest::InsertJobDates()
 {
-    int64_t  id;
+    int64_t id;
     ValuesBucket values;
 
     values.PutInt("id", 1);
@@ -197,7 +200,7 @@ void RdbStorePredicateJoinBTest::InsertEmpDates()
 
 void RdbStorePredicateJoinBTest::InsertSalarygradeDates()
 {
-    int64_t  id;
+    int64_t id;
     ValuesBucket values;
 
     values.PutInt("grade", 1);
@@ -407,7 +410,6 @@ HWTEST_F(RdbStorePredicateJoinBTest, RdbStore_InnerJoinB_003, TestSize.Level1)
     EXPECT_EQ(12000, hiSalary);
 }
 
-
 /* *
  * @tc.name: RdbStore_InnerJoinB_004
  * @tc.desc: Normal testCase of RdbPredicates for InnerJoin
@@ -432,7 +434,7 @@ HWTEST_F(RdbStorePredicateJoinBTest, RdbStore_InnerJoinB_004, TestSize.Level1)
     EXPECT_EQ("", predicates.GetJoinConditions()[1]);
     EXPECT_EQ("ON(t1.jobId = t2.id AND t1.deptId = t3.id AND t1.salary BETWEEN "
               "t4.losalary AND t4.hisalary)",
-              predicates.GetJoinConditions()[2]);
+        predicates.GetJoinConditions()[2]);
 
     std::vector<std::string> columns;
     columns.push_back("t1.eName");
@@ -475,7 +477,6 @@ HWTEST_F(RdbStorePredicateJoinBTest, RdbStore_InnerJoinB_004, TestSize.Level1)
     EXPECT_EQ(1, grade);
 }
 
-
 /* *
  * @tc.name: RdbStore_LeftOuterJoinB_005
  * @tc.desc: Normal testCase of RdbPredicates for LeftOuterJoin
diff --git a/relational_store/test/native/rdb/unittest/rdb_predicates_join_test.cpp b/relational_store/test/native/rdb/unittest/rdb_predicates_join_test.cpp
index 0be12d0d627631fbd8d8ddd901af47a8de6c4513..9e78fde7c8393e89110c6d1275cff6117c052e00 100644
--- a/relational_store/test/native/rdb/unittest/rdb_predicates_join_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_predicates_join_test.cpp
@@ -17,18 +17,19 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <string>
-#include <vector>
-#include <sstream>
+
 #include <algorithm>
 #include <ctime>
+#include <sstream>
+#include <string>
+#include <vector>
 
+#include "abs_predicates.h"
 #include "common.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
 #include "rdb_open_callback.h"
 #include "rdb_predicates.h"
-#include "abs_predicates.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -64,7 +65,6 @@ public:
     int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
 };
 
-
 int PredicateJoinTestOpenCallback::OnCreate(RdbStore &store)
 {
     return E_OK;
@@ -75,9 +75,13 @@ int PredicateJoinTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, in
     return E_OK;
 }
 
-void RdbStorePredicateJoinTest::SetUpTestCase(void) {}
+void RdbStorePredicateJoinTest::SetUpTestCase(void)
+{
+}
 
-void RdbStorePredicateJoinTest::TearDownTestCase(void) {}
+void RdbStorePredicateJoinTest::TearDownTestCase(void)
+{
+}
 
 void RdbStorePredicateJoinTest::SetUp(void)
 {
@@ -105,7 +109,7 @@ void RdbStorePredicateJoinTest::GenerateAllTables()
 
 void RdbStorePredicateJoinTest::InsertUserDates()
 {
-    int64_t  id;
+    int64_t id;
     ValuesBucket values;
 
     values.PutInt("userId", 1);
@@ -150,7 +154,7 @@ void RdbStorePredicateJoinTest::InsertUserDates()
 
 void RdbStorePredicateJoinTest::InsertBookDates()
 {
-    int64_t  id;
+    int64_t id;
     ValuesBucket values;
 
     values.PutInt("id", 1);
@@ -470,7 +474,7 @@ HWTEST_F(RdbStorePredicateJoinTest, RdbStore_LeftOuterJoin_009, TestSize.Level1)
     EXPECT_EQ(2, predicates.GetJoinCount());
     predicates.Using(fields)->EqualTo("name", "SanGuo");
 
-    std::vector<std::string> joinTypes{"LEFT OUTER JOIN", "LEFT OUTER JOIN"};
+    std::vector<std::string> joinTypes{ "LEFT OUTER JOIN", "LEFT OUTER JOIN" };
     EXPECT_EQ(joinTypes, predicates.GetJoinTypes());
     EXPECT_EQ(0, predicates.GetJoinCount());
 
diff --git a/relational_store/test/native/rdb/unittest/rdb_predicates_test.cpp b/relational_store/test/native/rdb/unittest/rdb_predicates_test.cpp
index a367971303b160903ec8151223a8d0b1e710f207..05b44dcffc93538674617b6601bb00c7bea75458 100644
--- a/relational_store/test/native/rdb/unittest/rdb_predicates_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_predicates_test.cpp
@@ -13,23 +13,25 @@
  * limitations under the License.
  */
 
+#include "rdb_predicates.h"
+
 #include <gtest/gtest.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <string>
-#include <vector>
-#include <sstream>
+
 #include <algorithm>
 #include <climits>
 #include <ctime>
+#include <sstream>
+#include <string>
+#include <vector>
 
+#include "abs_rdb_predicates.h"
 #include "common.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
 #include "rdb_open_callback.h"
-#include "rdb_predicates.h"
-#include "abs_rdb_predicates.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -328,7 +330,8 @@ public:
 
 std::shared_ptr<RdbStore> RdbStorePredicateTest::store = nullptr;
 const std::string RdbStorePredicateTest::DATABASE_NAME = RDB_TEST_PATH + "predicates_test.db";
-const std::string CREATE_TABLE_ALL_DATA_TYPE_SQL = "CREATE TABLE IF NOT EXISTS AllDataType "
+const std::string CREATE_TABLE_ALL_DATA_TYPE_SQL =
+    "CREATE TABLE IF NOT EXISTS AllDataType "
     "(id INTEGER PRIMARY KEY AUTOINCREMENT, integerValue INTEGER , longValue INTEGER , "
     "shortValue INTEGER , booleanValue INTEGER , doubleValue REAL , floatValue REAL , "
     "stringValue TEXT , blobValue BLOB , clobValue TEXT , byteValue INTEGER , "
@@ -338,10 +341,12 @@ const std::string CREATE_TABLE_ALL_DATA_TYPE_SQL = "CREATE TABLE IF NOT EXISTS A
     "primBooleanValue INTEGER  NOT NULL, primByteValue INTEGER  NOT NULL, "
     "primCharValue TEXT, `orderr` INTEGER);";
 
-const std::string CREATE_TABLE_PERSON_SQL = "CREATE TABLE IF NOT EXISTS person "
-   "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT , age INTEGER , REAL INTEGER);";
+const std::string CREATE_TABLE_PERSON_SQL =
+    "CREATE TABLE IF NOT EXISTS person "
+    "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT , age INTEGER , REAL INTEGER);";
 
-const std::string ALL_DATA_TYPE_INSERT_SQL = "INSERT INTO AllDataType (id, integerValue, longValue, "
+const std::string ALL_DATA_TYPE_INSERT_SQL =
+    "INSERT INTO AllDataType (id, integerValue, longValue, "
     "shortValue, booleanValue, doubleValue, floatValue, stringValue, blobValue, "
     "clobValue, byteValue, timeValue, characterValue, primIntValue, primLongValue, "
     "primShortValue, primFloatValue, primDoubleValue, "
@@ -365,7 +370,8 @@ int PredicateTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int ne
 }
 
 void RdbStorePredicateTest::SetUpTestCase()
-{}
+{
+}
 
 void RdbStorePredicateTest::TearDownTestCase()
 {
@@ -387,7 +393,9 @@ void RdbStorePredicateTest::SetUp()
     RdbStorePredicateTest::GenerateAllDataTypeTable();
 }
 
-void RdbStorePredicateTest::TearDown(void) {}
+void RdbStorePredicateTest::TearDown(void)
+{
+}
 
 void RdbStorePredicateTest::GenerateAllDataTypeTable()
 {
@@ -407,7 +415,7 @@ void RdbStorePredicateTest::GenerateAllDataTypeTable()
 
 AllDataType RdbStorePredicateTest::RdbStorePredicateTest::BuildAllDataType1()
 {
-    std::vector<uint8_t> blob = {1, 2, 3};
+    std::vector<uint8_t> blob = { 1, 2, 3 };
     AllDataType dataType;
     dataType.SetId(1); // 1 means Id of the AllDataType object is 1
     dataType.SetIntegerValue(INT_MAX);
@@ -422,7 +430,7 @@ AllDataType RdbStorePredicateTest::RdbStorePredicateTest::BuildAllDataType1()
     dataType.SetClobValue("ABCDEFGHIJKLMN");
     dataType.SetByteValue(INT8_MAX);
 
-    std::vector<int> date = {2019, 7, 10};
+    std::vector<int> date = { 2019, 7, 10 };
     time_t timeValue = RdbStorePredicateTest::DateMakeTime(date);
     dataType.SetTimeValue(timeValue);
 
@@ -439,7 +447,7 @@ AllDataType RdbStorePredicateTest::RdbStorePredicateTest::BuildAllDataType1()
 
 AllDataType RdbStorePredicateTest::BuildAllDataType2()
 {
-    std::vector<uint8_t> blob = {1, 2, 3};
+    std::vector<uint8_t> blob = { 1, 2, 3 };
     AllDataType dataType2;
     dataType2.SetId(2); // 2 means Id of the AllDataType object is 2
     dataType2.SetIntegerValue(1);
@@ -454,7 +462,7 @@ AllDataType RdbStorePredicateTest::BuildAllDataType2()
     dataType2.SetClobValue("ABCDEFGHIJKLMN");
     dataType2.SetByteValue(INT8_MIN);
 
-    std::vector<int> date = {2019, 7, 17};
+    std::vector<int> date = { 2019, 7, 17 };
     time_t timeValue2 = RdbStorePredicateTest::DateMakeTime(date);
     dataType2.SetTimeValue(timeValue2);
 
@@ -471,7 +479,7 @@ AllDataType RdbStorePredicateTest::BuildAllDataType2()
 
 AllDataType RdbStorePredicateTest::BuildAllDataType3()
 {
-    std::vector<uint8_t> blob = {1, 2, 3};
+    std::vector<uint8_t> blob = { 1, 2, 3 };
     AllDataType dataType3;
     dataType3.SetId(3); // 3 means Id of the AllDataType object is 3
     dataType3.SetIntegerValue(INT_MIN);
@@ -486,7 +494,7 @@ AllDataType RdbStorePredicateTest::BuildAllDataType3()
     dataType3.SetClobValue("ABCDEFGHIJKLMN");
     dataType3.SetByteValue(INT8_MIN);
 
-    std::vector<int> date = {2019, 6, 10};
+    std::vector<int> date = { 2019, 6, 10 };
     time_t timeValue3 = RdbStorePredicateTest::DateMakeTime(date);
     dataType3.SetTimeValue(timeValue3);
 
@@ -541,7 +549,7 @@ void RdbStorePredicateTest::InsertDates(std::vector<AllDataType> dataTypes)
         strByte.str("");
         strByte << dataTypes[i].GetPrimDoubleValue();
         objects.push_back(ValueObject(strByte.str()));
-        objects.push_back(ValueObject(dataTypes[i].IsPrimBooleanValue() ? (char) 1 : (char) 0));
+        objects.push_back(ValueObject(dataTypes[i].IsPrimBooleanValue() ? (char)1 : (char)0));
         objects.push_back(ValueObject(dataTypes[i].GetPrimByteValue()));
 
         strByte.str("");
@@ -555,7 +563,7 @@ void RdbStorePredicateTest::InsertDates(std::vector<AllDataType> dataTypes)
 
 time_t RdbStorePredicateTest::DateMakeTime(std::vector<int> data)
 {
-    struct tm t1 = {0};
+    struct tm t1 = { 0 };
     t1.tm_year = data[0] - 1990;
     t1.tm_mon = data[1] - 1;
     t1.tm_hour = data[2];
@@ -597,7 +605,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_RdbPredicates_001, TestSize.Level1)
 HWTEST_F(RdbStorePredicateTest, RdbStore_RdbPredicates_002, TestSize.Level1)
 {
     std::vector<std::string> tableEmpty;
-    std::vector<std::string> tables({"AllDataType", "person"});
+    std::vector<std::string> tables({ "AllDataType", "person" });
 
     AbsRdbPredicates predicates1(tableEmpty);
     AbsRdbPredicates predicates2(tables);
@@ -668,7 +676,7 @@ void RdbStorePredicateTest::CalendarTest(RdbPredicates predicates1)
     std::vector<std::string> columns;
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 7, 17};
+    std::vector<int> date = { 2019, 7, 17 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
 
     predicates1.EqualTo("timeValue", std::to_string(calendarTime));
@@ -733,7 +741,7 @@ void RdbStorePredicateTest::BasicDataTypeTest(RdbPredicates predicates1)
     EXPECT_EQ(3, valueInt);
 
     predicates1.Clear();
-    predicates1.EqualTo("blobValue", std::vector<uint8_t>{1, 2, 3});
+    predicates1.EqualTo("blobValue", std::vector<uint8_t>{ 1, 2, 3 });
     std::shared_ptr<ResultSet> allDataTypes9 = RdbStorePredicateTest::store->Query(predicates1, columns);
     // 3 rows in the resultSet when blobValue={1, 2, 3}
     EXPECT_EQ(3, ResultSize(allDataTypes9));
@@ -838,7 +846,7 @@ void RdbStorePredicateTest::CalendarTest002(RdbPredicates predicates1)
     std::vector<std::string> columns;
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 7, 17};
+    std::vector<int> date = { 2019, 7, 17 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
 
     predicates1.NotEqualTo("timeValue", std::to_string(calendarTime));
@@ -966,7 +974,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThan_005, TestSize.Level1)
     EXPECT_EQ(2, ResultSize(allDataTypes5));
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 6, 9};
+    std::vector<int> date = { 2019, 6, 9 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
     predicates1.GreaterThan("timeValue", std::to_string(calendarTime).c_str());
     std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
@@ -1014,7 +1022,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_GreaterThanOrEqualTo_006, TestSize.Leve
     EXPECT_EQ(3, ResultSize(allDataTypes5));
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 6, 9};
+    std::vector<int> date = { 2019, 6, 9 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
     predicates1.GreaterThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
     std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
@@ -1068,7 +1076,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_lessThan_007, TestSize.Level1)
     EXPECT_EQ(0, ResultSize(allDataTypes5));
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 6, 9};
+    std::vector<int> date = { 2019, 6, 9 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
     predicates1.LessThan("timeValue", std::to_string(calendarTime).c_str());
     std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
@@ -1116,7 +1124,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_LessThanOrEqualTo_008, TestSize.Level1)
     EXPECT_EQ(1, ResultSize(allDataTypes5));
 
     predicates1.Clear();
-    std::vector<int> date = {2019, 6, 9};
+    std::vector<int> date = { 2019, 6, 9 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
     predicates1.LessThanOrEqualTo("timeValue", std::to_string(calendarTime).c_str());
     std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
@@ -1167,9 +1175,9 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_Between_009, TestSize.Level1)
     EXPECT_EQ(3, ResultSize(allDataTypes5));
 
     predicates1.Clear();
-    std::vector<int> lowCalendar = {2019, 6, 9};
+    std::vector<int> lowCalendar = { 2019, 6, 9 };
     time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
-    std::vector<int> highCalendar = {2019, 7, 17};
+    std::vector<int> highCalendar = { 2019, 7, 17 };
     time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
     predicates1.Between("timeValue", std::to_string(lowCalendarTime).c_str(), std::to_string(highCalendarTime).c_str());
     std::shared_ptr<ResultSet> allDataTypes6 = RdbStorePredicateTest::store->Query(predicates1, columns);
@@ -1252,11 +1260,11 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_BeginEndWrap_014, TestSize.Level1)
     std::vector<std::string> columns;
 
     predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
-    ->BeginWrap()
-    ->EqualTo("integerValue", "1")
-    ->Or()
-    ->EqualTo("integerValue", std::to_string(INT_MAX))
-    ->EndWrap();
+        ->BeginWrap()
+        ->EqualTo("integerValue", "1")
+        ->Or()
+        ->EqualTo("integerValue", std::to_string(INT_MAX))
+        ->EndWrap();
     std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
     EXPECT_EQ(2, ResultSize(allDataTypes1));
 
@@ -1278,11 +1286,11 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_AndOR_015, TestSize.Level1)
     std::vector<std::string> columns;
 
     predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
-    ->BeginWrap()
-    ->EqualTo("integerValue", "1")
-    ->Or()
-    ->EqualTo("integerValue", std::to_string(INT_MAX))
-    ->EndWrap();
+        ->BeginWrap()
+        ->EqualTo("integerValue", "1")
+        ->Or()
+        ->EqualTo("integerValue", std::to_string(INT_MAX))
+        ->EndWrap();
 
     std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
     EXPECT_EQ(2, ResultSize(allDataTypes1));
@@ -1460,9 +1468,9 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_NotBetween_020, TestSize.Level1)
     std::shared_ptr<ResultSet> allDataTypes5 = RdbStorePredicateTest::store->Query(predicates1, columns);
     EXPECT_EQ(0, ResultSize(allDataTypes5));
 
-    std::vector<int> lowCalendar = {2019, 6, 9};
+    std::vector<int> lowCalendar = { 2019, 6, 9 };
     time_t lowCalendarTime = RdbStorePredicateTest::DateMakeTime(lowCalendar);
-    std::vector<int> highCalendar = {2019, 7, 17};
+    std::vector<int> highCalendar = { 2019, 7, 17 };
     time_t highCalendarTime = RdbStorePredicateTest::DateMakeTime(highCalendar);
     predicates1.Clear();
     predicates1.NotBetween("timeValue", std::to_string(lowCalendarTime), std::to_string(highCalendarTime));
@@ -1481,8 +1489,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_ComplexPredicate_021, TestSize.Level1)
     RdbPredicates predicates1("AllDataType");
     std::vector<std::string> columns;
 
-    predicates1.Glob("stringValue", "ABC*")->EqualTo("booleanValue", "1")
-    ->NotBetween("longValue", "0", "2");
+    predicates1.Glob("stringValue", "ABC*")->EqualTo("booleanValue", "1")->NotBetween("longValue", "0", "2");
     std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
     EXPECT_EQ(1, ResultSize(allDataTypes1));
 }
@@ -1510,13 +1517,13 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_ClearMethod_022, TestSize.Level1)
     std::vector<std::string> columns;
 
     predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
-    ->BeginWrap()
-    ->EqualTo("integerValue", "1")
-    ->Or()
-    ->EqualTo("integerValue", std::to_string(INT_MAX))
-    ->EndWrap()
-    ->OrderByDesc("integerValue")
-    ->Limit(2);
+        ->BeginWrap()
+        ->EqualTo("integerValue", "1")
+        ->Or()
+        ->EqualTo("integerValue", std::to_string(INT_MAX))
+        ->EndWrap()
+        ->OrderByDesc("integerValue")
+        ->Limit(2);
 
     std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
     EXPECT_EQ(2, ResultSize(allDataTypes1));
@@ -1550,8 +1557,8 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_ClearMethod_022, TestSize.Level1)
     predicates1.Clear();
     EXPECT_EQ("AllDataType", predicates1.GetTableName());
     EXPECT_EQ(-2147483648, predicates1.GetLimit());
-    EXPECT_EQ(true,  predicates1.GetWhereClause().empty());
-    EXPECT_EQ(true,  predicates1.GetWhereArgs().empty());
+    EXPECT_EQ(true, predicates1.GetWhereClause().empty());
+    EXPECT_EQ(true, predicates1.GetWhereArgs().empty());
 
     EXPECT_EQ(true, predicates1.GetJoinTableNames().empty());
     EXPECT_EQ(0, predicates1.GetJoinCount());
@@ -1572,7 +1579,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_InMethod_023, TestSize.Level1)
 {
     RdbPredicates rdbPredicates1("AllDataType");
     std::vector<std::string> columns;
-    std::vector<std::string> agrs = {std::to_string(INT_MAX)};
+    std::vector<std::string> agrs = { std::to_string(INT_MAX) };
     rdbPredicates1.In("integerValue", agrs);
     std::shared_ptr<ResultSet> resultSet1 = RdbStorePredicateTest::store->Query(rdbPredicates1, columns);
     int count = 0;
@@ -1599,7 +1606,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_InMethod_023, TestSize.Level1)
     resultSet4->GetRowCount(count);
     EXPECT_EQ(1, count);
 
-    std::vector<int> date = {2019, 6, 10};
+    std::vector<int> date = { 2019, 6, 10 };
     time_t calendarTime = RdbStorePredicateTest::DateMakeTime(date);
     RdbPredicates rdbPredicates5("AllDataType");
     agrs[0] = std::to_string(calendarTime);
@@ -1618,7 +1625,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_InMethod_023, TestSize.Level1)
 HWTEST_F(RdbStorePredicateTest, RdbStore_NotInMethod_023, TestSize.Level1)
 {
     std::vector<std::string> columns;
-    std::vector<std::string> agrs = {std::to_string(INT_MAX), std::to_string(INT_MIN)};
+    std::vector<std::string> agrs = { std::to_string(INT_MAX), std::to_string(INT_MIN) };
     std::stringstream tempValue;
 
     RdbPredicates rdbPredicates1("AllDataType");
@@ -1667,13 +1674,15 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_KeywordMethod_024, TestSize.Level1)
 {
     RdbPredicates predicates1("AllDataType");
     predicates1.EqualTo("stringValue", "ABCDEFGHIJKLMN")
-    ->BeginWrap()
-    ->EqualTo("integerValue", "1")
-    ->Or()
-    ->EqualTo("integerValue", std::to_string(INT_MAX))
-    ->EndWrap()->OrderByDesc("integerValue")->Limit(2);
+        ->BeginWrap()
+        ->EqualTo("integerValue", "1")
+        ->Or()
+        ->EqualTo("integerValue", std::to_string(INT_MAX))
+        ->EndWrap()
+        ->OrderByDesc("integerValue")
+        ->Limit(2);
 
-    std::vector<std::string> columns = {"booleanValue", "doubleValue", "orderr"};
+    std::vector<std::string> columns = { "booleanValue", "doubleValue", "orderr" };
     std::shared_ptr<ResultSet> allDataTypes1 = RdbStorePredicateTest::store->Query(predicates1, columns);
     allDataTypes1->GoToFirstRow();
     int count = ResultSize(allDataTypes1);
@@ -1756,9 +1765,9 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_InDevices_InAllDevices_026, TestSize.Le
     std::vector<std::string> devices;
     devices.push_back("7001005458323933328a071dab423800");
     devices.push_back("7001005458323933328a268fa2fa3900");
-    AbsRdbPredicates* absRdbPredicates = predicates.InDevices(devices);
+    AbsRdbPredicates *absRdbPredicates = predicates.InDevices(devices);
     EXPECT_NE(absRdbPredicates, nullptr);
-    AbsRdbPredicates* absRdbPredicates1 = predicates.InAllDevices();
+    AbsRdbPredicates *absRdbPredicates1 = predicates.InAllDevices();
     EXPECT_NE(absRdbPredicates1, nullptr);
     EXPECT_EQ(absRdbPredicates, absRdbPredicates1);
 }
@@ -1810,7 +1819,6 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_NotInMethod_028, TestSize.Level1)
     resultSet2->Close();
 }
 
-
 /* *
  * @tc.name: RdbStore_NotContain_029
  * @tc.desc: Normal testCase of RdbPredicates for Not Contain
@@ -1827,7 +1835,6 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_NotContain_029, TestSize.Level1)
     EXPECT_EQ(3, ResultSize(allDataTypes1));
 }
 
-
 /* *
  * @tc.name: RdbStore_NotLike_030
  * @tc.desc: Normal testCase of RdbPredicates for Not Like
@@ -2246,7 +2253,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_001, TestSize.Level1)
 HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_002, TestSize.Level1)
 {
     RdbPredicates predicates("AllDataType");
-    predicates.GroupBy({"idx"});
+    predicates.GroupBy({ "idx" });
 
     std::vector<std::string> columns;
     std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
@@ -2262,7 +2269,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_002, TestSize.Level1)
 HWTEST_F(RdbStorePredicateTest, RdbStore_GroupBy_003, TestSize.Level1)
 {
     RdbPredicates predicates("AllDataType");
-    predicates.GroupBy({""});
+    predicates.GroupBy({ "" });
 
     std::vector<std::string> columns;
     std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
@@ -2332,7 +2339,7 @@ HWTEST_F(RdbStorePredicateTest, RdbStore_In_002, TestSize.Level1)
 
     std::vector<std::string> columns;
     std::shared_ptr<ResultSet> allDataTypes = RdbStorePredicateTest::store->Query(predicates, columns);
-    EXPECT_EQ(3, ResultSize(allDataTypes));
+    EXPECT_EQ(0, ResultSize(allDataTypes));
     allDataTypes->Close();
 }
 
diff --git a/relational_store/test/native/rdb/unittest/rdb_read_only_test.cpp b/relational_store/test/native/rdb/unittest/rdb_read_only_test.cpp
index 53c4f3b2d68aed1ea388ead16ebb55d28c7914c7..d0600b8810ac93506a6bf1bb2f31a55a6f901fcc 100644
--- a/relational_store/test/native/rdb/unittest/rdb_read_only_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_read_only_test.cpp
@@ -50,7 +50,8 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string ReadOnlyTestOpenCallback::CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test "
+const std::string ReadOnlyTestOpenCallback::CREATE_TABLE_TEST =
+    "CREATE TABLE IF NOT EXISTS test "
     "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER, salary REAL, blobType BLOB)";
 
 int ReadOnlyTestOpenCallback::OnCreate(RdbStore &store)
@@ -503,4 +504,3 @@ HWTEST_F(RdbReadOnlyTest, RdbStore_ReadOnly_0022, TestSize.Level1)
     auto ret = store->CleanDirtyData("test", cursor);
     EXPECT_EQ(E_NOT_SUPPORT, ret);
 }
-
diff --git a/relational_store/test/native/rdb/unittest/rdb_security_manager_test.cpp b/relational_store/test/native/rdb/unittest/rdb_security_manager_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22094b1226aa45f18557c2e4899a66e0cae349eb
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/rdb_security_manager_test.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "RdbSecurityManagerTest"
+#include "rdb_security_manager.h"
+
+#include <block_data.h>
+#include <gtest/gtest.h>
+#include <thread>
+
+#include "common.h"
+#include "rdb_errno.h"
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+namespace Test {
+using KeyType = RdbSecurityManager::KeyFileType;
+class RdbSecurityManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+
+protected:
+    static constexpr const char *BUNDLE_NAME = "rdb.security.manager.test";
+    static constexpr const char *DB_FILE = "security_manager_test.db";
+    const std::string dbFile_ = RDB_TEST_PATH + DB_FILE;
+};
+
+void RdbSecurityManagerTest::SetUpTestCase(void)
+{
+    RdbSecurityManager::GetInstance().Init(BUNDLE_NAME);
+}
+
+void RdbSecurityManagerTest::TearDownTestCase(void)
+{
+}
+
+void RdbSecurityManagerTest::SetUp(void)
+{
+}
+
+void RdbSecurityManagerTest::TearDown(void)
+{
+}
+
+/**
+ * @tc.name: Insert_BigInt_INT64
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbSecurityManagerTest, RestoreKeyFile, TestSize.Level1)
+{
+    std::vector<uint8_t> key = {
+        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F
+    };
+    auto errCode = RdbSecurityManager::GetInstance().RestoreKeyFile(dbFile_, key);
+    ASSERT_EQ(errCode, E_OK);
+    auto password = RdbSecurityManager::GetInstance().GetRdbPassword(dbFile_, KeyType::PUB_KEY_FILE);
+    ASSERT_EQ(password.GetSize(), key.size());
+    auto ret = memcmp(password.GetData(), key.data(), password.GetSize());
+    ASSERT_EQ(ret, 0);
+}
+
+/**
+ * @tc.name: Insert_BigInt_INT64
+ * @tc.desc: test insert bigint to rdb store
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbSecurityManagerTest, LockUnlock, TestSize.Level1)
+{
+    auto blockResult = std::make_shared<OHOS::BlockData<bool>>(1, false);
+    RdbSecurityManager::KeyFiles keyFiles(dbFile_);
+    keyFiles.Lock();
+    std::thread thread([dbFile = dbFile_, blockResult]() {
+        RdbSecurityManager::KeyFiles keyFiles(dbFile);
+        keyFiles.Lock();
+        keyFiles.Unlock();
+        blockResult->SetValue(true);
+    });
+    auto beforeUnlock = blockResult->GetValue();
+    blockResult->Clear(false);
+    keyFiles.Unlock();
+    auto afterUnlock = blockResult->GetValue();
+    ASSERT_FALSE(beforeUnlock);
+    ASSERT_TRUE(afterUnlock);
+    thread.join();
+}
+}
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_sql_utils_test.cpp b/relational_store/test/native/rdb/unittest/rdb_sql_utils_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c66c160a49f9b8803876ebbc5ae661cb20069b0
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/rdb_sql_utils_test.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rdb_sql_utils.h"
+
+#include <gtest/gtest.h>
+
+#include <climits>
+#include <string>
+
+#include "grd_type_export.h"
+#include "rd_utils.h"
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+
+class RdbSqlUtilsTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp(void){};
+    void TearDown(void){};
+};
+
+void RdbSqlUtilsTest::SetUpTestCase(void)
+{
+}
+
+void RdbSqlUtilsTest::TearDownTestCase(void)
+{
+}
+
+/**
+ * @tc.name: RdbStore_SqliteUtils_001
+ * @tc.desc: Normal testCase of sqlite_utils for IsSpecial, if sqlType is special
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbSqlUtilsTest, RdbSqlUtils_Test_001, TestSize.Level1)
+{
+    auto [dataBasePath, errCode] = RdbSqlUtils::GetDefaultDatabasePath("/data/test", "RdbTest.db");
+    EXPECT_EQ(dataBasePath, "/data/test/rdb/RdbTest.db");
+    EXPECT_EQ(errCode, E_OK);
+
+    auto [dataBasePath1, errCode1] = RdbSqlUtils::GetDefaultDatabasePath("/data/test", "RdbTest.db", "myself");
+    EXPECT_EQ(dataBasePath1, "/data/test/rdb/myself/RdbTest.db");
+    EXPECT_EQ(errCode1, E_OK);
+}
diff --git a/relational_store/test/native/rdb/unittest/rdb_sqlite_shared_result_set_test.cpp b/relational_store/test/native/rdb/unittest/rdb_sqlite_shared_result_set_test.cpp
index 8417f70fd84768d6d93c7c0a53bb1f7b515d9145..759d0f35b81750b933de5ae39434e46c38790e0d 100644
--- a/relational_store/test/native/rdb/unittest/rdb_sqlite_shared_result_set_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_sqlite_shared_result_set_test.cpp
@@ -38,8 +38,8 @@ public:
     void GenerateDefaultTable();
     void GenerateAssetsTable();
     void GenerateTimeoutTable();
-    void CheckResultSetAttribute(std::shared_ptr<ResultSet> rstSet, int pos, bool isStart, bool isAtFirstRow,
-        bool isEnded);
+    void CheckResultSetAttribute(
+        std::shared_ptr<ResultSet> rstSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded);
 
     static const std::string DATABASE_NAME;
     static std::shared_ptr<RdbStore> store;
@@ -90,7 +90,8 @@ void RdbSqliteSharedResultSetTest::SetUp()
 }
 
 void RdbSqliteSharedResultSetTest::TearDown()
-{}
+{
+}
 
 void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
 {
@@ -103,7 +104,7 @@ void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
     values.PutString("data1", std::string("hello"));
     values.PutInt("data2", 10);
     values.PutDouble("data3", 1.0);
-    values.PutBlob("data4", std::vector<uint8_t> { 66 });
+    values.PutBlob("data4", std::vector<uint8_t>{ 66 });
     store->Insert(id, "test", values);
 
     values.Clear();
@@ -111,7 +112,7 @@ void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
     values.PutString("data1", std::string("2"));
     values.PutInt("data2", -5);
     values.PutDouble("data3", 2.5);
-    values.PutBlob("data4", std::vector<uint8_t> {});
+    values.PutBlob("data4", std::vector<uint8_t>{});
     store->Insert(id, "test", values);
 
     values.Clear();
@@ -119,7 +120,7 @@ void RdbSqliteSharedResultSetTest::GenerateDefaultTable()
     values.PutString("data1", std::string("hello world"));
     values.PutInt("data2", 3);
     values.PutDouble("data3", 1.8);
-    values.PutBlob("data4", std::vector<uint8_t> {});
+    values.PutBlob("data4", std::vector<uint8_t>{});
     store->Insert(id, "test", values);
 }
 
@@ -176,8 +177,8 @@ void RdbSqliteSharedResultSetTest::GenerateTimeoutTable()
     store->Insert(id, "test", values);
 }
 
-void RdbSqliteSharedResultSetTest::CheckResultSetAttribute(std::shared_ptr<ResultSet> rstSet, int pos, bool isStart,
-    bool isAtFirstRow, bool isEnded)
+void RdbSqliteSharedResultSetTest::CheckResultSetAttribute(
+    std::shared_ptr<ResultSet> rstSet, int pos, bool isStart, bool isAtFirstRow, bool isEnded)
 {
     int position = -1;
     int iRet = rstSet->GetRowIndex(position);
@@ -366,9 +367,9 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_001, TestSize.Le
     sz = blob.size();
     EXPECT_EQ(sz, 0);
 
-    bool isNull = false;
+    bool isNull = true;
     rstSet->IsColumnNull(4, isNull);
-    EXPECT_EQ(isNull, true);
+    EXPECT_EQ(isNull, false);
 
     ret = -1;
     ret = rstSet->GoToPreviousRow();
@@ -421,7 +422,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_002, TestSize.Le
     bool isAtLastRow = false;
     rstSet->IsAtLastRow(isAtLastRow);
     EXPECT_EQ(isAtLastRow, true);
-    
+
     EXPECT_EQ(rstSet->GoToNextRow(), E_ROW_OUT_RANGE);
     CheckResultSetAttribute(rstSet, 3, true, false, true);
 
@@ -856,7 +857,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_012, TestSize.Le
     EXPECT_EQ(retF, E_OK);
     rstSet->GetLong(0, valueInt);
     EXPECT_EQ(valueInt, 1.0);
-    std::string  valueStr = "";
+    std::string valueStr = "";
     rstSet->GetString(1, valueStr);
     EXPECT_EQ(valueStr, "hello");
     rstSet->GetLong(2, valueInt);
@@ -932,7 +933,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_014, TestSize.Le
     std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
     std::string path1 = pBk->Name();
 
-    EXPECT_EQ(path,  "/data/test/shared_test.db");
+    EXPECT_EQ(path, "/data/test/shared_test.db");
     EXPECT_EQ(path1, "/data/test/shared_test.db");
 
     rstSet->Close();
@@ -964,7 +965,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_015, TestSize.Le
     auto pBk = pSqlSharedRstSet->GetBlock();
     std::string path1 = pBk->Name();
 
-    EXPECT_EQ(path,  "/data/test/shared_test.db");
+    EXPECT_EQ(path, "/data/test/shared_test.db");
     EXPECT_EQ(path1, "/data/test/shared_test.db");
 
     rstSet->Close();
@@ -999,7 +1000,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_016, TestSize.Le
     std::string path = RdbSqliteSharedResultSetTest::store->GetPath();
     std::string path1 = pBk->Name();
 
-    EXPECT_EQ(path,  "/data/test/shared_test.db");
+    EXPECT_EQ(path, "/data/test/shared_test.db");
     EXPECT_EQ(path1, "/data/test/shared_test.db");
 
     int rowCnt = 0;
@@ -1034,7 +1035,6 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_017, TestSize.Le
     EXPECT_EQ(ret, E_OK);
 }
 
-
 /* *
  * @tc.name: Sqlite_Shared_Result_Set_018
  * @tc.desc:  frequency testcase of SqliteSharedResultSet for getColumnIndexForName
@@ -1044,8 +1044,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_017, TestSize.Le
 HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_018, TestSize.Level1)
 {
     GenerateDefaultTable();
-    std::shared_ptr<ResultSet> resultSet =
-        RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test");
+    std::shared_ptr<ResultSet> resultSet = RdbSqliteSharedResultSetTest::store->QuerySql("SELECT * FROM test");
     EXPECT_NE(resultSet, nullptr);
 
     int columnIndex = 0;
@@ -1152,8 +1151,7 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_021, TestSize.Le
 {
     GenerateDefaultTable();
     std::vector<std::string> selectionArgs;
-    std::shared_ptr<AbsResultSet> resultSet =
-        RdbSqliteSharedResultSetTest::store->QuerySql("SE", selectionArgs);
+    std::shared_ptr<AbsResultSet> resultSet = RdbSqliteSharedResultSetTest::store->QuerySql("SE", selectionArgs);
     EXPECT_NE(resultSet, nullptr);
 
     std::vector<std::string> columnNames;
@@ -1362,13 +1360,13 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_031, TestSize.Le
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToLastRow());
 
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
-    
+
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
 
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
 
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToPreviousRow());
-    
+
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToFirstRow());
 
     EXPECT_EQ(E_ALREADY_CLOSED, resultSet->GoToRow(1));
@@ -1519,8 +1517,8 @@ HWTEST_F(RdbSqliteSharedResultSetTest, Sqlite_Shared_Result_Set_035, TestSize.Le
 {
     GenerateDefaultTable();
     std::vector<std::string> selectionArgs;
-    std::shared_ptr<AbsResultSet> resultSet =RdbSqliteSharedResultSetTest::store->QuerySql(
-        "WITH tem AS ( SELECT * FROM test) SELECT * FROM tem");
+    std::shared_ptr<AbsResultSet> resultSet =
+        RdbSqliteSharedResultSetTest::store->QuerySql("WITH tem AS ( SELECT * FROM test) SELECT * FROM tem");
     EXPECT_NE(resultSet, nullptr);
 
     std::vector<std::string> columnNames;
diff --git a/relational_store/test/native/rdb/unittest/rdb_step_result_get_row_test.cpp b/relational_store/test/native/rdb/unittest/rdb_step_result_get_row_test.cpp
index 555c92af59dbeb9364143fb89b3b377e3db8e163..6b47817ce5ae12f26f20e1412d5a7e888b7a66bb 100644
--- a/relational_store/test/native/rdb/unittest/rdb_step_result_get_row_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_step_result_get_row_test.cpp
@@ -214,7 +214,7 @@ HWTEST_F(RdbStepResultSetGetRowTest, RdbStore_StepResultSet_GetRow_003, TestSize
     int idValueByIndex = rowEntity.Get(0);
     std::string data1ValueByIndex = rowEntity.Get(1);
     int data2ValueByIndex = rowEntity.Get(2);
-    double data3ValueByIndex  = rowEntity.Get(3);
+    double data3ValueByIndex = rowEntity.Get(3);
     std::vector<uint8_t> data4ValueByIndex = rowEntity.Get(4);
     int data5ValueByIndex = rowEntity.Get(5);
     EXPECT_EQ(1, idValueByIndex);
diff --git a/relational_store/test/native/rdb/unittest/rdb_step_result_set_test.cpp b/relational_store/test/native/rdb/unittest/rdb_step_result_set_test.cpp
index 1fb6b3fcf6c5938a3813ddb1d9d4e8791dea059f..d997686a29c51f3ed7cf33631dd03cf6540ef5a0 100644
--- a/relational_store/test/native/rdb/unittest/rdb_step_result_set_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_step_result_set_test.cpp
@@ -18,6 +18,7 @@
 #include <climits>
 #include <string>
 
+#include "abs_predicates.h"
 #include "cache_result_set.h"
 #include "common.h"
 #include "rdb_errno.h"
@@ -106,7 +107,7 @@ void RdbStepResultSetTest::TearDown(void)
 void RdbStepResultSetTest::GenerateDefaultTable()
 {
     std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
-        std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
+                                 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
     store->ExecuteSql(createTableSql);
 
     std::string insertSql = "INSERT INTO test (data1, data2, data3, data4) VALUES (?, ?, ?, ?);";
@@ -135,7 +136,7 @@ void RdbStepResultSetTest::GenerateDefaultTable()
 void RdbStepResultSetTest::GenerateDefaultEmptyTable()
 {
     std::string createTableSql = std::string("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, ") +
-        std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
+                                 std::string("data2 INTEGER, data3 FLOAT, data4 BLOB);");
     store->ExecuteSql(createTableSql);
 }
 
@@ -472,7 +473,6 @@ HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_008, TestSize.Level1)
     std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM test");
     EXPECT_NE(resultSet, nullptr);
 
-
     EXPECT_NE(E_OK, resultSet->GoToFirstRow());
     int position = INT_MIN;
     bool bResultSet = false;
@@ -853,6 +853,26 @@ HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_016, TestSize.Level1)
     EXPECT_EQ(10, longValue);
 }
 
+/* *
+ * @tc.name: RdbStore_StepResultSet_017
+ * @tc.desc: Abnormal testcase of StepResultSet, arguments of GetAsset and GetAssets are invalid
+ * @tc.type: FUNC
+ * @tc.require: AR000FKD4F
+ */
+HWTEST_F(RdbStepResultSetTest, RdbStore_StepResultSet_017, TestSize.Level1)
+{
+    GenerateDefaultTable();
+    std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT data1, data2, data3, data4 FROM test");
+    EXPECT_NE(resultSet, nullptr);
+    EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
+
+    ValueObject::Asset asset;
+    // if columnIndex < 0
+    EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetAsset(-1, asset));
+    ValueObject::Assets assets;
+    EXPECT_EQ(E_COLUMN_OUT_RANGE, resultSet->GetAssets(-1, assets));
+}
+
 /* *
  * @tc.name: testGetRowCount003
  * @tc.desc: normal testcase of StepResultSet for getRowCount
@@ -1457,10 +1477,10 @@ HWTEST_F(RdbStepResultSetTest, testSqlStep018, TestSize.Level1)
     std::vector<std::string> columns;
     std::string logTable = "naturalbase_rdb_aux_test_log";
     std::string sqlstr;
-    std::pair<bool, bool> queryStatus = {false, false};
+    std::pair<bool, bool> queryStatus = { false, false };
 
     // logtable is empty && tableName is not empty
-    queryStatus = {false, true};
+    queryStatus = { false, true };
     sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, "", queryStatus);
     EXPECT_EQ("", sqlstr);
 
@@ -1479,7 +1499,10 @@ HWTEST_F(RdbStepResultSetTest, testSqlStep018, TestSize.Level1)
     sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
     std::string value = "SELECT test.*, naturalbase_rdb_aux_test_log.cursor, CASE "
                         "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
-                        "THEN true ELSE false END AS deleted_flag "
+                        "THEN true ELSE false END AS deleted_flag, CASE "
+                        "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
+                        "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
+                        "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
                         "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
                         "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
     EXPECT_EQ(value, sqlstr);
@@ -1490,7 +1513,10 @@ HWTEST_F(RdbStepResultSetTest, testSqlStep018, TestSize.Level1)
     sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
     value = "SELECT DISTINCT test.name, naturalbase_rdb_aux_test_log.cursor, CASE "
             "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
-            "THEN true ELSE false END AS deleted_flag "
+            "THEN true ELSE false END AS deleted_flag, CASE "
+            "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
+            "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
+            "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
             "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
             "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
     EXPECT_EQ(value, sqlstr);
@@ -1507,10 +1533,10 @@ HWTEST_F(RdbStepResultSetTest, testSqlStep019, TestSize.Level1)
     std::vector<std::string> columns;
     std::string logTable = "naturalbase_rdb_aux_test_log";
     std::string sqlstr;
-    std::pair<bool, bool> queryStatus = {true, false};
+    std::pair<bool, bool> queryStatus = { true, false };
 
     //Distinct is false, columns has spacial field
-    queryStatus = {true, false};
+    queryStatus = { true, false };
     columns.push_back("name");
     columns.push_back("#_sharing_resource_field");
     sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
@@ -1528,12 +1554,15 @@ HWTEST_F(RdbStepResultSetTest, testSqlStep019, TestSize.Level1)
     EXPECT_EQ(value, sqlstr);
 
     //Distinct is true, columns and predicates have spacial fields
-    queryStatus = {true, true};
+    queryStatus = { true, true };
     sqlstr = SqliteSqlBuilder::BuildCursorQueryString(predicates, columns, logTable, queryStatus);
     value = "SELECT DISTINCT test.name, naturalbase_rdb_aux_test_log.sharing_resource AS sharing_resource_field, "
             "naturalbase_rdb_aux_test_log.cursor, CASE "
             "WHEN naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 "
-            "THEN true ELSE false END AS deleted_flag "
+            "THEN true ELSE false END AS deleted_flag, CASE "
+            "WHEN naturalbase_rdb_aux_test_log.flag & 0x808 = 0x808 THEN 3 WHEN "
+            "naturalbase_rdb_aux_test_log.flag & 0x800 = 0x800 THEN 1 WHEN "
+            "naturalbase_rdb_aux_test_log.flag & 0x8 = 0x8 THEN 2 ELSE 0 END AS data_status "
             "FROM test INNER JOIN naturalbase_rdb_aux_test_log "
             "ON test.ROWID = naturalbase_rdb_aux_test_log.data_key";
     EXPECT_EQ(value, sqlstr);
@@ -1897,5 +1926,30 @@ HWTEST_F(RdbStepResultSetTest, Abnormal_CacheResultSet004, TestSize.Level1)
     errCode = resultSet->Get(5, valueobject);
     EXPECT_NE(errCode, E_OK);
 }
+
+/**
+ * @tc.name: Abnormal_CacheResultSet004
+ * @tc.desc: Abnormal testcase of CacheResultSet, if CacheResultSet is Empty
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbStepResultSetTest, Invalid_TableName, TestSize.Level1)
+{
+    auto sql = "create table if not exists 'table_-1' (id INTEGER PRIMARY KEY AUTOINCREMENT)";
+    auto ret = store->ExecuteSql(sql);
+    EXPECT_EQ(E_OK, ret);
+    int64_t rowId = 0;
+    ValuesBucket bucket{};
+    bucket.Put("id", 1);
+    ret = store->Insert(rowId, "'table_-1'", bucket);
+    EXPECT_EQ(E_OK, ret);
+    EXPECT_EQ(rowId, 1);
+    AbsRdbPredicates predicates("table_-1");
+    auto resultSet = store->Query(predicates, {});
+    EXPECT_NE(resultSet, nullptr);
+    auto rowCount = 0;
+    ret = resultSet->GetRowCount(rowCount);
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(rowCount, 1);
+}
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_concurrent_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_concurrent_test.cpp
index c827e87db89da59d6a4dce2edf4ff4404aa792b5..5d66160f7f5fb79b6419d78697b29972c40c06e4 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_concurrent_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_concurrent_test.cpp
@@ -61,11 +61,11 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string ConcurrentTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                                  + std::string("(id INTEGER PRIMARY KEY "
-                                                                                "AUTOINCREMENT, name TEXT NOT NULL, "
-                                                                                "age INTEGER, salary REAL, blobType "
-                                                                                "BLOB)");
+const std::string ConcurrentTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY "
+                                                                  "AUTOINCREMENT, name TEXT NOT NULL, "
+                                                                  "age INTEGER, salary REAL, blobType "
+                                                                  "BLOB)");
 
 int ConcurrentTestOpenCallback::OnCreate(RdbStore &store)
 {
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_config_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_config_test.cpp
index bb30e681e0c92b3c1ffef9e685db168ce0a589df..25a33b2201e16dec82920a95c0abc91ee8ab3799 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_config_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_config_test.cpp
@@ -43,10 +43,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string ConfigTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                              + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                            "name TEXT NOT NULL, age INTEGER, salary "
-                                                                            "REAL, blobType BLOB)");
+const std::string ConfigTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int ConfigTestOpenCallback::OnCreate(RdbStore &store)
 {
@@ -876,7 +876,7 @@ HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_026, TestSize.Level1)
         EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
         resultSets.push_back(resultSet);
     }
-    for (const auto &resultSet: resultSets) {
+    for (const auto &resultSet : resultSets) {
         EXPECT_EQ(E_OK, resultSet->Close());
     }
     store = nullptr;
@@ -939,8 +939,8 @@ HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_029, TestSize.Level1)
     auto invalidConfig = config;
     invalidConfig.SetSecurityLevel(SecurityLevel::S2);
     store = RdbHelper::GetRdbStore(invalidConfig, 1, helper, errCode);
-    EXPECT_EQ(store, nullptr);
-    EXPECT_EQ(errCode, E_CONFIG_INVALID_CHANGE);
+    EXPECT_EQ(errCode, E_OK);
+    EXPECT_NE(store, nullptr);
     store = nullptr;
 
     RdbHelper::DeleteRdbStore(dbPath);
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp
index 9fe31b16578cfb3ee929bea3119c396ea758ff9b..504fe8c8d47c26148c0d71be7a45157d537a444b 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_impl_test.cpp
@@ -13,19 +13,20 @@
  * limitations under the License.
  */
 
+#include "rdb_store_impl.h"
+
 #include <gtest/gtest.h>
 
-#include <string>
 #include <map>
+#include <string>
 
 #include "common.h"
 #include "rdb_errno.h"
 #include "rdb_helper.h"
 #include "rdb_open_callback.h"
-#include "rdb_store_impl.h"
-#include "sqlite_connection.h"
-#include "relational_store_manager.h"
 #include "relational_store_delegate.h"
+#include "relational_store_manager.h"
+#include "sqlite_connection.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -61,9 +62,13 @@ int RdbStoreImplTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int
     return E_OK;
 }
 
-void RdbStoreImplTest::SetUpTestCase(void) {}
+void RdbStoreImplTest::SetUpTestCase(void)
+{
+}
 
-void RdbStoreImplTest::TearDownTestCase(void) {}
+void RdbStoreImplTest::TearDownTestCase(void)
+{
+}
 
 void RdbStoreImplTest::SetUp(void)
 {
@@ -93,14 +98,13 @@ void RdbStoreImplTest::TearDown(void)
 HWTEST_F(RdbStoreImplTest, GetModifyTimeByRowIdTest_001, TestSize.Level2)
 {
     store_->ExecuteSql("CREATE TABLE naturalbase_rdb_aux_rdbstoreimpltest_integer_log "
-        "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
-        "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                       "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
+                       "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     int64_t rowId;
     ValuesBucket valuesBucket;
     valuesBucket.PutInt("data_key", ValueObject(1));
     valuesBucket.PutInt("timestamp", ValueObject(1000000000));
-    int errorCode = store_->Insert(rowId,
-        "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
+    int errorCode = store_->Insert(rowId, "naturalbase_rdb_aux_rdbstoreimpltest_integer_log", valuesBucket);
     EXPECT_EQ(E_OK, errorCode);
     EXPECT_EQ(1, rowId);
 
@@ -198,7 +202,7 @@ HWTEST_F(RdbStoreImplTest, GetModifyTime_001, TestSize.Level2)
                        "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
 
     // table name is ""
-    std::vector<RdbStore::PRIKey> PKey = {1};
+    std::vector<RdbStore::PRIKey> PKey = { 1 };
     std::map<RdbStore::PRIKey, RdbStore::Date> result = store_->GetModifyTime("", "data_key", PKey);
     int size = result.size();
     EXPECT_EQ(0, size);
@@ -233,7 +237,7 @@ HWTEST_F(RdbStoreImplTest, GetModifyTime_002, TestSize.Level2)
                        "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, hash_key INTEGER, "
                        "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
 
-    std::vector<RdbStore::PRIKey> PKey = {1};
+    std::vector<RdbStore::PRIKey> PKey = { 1 };
     std::map<RdbStore::PRIKey, RdbStore::Date> result =
         store_->GetModifyTime("rdbstoreimpltest_integer", "data3", PKey);
     EXPECT_EQ(0, result.size());
@@ -277,8 +281,7 @@ HWTEST_F(RdbStoreImplTest, Rdb_QueryTest_002, TestSize.Level2)
     store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
                        "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     int errCode = E_OK;
-    store_->Query(errCode, true, "test", {},
-        "", std::vector<ValueObject> {}, "", "", "", 1, 0);
+    store_->Query(errCode, true, "test", {}, "", std::vector<ValueObject>{}, "", "", "", 1, 0);
     EXPECT_EQ(E_OK, errCode);
 
     store_->ExecuteSql("DROP TABLE IF EXISTS test");
@@ -406,13 +409,13 @@ HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionTest_001, TestSize.Level2)
 }
 
 /* *
- * @tc.name: Rdb_SqlitConnectionPoolTest_001
+ * @tc.name: Rdb_ConnectionPoolTest_001
  * @tc.desc: Abnormal testCase for ConfigLocale
  * @tc.type: FUNC
  */
-HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_001, TestSize.Level2)
+HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_001, TestSize.Level2)
 {
-    const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionOpenTest.db";
+    const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionOpenTest.db";
     int errCode = E_OK;
     RdbStoreConfig config(DATABASE_NAME);
     config.SetReadConSize(1);
@@ -422,7 +425,7 @@ HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_001, TestSize.Level2)
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
     EXPECT_EQ(E_OK, errCode);
 
-    auto connectionPool = SqliteConnectionPool::Create(config, errCode);
+    auto connectionPool = ConnectionPool::Create(config, errCode);
     EXPECT_NE(nullptr, connectionPool);
     EXPECT_EQ(E_OK, errCode);
 
@@ -437,18 +440,18 @@ HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_001, TestSize.Level2)
 }
 
 /* *
- * @tc.name: Rdb_SqlitConnectionPoolTest_002
+ * @tc.name: Rdb_ConnectionPoolTest_002
  * @tc.desc: Abnormal testCase for AcquireConnection/AcquireTransaction
  * @tc.type: FUNC
  */
-HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_002, TestSize.Level2)
+HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_002, TestSize.Level2)
 {
-    const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionTest.db";
+    const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db";
     int errCode = E_OK;
     RdbStoreConfig config(DATABASE_NAME);
     config.SetReadConSize(1);
     config.SetStorageMode(StorageMode::MODE_DISK);
-    auto connectionPool = SqliteConnectionPool::Create(config, errCode);
+    auto connectionPool = ConnectionPool::Create(config, errCode);
     EXPECT_NE(nullptr, connectionPool);
     EXPECT_EQ(E_OK, errCode);
 
@@ -476,39 +479,38 @@ HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_002, TestSize.Level2)
     connectionPool->ReleaseTransaction();
 }
 
-
 /* *
- * @tc.name: Rdb_SqlitConnectionPoolTest_003
+ * @tc.name: Rdb_ConnectionPoolTest_003
  * @tc.desc: Abnormal testCase for ChangeDbFileForRestore
  * @tc.type: FUNC
  */
-HWTEST_F(RdbStoreImplTest, Rdb_SqlitConnectionPoolTest_0023, TestSize.Level2)
+HWTEST_F(RdbStoreImplTest, Rdb_ConnectionPoolTest_0023, TestSize.Level2)
 {
-    const std::string DATABASE_NAME = RDB_TEST_PATH + "SqlitConnectionTest.db";
+    const std::string DATABASE_NAME = RDB_TEST_PATH + "ConnectionTest.db";
     int errCode = E_OK;
     RdbStoreConfig config(DATABASE_NAME);
     config.SetReadConSize(1);
     config.SetStorageMode(StorageMode::MODE_DISK);
-    auto connectionPool = SqliteConnectionPool::Create(config, errCode);
+    auto connectionPool = ConnectionPool::Create(config, errCode);
     EXPECT_NE(nullptr, connectionPool);
     EXPECT_EQ(E_OK, errCode);
 
-
     const std::string newPath = DATABASE_NAME;
     const std::string backupPath = DATABASE_NAME;
     const std::vector<uint8_t> newKey;
 
     // newPath == currentPath, writeConnectionUsed == true
     auto connection = connectionPool->AcquireConnection(false);
-    errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey);
+    SlaveStatus curStatus;
+    errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus);
     EXPECT_EQ(E_ERROR, errCode);
     connection = nullptr;
     // newPath == currentPath
-    errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey);
+    errCode = connectionPool->ChangeDbFileForRestore(newPath, backupPath, newKey, curStatus);
     EXPECT_NE(E_OK, errCode);
     // newPath != currentPath
     const std::string newPath2 = RDB_TEST_PATH + "tmp.db";
-    errCode = connectionPool->ChangeDbFileForRestore(newPath2, backupPath, newKey);
+    errCode = connectionPool->ChangeDbFileForRestore(newPath2, backupPath, newKey, curStatus);
     EXPECT_EQ(E_ERROR, errCode);
 }
 
@@ -540,13 +542,13 @@ HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_002, TestSize.Level2)
     EXPECT_NE(nullptr, store);
     store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t2;");
     store->ExecuteSql("CREATE TABLE if not exists test_callback_t2 "
-    "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
-    "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                      "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
+                      "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     // set TrackerTable
     DistributedDB::TrackerSchema tracker;
     tracker.tableName = "test_callback_t2";
     tracker.extendColName = "";
-    tracker.trackerColNames = {"id", "timestamp"};
+    tracker.trackerColNames = { "id", "timestamp" };
     using Delegate = DistributedDB::RelationalStoreDelegate;
     DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0);
     Delegate::Option option;
@@ -554,9 +556,8 @@ HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_002, TestSize.Level2)
     EXPECT_EQ(RdbStoreImplTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db");
     int status = rStoreManager.OpenStore(RdbStoreImplTest::DATABASE_NAME, "test_callback_t2", option, g_delegate);
     EXPECT_EQ(E_OK, status);
-    auto delegatePtr = std::shared_ptr<Delegate>(g_delegate, [&rStoreManager](Delegate* delegate) {
-        rStoreManager.CloseStore(delegate);
-    });
+    auto delegatePtr = std::shared_ptr<Delegate>(
+        g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); });
     int setStatus = delegatePtr->SetTrackerTable(tracker);
     EXPECT_EQ(E_OK, setStatus);
 
@@ -586,13 +587,13 @@ HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_003, TestSize.Level2)
     store->ExecuteSql("DROP TABLE IF EXISTS test_callback_t3;");
 
     store->ExecuteSql("CREATE TABLE if not exists test_callback_t3 "
-    "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
-    "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                      "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
+                      "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     // set TrackerTable
     DistributedDB::TrackerSchema tracker;
     tracker.tableName = "test_callback_t3";
     tracker.extendColName = "";
-    tracker.trackerColNames = {"id", "timestamp"};
+    tracker.trackerColNames = { "id", "timestamp" };
     using Delegate = DistributedDB::RelationalStoreDelegate;
     DistributedDB::RelationalStoreManager rStoreManager("test_app", "test_user_id", 0);
     Delegate::Option option;
@@ -600,9 +601,8 @@ HWTEST_F(RdbStoreImplTest, NotifyDataChangeTest_003, TestSize.Level2)
     EXPECT_EQ(RdbStoreImplTest::DATABASE_NAME, "/data/test/stepResultSet_impl_test.db");
     int status = rStoreManager.OpenStore(RdbStoreImplTest::DATABASE_NAME, "test_callback_t3", option, g_delegate);
     EXPECT_EQ(E_OK, status);
-    auto delegatePtr = std::shared_ptr<Delegate>(g_delegate, [&rStoreManager](Delegate* delegate) {
-        rStoreManager.CloseStore(delegate);
-    });
+    auto delegatePtr = std::shared_ptr<Delegate>(
+        g_delegate, [&rStoreManager](Delegate *delegate) { rStoreManager.CloseStore(delegate); });
     int setStatus = delegatePtr->SetTrackerTable(tracker);
     EXPECT_EQ(E_OK, setStatus);
 
@@ -663,8 +663,8 @@ HWTEST_F(RdbStoreImplTest, Rdb_QuerySharingResourceTest_002, TestSize.Level2)
     EXPECT_NE(store, nullptr);
     EXPECT_EQ(errCode, E_OK);
     store->ExecuteSql("CREATE TABLE test_resource "
-    "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
-    "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                      "(id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp INTEGER, data_key INTEGER, "
+                      "data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     int64_t rowId;
     ValuesBucket valuesBucket;
     valuesBucket.PutInt("data_key", ValueObject(1));
@@ -690,7 +690,7 @@ HWTEST_F(RdbStoreImplTest, Rdb_QuerySharingResourceTest_002, TestSize.Level2)
 HWTEST_F(RdbStoreImplTest, Abnormal_CleanDirtyDataTest_001, TestSize.Level2)
 {
     store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
-                      "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                       "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     int errCode = E_OK;
 
     // tabel is empty
@@ -713,7 +713,7 @@ HWTEST_F(RdbStoreImplTest, Abnormal_CleanDirtyDataTest_001, TestSize.Level2)
 HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_001, TestSize.Level2)
 {
     store_->ExecuteSql("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT, data1 TEXT, "
-                      "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
+                       "data2 INTEGER, data3 FLOAT, data4 BLOB, data5 BOOLEAN);");
     int errCode = E_OK;
     int64_t id;
     ValuesBucket valuesBucket;
@@ -731,4 +731,57 @@ HWTEST_F(RdbStoreImplTest, Normal_ClearCacheTest_001, TestSize.Level2)
     int64_t currentMemory = sqlite3_memory_used();
     EXPECT_EQ(E_OK, resultSet->Close());
     EXPECT_LT(sqlite3_memory_used(), currentMemory);
+}
+
+/* *
+ * @tc.name: LockCloudContainerTest
+ * @tc.desc: lock cloudContainer testCase
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbStoreImplTest, LockCloudContainerTest, TestSize.Level2)
+{
+    int errCode = E_OK;
+    // GetRdbService failed if rdbstoreconfig bundlename_ empty
+    auto ret = store_->LockCloudContainer();
+    EXPECT_EQ(E_INVALID_ARGS, ret.first);
+    EXPECT_EQ(0, ret.second);
+    RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
+
+    RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
+    config.SetName("RdbStore_impl_test.db");
+    config.SetBundleName("com.example.distributed.rdb");
+    RdbStoreImplTestOpenCallback helper;
+    std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(E_OK, errCode);
+    // GetRdbService succeeded if configuration file has already been configured
+    ret = store->LockCloudContainer();
+    EXPECT_NE(E_OK, ret.first);
+    store = nullptr;
+    RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
+}
+
+/* *
+ * @tc.name: UnlockCloudContainerTest
+ * @tc.desc: unlock cloudContainer testCase
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbStoreImplTest, UnlockCloudContainerTest, TestSize.Level2)
+{
+    int errCode = E_OK;
+    // GetRdbService failed if rdbstoreconfig bundlename_ empty
+    auto result = store_->UnlockCloudContainer();
+    EXPECT_EQ(E_INVALID_ARGS, result);
+    RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
+
+    RdbStoreConfig config(RdbStoreImplTest::DATABASE_NAME);
+    config.SetName("RdbStore_impl_test.db");
+    config.SetBundleName("com.example.distributed.rdb");
+    RdbStoreImplTestOpenCallback helper;
+    std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    EXPECT_EQ(E_OK, errCode);
+    // GetRdbService succeeded if configuration file has already been configured
+    result = store->UnlockCloudContainer();
+    EXPECT_NE(E_OK, result);
+    store = nullptr;
+    RdbHelper::DeleteRdbStore(RdbStoreImplTest::DATABASE_NAME);
 }
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_interface_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_interface_test.cpp
index 6c27adf03b9134acde3eade8305eac40384e458e..32971bf0ef2105994908a5c25246a4cb5e36bdbe 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_interface_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_interface_test.cpp
@@ -40,10 +40,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string MyOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                      + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, name "
-                                                                    "TEXT, "
-                                                                    "age INTEGER, salary REAL, blobType BLOB)");
+const std::string MyOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, name "
+                                                                  "TEXT, "
+                                                                  "age INTEGER, salary REAL, blobType BLOB)");
 
 int MyOpenCallback::OnCreate(RdbStore &store)
 {
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_rekey_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_rekey_test.cpp
index 11108f3bcc3981ce5125de6f96ca65d29bb1819a..0e736b2a890694810ce9bb6aa0c1879d6b5d381f 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_rekey_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_rekey_test.cpp
@@ -14,8 +14,10 @@
 */
 
 #include <gtest/gtest.h>
+
+#include <fstream>
+#include <iostream>
 #include <string>
-#include <sys/types.h>
 
 #include "common.h"
 #include "file_ex.h"
@@ -37,7 +39,9 @@ public:
     static std::string RemoveSuffix(const std::string &name);
     static std::chrono::system_clock::time_point GetKeyFileDate(const std::string &dbName);
     static bool ChangeKeyFileDate(const std::string &dbName, int rep);
+    static bool SaveNewKey(const std::string &dbName);
     static RdbStoreConfig GetRdbConfig(const std::string &name);
+    static RdbStoreConfig GetRdbNotRekeyConfig(const std::string &name);
     static void InsertData(std::shared_ptr<RdbStore> &store);
     static void CheckQueryData(std::shared_ptr<RdbStore> &store);
 
@@ -47,6 +51,7 @@ public:
     static const std::string encryptedDatabaseMockName;
     static const std::string encryptedDatabaseMockPath;
     static constexpr int HOURS_EXPIRED = (24 * 365) + 1;
+    static constexpr int HOURS_LONG_LONG_AGO = 30 * (24 * 365);
     static constexpr int HOURS_NOT_EXPIRED = (24 * 30);
 };
 
@@ -80,12 +85,18 @@ int RekeyTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVer
     return E_OK;
 }
 
-void RdbRekeyTest::SetUpTestCase() {}
+void RdbRekeyTest::SetUpTestCase()
+{
+}
 
-void RdbRekeyTest::TearDownTestCase() {}
+void RdbRekeyTest::TearDownTestCase()
+{
+}
 
 void RdbRekeyTest::SetUp()
 {
+    RdbHelper::ClearCache();
+    RdbHelper::DeleteRdbStore(RdbRekeyTest::encryptedDatabasePath);
     RdbStoreConfig config = GetRdbConfig(encryptedDatabasePath);
     RekeyTestOpenCallback helper;
     int errCode;
@@ -155,11 +166,39 @@ bool RdbRekeyTest::ChangeKeyFileDate(const std::string &dbName, int rep)
     return saved;
 }
 
+bool RdbRekeyTest::SaveNewKey(const string &dbName)
+{
+    std::string name = RemoveSuffix(dbName);
+    auto keyPath = RDB_TEST_PATH + "key/" + name + ".pub_key";
+    auto newKeyPath = RDB_TEST_PATH + "key/" + name + ".pub_key.new";
+    if (!OHOS::FileExists(keyPath)) {
+        return false;
+    }
+    std::vector<char> content;
+    auto loaded = OHOS::LoadBufferFromFile(keyPath, content);
+    if (!loaded) {
+        return false;
+    }
+    OHOS::SaveBufferToFile(newKeyPath, content);
+    content[content.size() - 1] = 'E';
+    return OHOS::SaveBufferToFile(keyPath, content);
+}
+
 RdbStoreConfig RdbRekeyTest::GetRdbConfig(const std::string &name)
 {
     RdbStoreConfig config(name);
     config.SetEncryptStatus(true);
     config.SetBundleName("com.example.test_rekey");
+    config.EnableRekey(true);
+    return config;
+}
+
+RdbStoreConfig RdbRekeyTest::GetRdbNotRekeyConfig(const std::string &name)
+{
+    RdbStoreConfig config(name);
+    config.SetEncryptStatus(true);
+    config.SetBundleName("com.example.test_rekey");
+    config.EnableRekey(false);
     return config;
 }
 
@@ -223,9 +262,10 @@ HWTEST_F(RdbRekeyTest, Rdb_Rekey_01, TestSize.Level1)
 
     RdbStoreConfig config = GetRdbConfig(RdbRekeyTest::encryptedDatabasePath);
     RekeyTestOpenCallback helper;
-    int errCode;
+    int errCode = E_OK;
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
     ASSERT_NE(store, nullptr);
+    ASSERT_EQ(errCode, E_OK);
 
     isFileExists = OHOS::FileExists(keyPath);
     ASSERT_TRUE(isFileExists);
@@ -256,9 +296,10 @@ HWTEST_F(RdbRekeyTest, Rdb_Rekey_02, TestSize.Level1)
 
     RdbStoreConfig config = GetRdbConfig(RdbRekeyTest::encryptedDatabasePath);
     RekeyTestOpenCallback helper;
-    int errCode;
+    int errCode = E_OK;
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
     ASSERT_NE(store, nullptr);
+    ASSERT_EQ(errCode, E_OK);
     CheckQueryData(store);
 }
 
@@ -282,10 +323,15 @@ HWTEST_F(RdbRekeyTest, Rdb_Rekey_03, TestSize.Level1)
     ASSERT_FALSE(isFileExists);
 
     RekeyTestOpenCallback helper;
-    int errCode;
+    int errCode = E_OK;
     RdbStoreConfig config = GetRdbConfig(encryptedDatabasePath);
     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
-    ASSERT_EQ(store, nullptr);
+    ASSERT_NE(store, nullptr);
+    ASSERT_EQ(errCode, E_OK);
+    store = nullptr;
+    store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    ASSERT_NE(store, nullptr);
+    ASSERT_EQ(errCode, E_OK);
 }
 
 /**
@@ -323,5 +369,76 @@ HWTEST_F(RdbRekeyTest, Rdb_Rekey_04, TestSize.Level1)
     keyFileDate = GetKeyFileDate(encryptedDatabaseName);
     ASSERT_EQ(changedDate, keyFileDate);
 
+    CheckQueryData(store);
+}
+
+/**
+* @tc.name: Rdb_Rekey_RenameFailed_05
+* @tc.desc: re key and rename failed the new key file.
+* @tc.type: FUNC
+*/
+HWTEST_F(RdbRekeyTest, Rdb_Rekey_RenameFailed_05, TestSize.Level1)
+{
+    std::string keyPath = encryptedDatabaseKeyDir + RemoveSuffix(encryptedDatabaseName) + ".pub_key";
+    std::string newKeyPath = encryptedDatabaseKeyDir + RemoveSuffix(encryptedDatabaseName) + ".pub_key.new";
+
+    bool isFileExists = OHOS::FileExists(keyPath);
+    ASSERT_TRUE(isFileExists);
+
+    auto keyFileDate = GetKeyFileDate(encryptedDatabaseName);
+
+    bool isFileDateChanged = ChangeKeyFileDate(encryptedDatabaseName, RdbRekeyTest::HOURS_LONG_LONG_AGO);
+    ASSERT_TRUE(isFileDateChanged);
+
+    auto changedDate = GetKeyFileDate(encryptedDatabaseName);
+    ASSERT_GT(keyFileDate, changedDate);
+
+    RdbStoreConfig config = GetRdbConfig(RdbRekeyTest::encryptedDatabasePath);
+    RekeyTestOpenCallback helper;
+    int errCode = E_OK;
+    for (int i = 0; i < 50; ++i) {
+        auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+        ASSERT_NE(store, nullptr);
+        ASSERT_EQ(errCode, E_OK);
+        store = nullptr;
+        SaveNewKey(encryptedDatabaseName);
+    }
+
+    auto store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    CheckQueryData(store);
+}
+
+/**
+* @tc.name: Rdb_Delete_Rekey_Test_06
+* @tc.desc: test RdbStore rekey function
+* @tc.type: FUNC
+*/
+HWTEST_F(RdbRekeyTest, Rdb_Rekey_06, TestSize.Level1)
+{
+    std::string keyPath = encryptedDatabaseKeyDir + RemoveSuffix(encryptedDatabaseName) + ".pub_key";
+    std::string newKeyPath = encryptedDatabaseKeyDir + RemoveSuffix(encryptedDatabaseName) + ".pub_key.new";
+
+    bool isFileExists = OHOS::FileExists(keyPath);
+    ASSERT_TRUE(isFileExists);
+
+    bool isFileDateChanged = ChangeKeyFileDate(encryptedDatabaseName, RdbRekeyTest::HOURS_EXPIRED);
+    ASSERT_TRUE(isFileDateChanged);
+
+    auto changedDate = GetKeyFileDate(encryptedDatabaseName);
+    ASSERT_TRUE(std::chrono::system_clock::now() - changedDate > std::chrono::hours(RdbRekeyTest::HOURS_EXPIRED));
+
+    RdbStoreConfig config = GetRdbNotRekeyConfig(RdbRekeyTest::encryptedDatabasePath);
+    RekeyTestOpenCallback helper;
+    int errCode = E_OK;
+    std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
+    ASSERT_NE(store, nullptr);
+    ASSERT_EQ(errCode, E_OK);
+
+    isFileExists = OHOS::FileExists(keyPath);
+    ASSERT_TRUE(isFileExists);
+    isFileExists = OHOS::FileExists(newKeyPath);
+    ASSERT_FALSE(isFileExists);
+
+    ASSERT_TRUE(std::chrono::system_clock::now() - changedDate > std::chrono::hours(RdbRekeyTest::HOURS_EXPIRED));
     CheckQueryData(store);
 }
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_store_subscribe_test.cpp b/relational_store/test/native/rdb/unittest/rdb_store_subscribe_test.cpp
index b111d387cc96d100b00f602eb0bbd9689fbf2431..ffcbe105a018e6addd536cf7d96a68da20c98021 100644
--- a/relational_store/test/native/rdb/unittest/rdb_store_subscribe_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_store_subscribe_test.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include <gtest/gtest.h>
+
 #include <functional>
 #include <string>
 
@@ -20,9 +21,9 @@
 #include "rdb_errno.h"
 #include "rdb_helper.h"
 #include "rdb_open_callback.h"
+#include "rdb_sql_statistic.h"
 #include "rdb_store_manager.h"
 #include "rdb_types.h"
-#include "rdb_sql_statistic.h"
 
 using namespace testing::ext;
 using namespace OHOS::NativeRdb;
@@ -31,22 +32,28 @@ using CheckOnChangeFunc = std::function<void(RdbStoreObserver::ChangeInfo &chang
 using SqlStatisticsFunc = std::function<void(SqlObserver::SqlExecutionInfo &info)>;
 class SubObserver : public RdbStoreObserver {
 public:
-    virtual ~SubObserver() {}
-    void OnChange(const std::vector<std::string>& devices) override;
-    void OnChange(const Origin &origin, const PrimaryFields &fields,
-        RdbStoreObserver::ChangeInfo &&changeInfo) override;
+    virtual ~SubObserver()
+    {
+    }
+    void OnChange(const std::vector<std::string> &devices) override;
+    void OnChange(
+        const Origin &origin, const PrimaryFields &fields, RdbStoreObserver::ChangeInfo &&changeInfo) override;
     void OnChange() override;
     void RegisterCallback(const CheckOnChangeFunc &callback);
     uint32_t count = 0;
+
 private:
     CheckOnChangeFunc checkOnChangeFunc_;
 };
 
 class StatisticsObserver : public SqlObserver {
 public:
-    virtual ~StatisticsObserver() {}
+    virtual ~StatisticsObserver()
+    {
+    }
     void OnStatistic(const SqlExecutionInfo &info);
     void Callback(const SqlStatisticsFunc &callback);
+
 private:
     SqlStatisticsFunc sqlStatisticsFunc_;
 };
@@ -69,8 +76,10 @@ public:
 
 class TestDetailProgressObserver : public DetailProgressObserver {
 public:
-    virtual ~TestDetailProgressObserver() {}
-    void ProgressNotification(const Details& details) override {};
+    virtual ~TestDetailProgressObserver()
+    {
+    }
+    void ProgressNotification(const Details &details) override{};
 };
 
 const std::string RdbStoreSubTest::MAIN_DATABASE_NAME = RDB_TEST_PATH + "subscribe.db";
@@ -284,8 +293,8 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail001, TestSize.Level1)
     EXPECT_NE(store, nullptr) << "store is null";
     EXPECT_NE(observer_, nullptr) << "observer is null";
     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test "
-                                          "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER)";
+                                            "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                            "name TEXT NOT NULL, age INTEGER)";
     store->ExecuteSql(createTableTest);
     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
     EXPECT_EQ(status, E_OK);
@@ -304,12 +313,8 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail001, TestSize.Level1)
     EXPECT_EQ(status, E_OK);
     EXPECT_EQ(id, 1);
 
-    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) {
-        ASSERT_TRUE(false);
-    });
-    observer2->RegisterCallback([](RdbStoreObserver::ChangeInfo &) {
-        ASSERT_TRUE(false);
-    });
+    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
+    observer2->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
     EXPECT_EQ(status, E_OK);
     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
@@ -357,9 +362,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail002, TestSize.Level1)
     EXPECT_EQ(status, E_OK);
     EXPECT_EQ(id, 1);
 
-    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) {
-        ASSERT_TRUE(false);
-    });
+    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
     EXPECT_EQ(status, E_OK);
 
@@ -469,8 +472,8 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail005, TestSize.Level1)
     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
     EXPECT_EQ(status, E_OK);
     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test1 "
-                                          "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER)";
+                                            "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                            "name TEXT NOT NULL, age INTEGER)";
     store->ExecuteSql(createTableTest);
 
     observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
@@ -514,9 +517,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail006, TestSize.Level1)
     EXPECT_NE(observer_, nullptr) << "observer is null";
     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, nullptr);
     EXPECT_EQ(status, E_OK);
-    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) {
-        ASSERT_TRUE(false);
-    });
+    observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
     ValuesBucket values;
     int id;
     values.PutString("name", std::string("zhangsan_update1"));
@@ -541,8 +542,8 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics001, TestSize.Level1)
     EXPECT_NE(store, nullptr) << "store is null";
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test "
-                                          "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER)";
+                                            "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                            "name TEXT NOT NULL, age INTEGER)";
     store->ExecuteSql(createTableTest);
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
@@ -556,12 +557,8 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics001, TestSize.Level1)
     status = store->Insert(id, "statistics_test", values);
     EXPECT_EQ(status, E_OK);
     EXPECT_EQ(id, 1);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 1);
-    });
-    observer2->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 1);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
+    observer2->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
     status = SqlStatistic::Unsubscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
     status = SqlStatistic::Unsubscribe(observer2);
@@ -590,9 +587,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics002, TestSize.Level1)
     status = store->Update(id, values, predicates);
     EXPECT_EQ(status, E_OK);
     EXPECT_EQ(id, 1);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 1);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
     status = SqlStatistic::Unsubscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
 }
@@ -610,9 +605,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics003, TestSize.Level1)
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 1);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
     int id;
     status = store->Delete(id, "statistics_test", "id = ?", std::vector<std::string>{ "1" });
     EXPECT_EQ(status, E_OK);
@@ -637,9 +630,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics004, TestSize.Level1)
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 1);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
     int64_t id;
     std::vector<ValuesBucket> values;
     for (int i = 0; i < num; i++) {
@@ -670,13 +661,11 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics005, TestSize.Level1)
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test1 "
-                                          "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                          "name TEXT NOT NULL, age INTEGER)";
+                                            "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                            "name TEXT NOT NULL, age INTEGER)";
     store->ExecuteSql(createTableTest);
 
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 3);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 3); });
     ValuesBucket values;
     int64_t id;
     values.PutInt("id", 1);
@@ -702,9 +691,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics006, TestSize.Level1)
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 2);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
     std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM statistics_test");
     EXPECT_NE(resultSet, nullptr);
     status = SqlStatistic::Unsubscribe(sqlObserver_);
@@ -724,9 +711,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics007, TestSize.Level1)
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_.size(), 2);
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM statistics_test");
     EXPECT_NE(resultSet, nullptr);
     status = SqlStatistic::Unsubscribe(sqlObserver_);
@@ -746,9 +731,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics008, TestSize.Level1)
     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_[0], "PRAGMA quick_check");
-    });
+    sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], "PRAGMA quick_check"); });
     auto [ret, object] = store->Execute("PRAGMA quick_check");
     status = SqlStatistic::Unsubscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
@@ -768,9 +751,7 @@ HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics009, TestSize.Level1)
     std::string value = "with test as (select * from statistics_test) select * from test1";
     auto status = SqlStatistic::Subscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
-    sqlObserver_->Callback([value](SqlObserver::SqlExecutionInfo &info) {
-        ASSERT_EQ(info.sql_[0], value);
-    });
+    sqlObserver_->Callback([value](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], value); });
     store->ExecuteSql(value);
     status = SqlStatistic::Unsubscribe(sqlObserver_);
     EXPECT_EQ(status, E_OK);
diff --git a/relational_store/test/native/rdb/unittest/rdb_transaction_test.cpp b/relational_store/test/native/rdb/unittest/rdb_transaction_test.cpp
index ba32b0925a938af910dfb5bbcdc8baa13ec72c3e..e6bf82172f3704694d199f7414f4708c63327a33 100644
--- a/relational_store/test/native/rdb/unittest/rdb_transaction_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_transaction_test.cpp
@@ -47,11 +47,11 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string TransactionTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                                   + std::string("(id INTEGER PRIMARY KEY "
-                                                                                 "AUTOINCREMENT, name TEXT NOT NULL, "
-                                                                                 "age INTEGER, salary REAL, blobType "
-                                                                                 "BLOB)");
+const std::string TransactionTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY "
+                                                                  "AUTOINCREMENT, name TEXT NOT NULL, "
+                                                                  "age INTEGER, salary REAL, blobType "
+                                                                  "BLOB)");
 
 int TransactionTestOpenCallback::OnCreate(RdbStore &store)
 {
@@ -89,7 +89,6 @@ void RdbTransactionTest::TearDown(void)
 {
 }
 
-
 /**
  * @tc.name: RdbStore_Transaction_001
  * @tc.desc: test RdbStore BaseTransaction
@@ -219,7 +218,6 @@ HWTEST_F(RdbTransactionTest, RdbStore_Transaction_003, TestSize.Level1)
     EXPECT_EQ(deletedRows, 0);
 }
 
-
 /**
  * @tc.name: RdbStore_NestedTransaction_001
  * @tc.desc: test RdbStore BaseTransaction
@@ -456,7 +454,6 @@ HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_001, TestSize.Level1)
     EXPECT_EQ(100, rowCount);
 }
 
-
 /**
  * @tc.name: RdbStore_BatchInsert_002
  * @tc.desc: test RdbStore BatchInsert
@@ -491,7 +488,6 @@ HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_002, TestSize.Level1)
     EXPECT_EQ(100, rowCount);
 }
 
-
 /**
  * @tc.name: RdbStore_BatchInsert_003
  * @tc.desc: test RdbStore BatchInsert
@@ -510,7 +506,7 @@ HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_003, TestSize.Level1)
     std::vector<uint8_t> blob = { 1, 2, 3 };
     std::vector<ValuesBucket> valuesBuckets;
     for (int i = 0; i < 100; i++) {
-        RowData rowData1 = {id + i, name, age + i, salary + i, blob};
+        RowData rowData1 = { id + i, name, age + i, salary + i, blob };
         ValuesBucket values = UTUtils::SetRowData(rowData1);
         valuesBuckets.push_back(std::move(values));
     }
@@ -527,7 +523,7 @@ HWTEST_F(RdbTransactionTest, RdbStore_BatchInsert_003, TestSize.Level1)
 
     valuesBuckets.clear();
     for (int i = 50; i < 100; i++) {
-        RowData rowData2 = {id + i, name, age + i, salary + i, blob};
+        RowData rowData2 = { id + i, name, age + i, salary + i, blob };
         ValuesBucket values = UTUtils::SetRowData(rowData2);
         valuesBuckets.push_back(std::move(values));
     }
diff --git a/relational_store/test/native/rdb/unittest/rdb_update_test.cpp b/relational_store/test/native/rdb/unittest/rdb_update_test.cpp
index 1fbf8f0f1a41e3cc750e425454939e33aa0965fb..6619c44d8be889541d9ca93c80b2199002b03c3e 100644
--- a/relational_store/test/native/rdb/unittest/rdb_update_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_update_test.cpp
@@ -31,8 +31,7 @@ class RdbStoreUpdateTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
-    static void ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet,
-        const RowData &expect);
+    static void ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect);
     void SetUp();
     void TearDown();
 
@@ -50,10 +49,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string UpdateTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                              + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                            "name TEXT UNIQUE, age INTEGER, salary "
-                                                                            "REAL, blobType BLOB)");
+const std::string UpdateTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT UNIQUE, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int UpdateTestOpenCallback::OnCreate(RdbStore &store)
 {
@@ -114,8 +113,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
     values.PutInt("age", 20);
     values.PutDouble("salary", 200.5);
     values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
-    ret = store->Update(changedRows, "test", values, "id = ?",
-                std::vector<std::string>{ "1" });
+    ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, changedRows);
 
@@ -124,7 +122,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_001, TestSize.Level1)
 
     ret = resultSet->GoToFirstRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -166,11 +164,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_002, TestSize.Level1)
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -243,8 +241,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_005, TestSize.Level1)
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, id);
 
-    ret = store->Update(changedRows, "test", values, "id = ?",
-        std::vector<std::string>{ "1" });
+    ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
     EXPECT_EQ(ret, E_EMPTY_VALUES_BUCKET);
 }
 
@@ -271,8 +268,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_006, TestSize.Level1)
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, id);
 
-    ret = store->Update(changedRows, "test", values, "id = ?",
-        std::vector<std::string>{ "1" });
+    ret = store->Update(changedRows, "test", values, "id = ?", std::vector<std::string>{ "1" });
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, changedRows);
 
@@ -281,7 +277,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_Update_006, TestSize.Level1)
 
     ret = resultSet->GoToFirstRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 20, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -326,11 +322,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_001, TestSize
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -366,8 +362,8 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize
     values.PutInt("age", 20);
     values.PutDouble("salary", 300.5);
     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
-    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
-        std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_NONE);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
+        ConflictResolution::ON_CONFLICT_NONE);
     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
 
     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
@@ -375,11 +371,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_002, TestSize
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -415,8 +411,8 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize
     values.PutInt("age", 20);
     values.PutDouble("salary", 300.5);
     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
-    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
-        std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_ROLLBACK);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
+        ConflictResolution::ON_CONFLICT_ROLLBACK);
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, changedRows);
 
@@ -425,11 +421,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_003, TestSize
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -465,8 +461,8 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize
     values.PutInt("age", 20);
     values.PutDouble("salary", 300.5);
     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
-    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
-        std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_ROLLBACK);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
+        ConflictResolution::ON_CONFLICT_ROLLBACK);
     EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
 
     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
@@ -474,11 +470,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_004, TestSize
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "lisi", 19, 200.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -514,8 +510,8 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize
     values.PutInt("age", 20);
     values.PutDouble("salary", 300.5);
     values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
-    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
-        std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_REPLACE);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
+        ConflictResolution::ON_CONFLICT_REPLACE);
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(1, changedRows);
 
@@ -524,11 +520,11 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_005, TestSize
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 1, "zhangsan", 18, 100.5, std::vector<uint8_t>{ 1, 2, 3 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 3, "wangjing", 20, 300.5, std::vector<uint8_t>{ 7, 8, 9 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -562,8 +558,8 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize
     values.PutString("name", std::string("zhangsan"));
     values.PutInt("age", 20);
     values.PutDouble("salary", 300.5);
-    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?",
-        std::vector<std::string>{ "19" }, ConflictResolution::ON_CONFLICT_REPLACE);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "19" },
+        ConflictResolution::ON_CONFLICT_REPLACE);
     EXPECT_EQ(ret, E_OK);
     EXPECT_EQ(changedRows, 1);
 
@@ -573,7 +569,7 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_OK);
 
-    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 }});
+    RdbStoreUpdateTest::ExpectValue(resultSet, RowData{ 2, "zhangsan", 20, 300.5, std::vector<uint8_t>{ 4, 5, 6 } });
 
     ret = resultSet->GoToNextRow();
     EXPECT_EQ(ret, E_ROW_OUT_RANGE);
@@ -582,6 +578,39 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_006, TestSize
     EXPECT_EQ(ret, E_OK);
 }
 
+/**
+ * @tc.name: RdbStore_UpdateWithConflictResolution_007
+ * @tc.desc: test RdbStore UpdateWithConflictResolution
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateWithConflictResolution_007, TestSize.Level1)
+{
+    std::shared_ptr<RdbStore> &store = RdbStoreUpdateTest::store;
+
+    int changedRows;
+    int64_t id;
+    ValuesBucket values;
+
+    int ret = store->Insert(id, "test", UTUtils::SetRowData(UTUtils::g_rowData[0]));
+    EXPECT_EQ(ret, E_OK);
+    EXPECT_EQ(1, id);
+
+    values.PutInt("id", 2);
+    values.PutInt("age", 19);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" },
+        static_cast<ConflictResolution>(6));
+    EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
+    EXPECT_EQ(0, changedRows);
+
+    values.Clear();
+    values.PutInt("id", 2);
+    values.PutInt("age", 19);
+    ret = store->UpdateWithConflictResolution(changedRows, "test", values, "age = ?", std::vector<std::string>{ "18" },
+        static_cast<ConflictResolution>(-1));
+    EXPECT_EQ(E_INVALID_CONFLICT_FLAG, ret);
+    EXPECT_EQ(0, changedRows);
+}
+
 /**
  * @tc.name: RdbStore_UpdateSqlBuilder_001
  * @tc.desc: test RdbStore UpdateSqlBuilder
@@ -595,17 +624,17 @@ HWTEST_F(RdbStoreUpdateTest, RdbStore_UpdateSqlBuilder_001, TestSize.Level1)
     values.PutDouble("salary", 300.5);
 
     std::vector<ValueObject> bindArgs;
-    std::string updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{ "19" },
-        "", "age = ?", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
+    std::string updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{ "19" }, "",
+        "age = ?", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
     EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=? WHERE age = ?");
 
-    updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{},
-        "", "", "", "", INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
+    updateSql = SqliteSqlBuilder::BuildUpdateString(values, "test", std::vector<std::string>{}, "", "", "", "",
+        INT_MIN, INT_MIN, bindArgs, ConflictResolution::ON_CONFLICT_NONE);
     EXPECT_EQ(updateSql, "UPDATE test SET age=?,name=?,salary=?");
 }
 
-void RdbStoreUpdateTest::ExpectValue(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet,
-    const RowData &expect)
+void RdbStoreUpdateTest::ExpectValue(
+    const std::shared_ptr<OHOS::NativeRdb::ResultSet> &resultSet, const RowData &expect)
 {
     EXPECT_NE(nullptr, resultSet);
     int columnIndex;
diff --git a/relational_store/test/native/rdb/unittest/rdb_upgrade_test.cpp b/relational_store/test/native/rdb/unittest/rdb_upgrade_test.cpp
index a8650940e219cd6bdea791d3bd8cef9e46c998d2..433566302ed3dbc7a48c1657776afb0ef3aac178 100644
--- a/relational_store/test/native/rdb/unittest/rdb_upgrade_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_upgrade_test.cpp
@@ -47,10 +47,10 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-std::string const UpgradeTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
-                                                               + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
-                                                                             "name TEXT NOT NULL, age INTEGER, salary "
-                                                                             "REAL, blobType BLOB)");
+std::string const UpgradeTestOpenCallback::CREATE_TABLE_TEST =
+    std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                                                                  "name TEXT NOT NULL, age INTEGER, salary "
+                                                                  "REAL, blobType BLOB)");
 
 int UpgradeTestOpenCallback::OnCreate(RdbStore &store)
 {
diff --git a/relational_store/test/native/rdb/unittest/rdb_utils_test.cpp b/relational_store/test/native/rdb/unittest/rdb_utils_test.cpp
index 88a5b4123fbcb278fc1c2fc152581657bde76f8e..36334aba05749a77ab409491b30e9e28faf44b7f 100644
--- a/relational_store/test/native/rdb/unittest/rdb_utils_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_utils_test.cpp
@@ -28,8 +28,8 @@ class RdbUtilsTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
-    void SetUp(void) {};
-    void TearDown(void) {};
+    void SetUp(void){};
+    void TearDown(void){};
 };
 
 void RdbUtilsTest::SetUpTestCase(void)
@@ -111,4 +111,49 @@ HWTEST_F(RdbUtilsTest, RdbStore_SqliteUtils_006, TestSize.Level1)
 HWTEST_F(RdbUtilsTest, RdbStore_SqliteUtils_007, TestSize.Level1)
 {
     EXPECT_EQ(0, SqliteUtils::GetFileSize("act.txt"));
+}
+
+/**
+ * @tc.name: GetSqlStatementType_001
+ * @tc.desc: Normal testCase of GetSqlStatementType
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbUtilsTest, GetSqlStatementType_001, TestSize.Level1)
+{
+    EXPECT_EQ(SqliteUtils::STATEMENT_SELECT, SqliteUtils::GetSqlStatementType("select * from text"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_UPDATE, SqliteUtils::GetSqlStatementType("update test set id = ?"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_UPDATE, SqliteUtils::GetSqlStatementType("delete from test where id = ?"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_UPDATE, SqliteUtils::GetSqlStatementType("Replace INTO test"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_ATTACH, SqliteUtils::GetSqlStatementType("attach database ? as ?"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_DETACH, SqliteUtils::GetSqlStatementType("detach database ?"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_BEGIN, SqliteUtils::GetSqlStatementType("BEGIN TRANSACTION"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_BEGIN, SqliteUtils::GetSqlStatementType("SAVEPOINT 1"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_COMMIT, SqliteUtils::GetSqlStatementType("END TRANSACTION"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_COMMIT, SqliteUtils::GetSqlStatementType("COMMIT"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_ROLLBACK, SqliteUtils::GetSqlStatementType("ROLLBACK"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_PRAGMA, SqliteUtils::GetSqlStatementType("PRAGMA user_version"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_DDL, SqliteUtils::GetSqlStatementType("CREATE TABLE"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_DDL, SqliteUtils::GetSqlStatementType("CREATE TRIGGER"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_DDL, SqliteUtils::GetSqlStatementType("DROP TABLE"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_DDL, SqliteUtils::GetSqlStatementType("ALTER TABLE"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_INSERT, SqliteUtils::GetSqlStatementType("INSERT INTO test"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_OTHER, SqliteUtils::GetSqlStatementType("EXPLAIN SELECT * FROM test"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_OTHER, SqliteUtils::GetSqlStatementType("SAZZZZZZZ"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_OTHER, SqliteUtils::GetSqlStatementType("SAAAAAAAA"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_OTHER, SqliteUtils::GetSqlStatementType("PROCESS"));
+}
+
+/**
+ * @tc.name: GetSqlStatementType_002
+ * @tc.desc: Normal testCase of GetSqlStatementType
+ *           1.Spaces before the sql
+ *           2.Enter before the sql
+ *           3.Non-alphanumeric and non-numeric before the sql
+ * @tc.type: FUNC
+ */
+HWTEST_F(RdbUtilsTest, GetSqlStatementType_002, TestSize.Level1)
+{
+    EXPECT_EQ(SqliteUtils::STATEMENT_SELECT, SqliteUtils::GetSqlStatementType("   select * from text"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_UPDATE, SqliteUtils::GetSqlStatementType("\r\nupdate test set id = ?"));
+    EXPECT_EQ(SqliteUtils::STATEMENT_OTHER, SqliteUtils::GetSqlStatementType("~!@# attach database ? as ?"));
 }
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/rdb_value_bucket_test.cpp b/relational_store/test/native/rdb/unittest/rdb_value_bucket_test.cpp
index 4ef8fc6b98852c9d7b18dde99ee29f45f45ef5ff..421f362bd2b4b7b66bb15a0d632b475ec68f8dcc 100644
--- a/relational_store/test/native/rdb/unittest/rdb_value_bucket_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_value_bucket_test.cpp
@@ -21,10 +21,10 @@
 #include "message_parcel.h"
 #include "parcel.h"
 #include "raw_data_parser.h"
+#include "rdb_errno.h"
 #include "sqlite_global_config.h"
 #include "value_object.h"
 #include "values_bucket.h"
-#include "rdb_errno.h"
 
 using namespace testing::ext;
 using namespace OHOS;
@@ -364,8 +364,8 @@ HWTEST_F(ValuesBucketTest, Convert_To_Subset, TestSize.Level1)
     auto *blob = std::get_if<std::vector<uint8_t>>(&output);
     EXPECT_TRUE(blob != nullptr);
     EXPECT_TRUE(*blob == std::vector<uint8_t>(10, 'm'));
-    AssetValue value{.version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12"};
-    input = value ;
+    AssetValue value{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" };
+    input = value;
     output = {};
     RawDataParser::Convert(input, output);
     nil = std::get_if<std::monostate>(&output);
@@ -390,7 +390,7 @@ HWTEST_F(ValuesBucketTest, Explicit_Conversion, TestSize.Level1)
     auto transformedBlob = ValueObject::Blob(valueObject);
     ASSERT_EQ(transformedBlob.size(), 10);
 
-    AssetValue asset{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12"};
+    AssetValue asset{ .version = 0, .name = "123", .uri = "my test path", .createTime = "12", .modifyTime = "12" };
     valueObject = ValueObject(asset);
     auto transformedAsset = ValueObject::Asset(valueObject);
     ASSERT_EQ(transformedAsset.version, asset.version);
diff --git a/relational_store/test/native/rdb/unittest/rdb_wal_limit_test.cpp b/relational_store/test/native/rdb/unittest/rdb_wal_limit_test.cpp
index 3905c95c49d2df4a4a91dcadbb2ecfda989eae42..75ebd95e3c268843741ddf8323c6f1c72e610203 100644
--- a/relational_store/test/native/rdb/unittest/rdb_wal_limit_test.cpp
+++ b/relational_store/test/native/rdb/unittest/rdb_wal_limit_test.cpp
@@ -60,7 +60,8 @@ public:
     static const std::string CREATE_TABLE_TEST;
 };
 
-const std::string RdbWalLimitCallback::CREATE_TABLE_TEST("CREATE TABLE IF NOT EXISTS test "
+const std::string RdbWalLimitCallback::CREATE_TABLE_TEST(
+    "CREATE TABLE IF NOT EXISTS test "
     "(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, age INTEGER, salary REAL, blobType BLOB)");
 
 int RdbWalLimitCallback::OnCreate(RdbStore &store)
@@ -258,5 +259,23 @@ HWTEST_F(RdbWalLimitTest, RdbStore_WalOverLimit_003, TestSize.Level3)
     store->BeginTransaction();
     MakeWalReachLimit();
     EXPECT_EQ(store->Insert(id, "test", values), E_WAL_SIZE_OVER_LIMIT);
-    store->Commit();
+    int errCode = store->Commit();
+    EXPECT_EQ(errCode, E_OK);
+}
+
+/**
+ * @tc.name: RdbStore_WalOverLimit_003
+ * @tc.desc: During transactions, the size of the wal file may exceed the limit.
+ * @tc.type: FUNC
+ * @tc.acquire: AR000HR0G5
+ */
+HWTEST_F(RdbWalLimitTest, RdbStore_WalOverLimit_004, TestSize.Level3)
+{
+    ValuesBucket values = MakeValueBucket(200);
+    int64_t id;
+    store->BeginTransaction();
+    MakeWalReachLimit();
+    EXPECT_EQ(store->Insert(id, "test", values), E_WAL_SIZE_OVER_LIMIT);
+    int errCode = store->RollBack();
+    EXPECT_EQ(errCode, E_OK);
 }
\ No newline at end of file
diff --git a/relational_store/test/native/rdb/unittest/value_object_test.cpp b/relational_store/test/native/rdb/unittest/value_object_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc007879ae5e6d2902edebe2044acfe915c3848e
--- /dev/null
+++ b/relational_store/test/native/rdb/unittest/value_object_test.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "value_object.h"
+
+#include <gtest/gtest.h>
+
+#include <climits>
+#include <string>
+
+#include "big_integer.h"
+#include "grd_type_export.h"
+
+using namespace testing::ext;
+using namespace OHOS::NativeRdb;
+
+namespace Test {
+class ValueObjectTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp(void){};
+    void TearDown(void){};
+};
+
+void ValueObjectTest::SetUpTestCase(void)
+{
+}
+
+void ValueObjectTest::TearDownTestCase(void)
+{
+}
+
+/**
+ * @tc.name: ValueObject_Test_001
+ * @tc.desc: test func third line
+ValueObject &ValueObject::operator=(ValueObject &&val) noexcept
+{
+    if (this == &val) {
+        return *this;
+    }
+    value = std::move(val.value);
+    return *this;
+}
+ * @tc.type: FUNC
+ */
+HWTEST_F(ValueObjectTest, ValueObject_Test_001, TestSize.Level1)
+{
+    int32_t intValue = 1234;
+    ValueObject obj(intValue);
+    ValueObject &ref = obj;
+    ref = std::move(obj);
+    int outValue;
+    ref.GetInt(outValue);
+    EXPECT_EQ(outValue, intValue);
+}
+
+/**
+ * @tc.name: ValueObject_Test_001
+ * @tc.desc: test func third line
+ValueObject &ValueObject::operator=(const ValueObject &val)
+{
+    if (this == &val) {
+        return *this;
+    }
+    value = val.value;
+    return *this;
+}
+ * @tc.type: FUNC
+ */
+HWTEST_F(ValueObjectTest, ValueObject_Test_002, TestSize.Level1)
+{
+    int32_t intValue = 1234;
+    ValueObject obj(intValue);
+    ValueObject &ref = obj;
+    EXPECT_EQ(&ref, &(ref = obj));
+}
+
+/**
+ * @tc.name: ValueObject_Test_003
+ * @tc.desc: test func fouth line
+ValueObject::operator BigInt() const
+{
+    auto val = std::get_if<BigInt>(&value);
+    if (val == nullptr) {
+        return {};
+    }
+    return *val;
+}
+ * @tc.type: FUNC
+ */
+HWTEST_F(ValueObjectTest, ValueObject_Test_003, TestSize.Level1)
+{
+    BigInteger bigInt1(1234);
+    ValueObject obj(bigInt1);
+    BigInteger bigInt = obj;
+    EXPECT_TRUE(bigInt == bigInt1);
+}
+} // namespace Test
diff --git a/relational_store/test/native/rdb_data_ability_adapter/unittest/data_ability_utils_test.cpp b/relational_store/test/native/rdb_data_ability_adapter/unittest/data_ability_utils_test.cpp
index 90afb9c1d986e773537679872407597137be5506..e16ea790c5c1ef1826a01f58a24f58ec97276f3c 100644
--- a/relational_store/test/native/rdb_data_ability_adapter/unittest/data_ability_utils_test.cpp
+++ b/relational_store/test/native/rdb_data_ability_adapter/unittest/data_ability_utils_test.cpp
@@ -14,6 +14,7 @@
  */
 
 #include <gtest/gtest.h>
+
 #include <vector>
 
 #include "abs_rdb_predicates.h"
@@ -36,10 +37,18 @@ public:
     void TearDown();
 };
 
-void DataAbilityUtilsTest::SetUpTestCase(void) {}
-void DataAbilityUtilsTest::TearDownTestCase(void) {}
-void DataAbilityUtilsTest::SetUp(void) {}
-void DataAbilityUtilsTest::TearDown(void) {}
+void DataAbilityUtilsTest::SetUpTestCase(void)
+{
+}
+void DataAbilityUtilsTest::TearDownTestCase(void)
+{
+}
+void DataAbilityUtilsTest::SetUp(void)
+{
+}
+void DataAbilityUtilsTest::TearDown(void)
+{
+}
 
 /* *
  * @tc.name: DataAbilityUtilsTest_001
diff --git a/relational_store/test/native/rdb_data_share_adapter/unittest/rdb_data_share_adapter_test.cpp b/relational_store/test/native/rdb_data_share_adapter/unittest/rdb_data_share_adapter_test.cpp
index ed6efb46a1f3e73e3b519e5ffae5542011fd91d6..184151da627008062bac7869ccf35d658cfa716b 100644
--- a/relational_store/test/native/rdb_data_share_adapter/unittest/rdb_data_share_adapter_test.cpp
+++ b/relational_store/test/native/rdb_data_share_adapter/unittest/rdb_data_share_adapter_test.cpp
@@ -14,6 +14,7 @@
  */
 #define LOG_TAG "RdbDataShareAdapterTest"
 #include <gtest/gtest.h>
+
 #include <string>
 
 #include "datashare_predicates.h"
@@ -108,29 +109,28 @@ void RdbDataShareAdapterTest::GenerateDefaultTable()
     uint8_t uValue = 66;
     std::vector<uint8_t> typeBlob;
     typeBlob.push_back(uValue);
-    store->ExecuteSql(insertSql, std::vector<ValueObject> {
-        ValueObject(std::string("hello")), ValueObject((int)10),
+    store->ExecuteSql(insertSql, std::vector<ValueObject>{ ValueObject(std::string("hello")), ValueObject((int)10),
         ValueObject((double)1.0), ValueObject((std::vector<uint8_t>)typeBlob)
     });
 
     /* insert second entry data */
     typeBlob.clear();
-    store->ExecuteSql(insertSql, std::vector<ValueObject> {
+    store->ExecuteSql(insertSql, std::vector<ValueObject>{
         ValueObject(std::string("2")), ValueObject((int)-5), ValueObject((double)2.5),
         ValueObject() // set double value 2.5
     });
 
     /* insert third entry data */
-    store->ExecuteSql(insertSql, std::vector<ValueObject> {
+    store->ExecuteSql(insertSql, std::vector<ValueObject>{
         ValueObject(std::string("hello world")), ValueObject((int)3), ValueObject((double)1.8),
-        ValueObject(std::vector<uint8_t> { 4, 5, 6 }) // set int value 3, double 1.8
+        ValueObject(std::vector<uint8_t>{ 4, 5, 6 }) // set int value 3, double 1.8
     });
 
     /* insert four entry data */
-    store->ExecuteSql(insertSql, std::vector<ValueObject> {
-        ValueObject(std::string("new world")), ValueObject((int)5),
-        ValueObject((double)5.8), ValueObject() // set int value 5, double 5.8
-    });
+    store->ExecuteSql(insertSql, std::vector<ValueObject>{
+                                     ValueObject(std::string("new world")), ValueObject((int)5),
+                                     ValueObject((double)5.8), ValueObject() // set int value 5, double 5.8
+                                 });
 }
 
 void RdbDataShareAdapterTest::GenerateDefaultEmptyTable()
@@ -232,7 +232,7 @@ HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_004, TestSize.Level1)
     std::string table = "test";
     OHOS::DataShare::DataSharePredicates predicates;
     predicates.SetWhereClause("`data2` > ?");
-    predicates.SetWhereArgs(std::vector<std::string> { "-5" });
+    predicates.SetWhereArgs(std::vector<std::string>{ "-5" });
     predicates.SetOrder("data3");
     std::vector<std::string> columns;
     auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, table), columns);
@@ -282,7 +282,7 @@ HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_005, TestSize.Level1)
     values.Put("data1", std::string("tulip"));
     values.Put("data2", 100);
     values.Put("data3", 50.5);
-    values.Put("data4", std::vector<uint8_t> { 20, 21, 22 });
+    values.Put("data4", std::vector<uint8_t>{ 20, 21, 22 });
 
     int ret = store->Insert(id, "test", RdbUtils::ToValuesBucket(values));
     EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
@@ -302,9 +302,9 @@ HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_005, TestSize.Level1)
 
     values.Clear();
     values.Put("data3", 300.5);
-    values.Put("data4", std::vector<uint8_t> { 17, 18, 19 });
+    values.Put("data4", std::vector<uint8_t>{ 17, 18, 19 });
     ret = store->Update(
-        changedRows, "test", RdbUtils::ToValuesBucket(values), "data1 = ?", std::vector<std::string> { "tulip" });
+        changedRows, "test", RdbUtils::ToValuesBucket(values), "data1 = ?", std::vector<std::string>{ "tulip" });
     EXPECT_EQ(ret, OHOS::NativeRdb::E_OK);
     EXPECT_EQ(1, changedRows);
 
@@ -392,7 +392,6 @@ HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_007, TestSize.Level1)
     EXPECT_EQ(ret2, OHOS::NativeRdb::E_OK);
     EXPECT_EQ(2, id);
 
-
     std::string table = "test";
     OHOS::DataShare::DataSharePredicates predicates;
     std::vector<std::string> columns;
@@ -442,8 +441,13 @@ HWTEST_F(RdbDataShareAdapterTest, Rdb_DataShare_Adapter_008, TestSize.Level1)
     EXPECT_EQ(1, id);
 
     OHOS::DataShare::DataSharePredicates predicates;
-    predicates.BeginWrap()->EqualTo("data1", data1)->And()
-        ->EqualTo("data2", data2)->And()->EqualTo("data3", data3)->EndWrap();
+    predicates.BeginWrap()
+        ->EqualTo("data1", data1)
+        ->And()
+        ->EqualTo("data2", data2)
+        ->And()
+        ->EqualTo("data3", data3)
+        ->EndWrap();
     std::vector<std::string> columns;
     auto allDataTypes = store->Query(RdbUtils::ToPredicates(predicates, tableName), columns);
     int rowCount;
diff --git a/relational_store/test/ndk/unittest/common.h b/relational_store/test/ndk/unittest/common.h
index 59043d2071c89432cfcd690b4571f378197245e7..fa47179a057304b52a8ece24116ba9e2edf6d3d5 100644
--- a/relational_store/test/ndk/unittest/common.h
+++ b/relational_store/test/ndk/unittest/common.h
@@ -21,7 +21,7 @@
 namespace OHOS {
 namespace NativeRdb {
 
-static constexpr const char *RDB_TEST_PATH = "/data/storage/el2/database/com.ohos.example.distributedndk/entry/rdb/";
+static constexpr const char *RDB_TEST_PATH = "/data/storage/el2/database/com.ohos.example.distributedndk/entry/";
 
 } // namespace NativeRdb
 } // namespace OHOS
diff --git a/relational_store/test/ndk/unittest/rdb_asset_test.cpp b/relational_store/test/ndk/unittest/rdb_asset_test.cpp
index 3556a1253041e9a4006e18340b5127c62d400c58..0a7a9d005bf40441a5459a250391857411a1377a 100644
--- a/relational_store/test/ndk/unittest/rdb_asset_test.cpp
+++ b/relational_store/test/ndk/unittest/rdb_asset_test.cpp
@@ -14,10 +14,11 @@
  */
 
 #include <gtest/gtest.h>
-#include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <string>
+
 #include "common.h"
 #include "relational_store.h"
 #include "relational_store_error_code.h"
@@ -70,9 +71,13 @@ void RdbNativeAssetTest::TearDownTestCase(void)
     EXPECT_EQ(errCode, 0);
 }
 
-void RdbNativeAssetTest::SetUp(void) {}
+void RdbNativeAssetTest::SetUp(void)
+{
+}
 
-void RdbNativeAssetTest::TearDown(void) {}
+void RdbNativeAssetTest::TearDown(void)
+{
+}
 
 void RdbNativeAssetTest::CreateAssetTable()
 {
diff --git a/relational_store/test/ndk/unittest/rdb_cursor_test.cpp b/relational_store/test/ndk/unittest/rdb_cursor_test.cpp
index b3772e5ea1c4000acf1925f473cd40d3b371e3b9..1840d11ab0d91a637589dc24cabc2fa3ef92f77b 100644
--- a/relational_store/test/ndk/unittest/rdb_cursor_test.cpp
+++ b/relational_store/test/ndk/unittest/rdb_cursor_test.cpp
@@ -14,10 +14,11 @@
  */
 
 #include <gtest/gtest.h>
-#include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <string>
+
 #include "common.h"
 #include "relational_store.h"
 #include "relational_store_error_code.h"
@@ -102,9 +103,13 @@ void RdbNativeCursorTest::TearDownTestCase(void)
     OH_Rdb_DeleteStore(&config_);
 }
 
-void RdbNativeCursorTest::SetUp(void) {}
+void RdbNativeCursorTest::SetUp(void)
+{
+}
 
-void RdbNativeCursorTest::TearDown(void) {}
+void RdbNativeCursorTest::TearDown(void)
+{
+}
 
 void RdbNativeCursorTest::CreateAssetTable()
 {
@@ -418,7 +423,7 @@ HWTEST_F(RdbNativeCursorTest, RDB_Native_cursor_test_006, TestSize.Level1)
 {
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
 
-    const char *columnNames[] = {"data1", "data2", "data3", "data4"};
+    const char *columnNames[] = { "data1", "data2", "data3", "data4" };
     int len = sizeof(columnNames) / sizeof(columnNames[0]);
     OH_Cursor *cursor = OH_Rdb_Query(cursorTestRdbStore_, predicates, columnNames, len);
     EXPECT_NE(cursor, NULL);
diff --git a/relational_store/test/ndk/unittest/rdb_predicates_test.cpp b/relational_store/test/ndk/unittest/rdb_predicates_test.cpp
index 1e1e7e25f110c6057ba05ceae81b337ddc9558a4..41b88b36405a64f58950f90468da09c3dd99ef8c 100644
--- a/relational_store/test/ndk/unittest/rdb_predicates_test.cpp
+++ b/relational_store/test/ndk/unittest/rdb_predicates_test.cpp
@@ -14,13 +14,14 @@
  */
 
 #include <gtest/gtest.h>
-
-#include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
+
+#include <string>
+
 #include "common.h"
-#include "relational_store.h"
 #include "oh_value_object.h"
+#include "relational_store.h"
 #include "relational_store_error_code.h"
 
 using namespace testing::ext;
@@ -46,7 +47,7 @@ public:
 };
 
 OH_Rdb_Store *predicatesTestRdbStore_;
-OH_Rdb_Config RdbNativePredicatesTest::config_ = {0};
+OH_Rdb_Config RdbNativePredicatesTest::config_ = { 0 };
 void RdbNativePredicatesTest::SetUpTestCase(void)
 {
     InitRdbConfig();
@@ -65,7 +66,7 @@ void RdbNativePredicatesTest::SetUpTestCase(void)
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     valueBucket->putInt64(valueBucket, "data2", 12800);
     valueBucket->putReal(valueBucket, "data3", 100.1);
-    uint8_t arr[] = {1, 2, 3, 4, 5};
+    uint8_t arr[] = { 1, 2, 3, 4, 5 };
     int len = sizeof(arr) / sizeof(arr[0]);
     valueBucket->putBlob(valueBucket, "data4", arr, len);
     valueBucket->putText(valueBucket, "data5", "ABCDEFG");
@@ -354,11 +355,11 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_009, TestSize.Level
     int errCode = 0;
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
-    int64_t data2Value[] = {12000, 13000};
+    int64_t data2Value[] = { 12000, 13000 };
     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
     valueObject->putInt64(valueObject, data2Value, len);
     predicates->between(predicates, "data2", valueObject);
-    double data3Value[] = {0.1, 101.1};
+    double data3Value[] = { 0.1, 101.1 };
     len = sizeof(data3Value) / sizeof(data3Value[0]);
     valueObject->putDouble(valueObject, data3Value, len);
     predicates->between(predicates, "data3", valueObject);
@@ -384,7 +385,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_010, TestSize.Level
     int errCode = 0;
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
-    int64_t data2Value[] = {12000, 13000};
+    int64_t data2Value[] = { 12000, 13000 };
     int len = sizeof(data2Value) / sizeof(data2Value[0]);
     valueObject->putInt64(valueObject, data2Value, len);
     predicates->notBetween(predicates, "data2", valueObject);
@@ -442,7 +443,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_012, TestSize.Level
     int errCode = 0;
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
-    const char *data1Value[] = {"zhangSan", "liSi"};
+    const char *data1Value[] = { "zhangSan", "liSi" };
     int len = sizeof(data1Value) / sizeof(data1Value[0]);
     valueObject->putTexts(valueObject, data1Value, len);
     predicates->in(predicates, "data1", valueObject);
@@ -468,7 +469,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_013, TestSize.Level
     int errCode = 0;
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
-    const char *data1Value[] = {"zhangSan", "liSi"};
+    const char *data1Value[] = { "zhangSan", "liSi" };
     int len = sizeof(data1Value) / sizeof(data1Value[0]);
     valueObject->putTexts(valueObject, data1Value, len);
     predicates->notIn(predicates, "data1", valueObject);
@@ -521,7 +522,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_015, TestSize.Level
 {
     int errCode = 0;
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("test");
-    const char *columnNames[] = {"data1", "data2"};
+    const char *columnNames[] = { "data1", "data2" };
     int len = sizeof(columnNames) / sizeof(columnNames[0]);
     predicates->groupBy(predicates, columnNames, len);
 
@@ -648,7 +649,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_019, TestSize.Level
     predicates->like(predicates, nullptr, valueObject);
     predicates->like(predicates, "data5", nullptr);
 
-    int64_t data2Value[] = {12000, 13000};
+    int64_t data2Value[] = { 12000, 13000 };
     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
     valueObject->putInt64(valueObject, data2Value, len);
     predicates->between(nullptr, "data2", valueObject);
@@ -657,7 +658,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_019, TestSize.Level
     predicates->notBetween(nullptr, "data2", valueObject);
     predicates->notBetween(predicates, nullptr, valueObject);
     predicates->notBetween(predicates, "data2", nullptr);
-    int64_t data2Value_1[] = {12000};
+    int64_t data2Value_1[] = { 12000 };
     len = sizeof(data2Value_1) / sizeof(data2Value_1[0]);
     valueObject->putInt64(valueObject, data2Value_1, len);
     predicates->between(predicates, "data2", valueObject);
@@ -703,13 +704,13 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_020, TestSize.Level
     predicates->limit(nullptr, 1);
     predicates->offset(nullptr, 1);
 
-    const char *columnNames[] = {"data1", "data2"};
+    const char *columnNames[] = { "data1", "data2" };
     uint32_t len = sizeof(columnNames) / sizeof(columnNames[0]);
     predicates->groupBy(nullptr, columnNames, len);
     predicates->groupBy(predicates, nullptr, len);
     predicates->groupBy(predicates, columnNames, 0);
 
-    const char *data1ValueIn[] = {"zhangSan", "liSi"};
+    const char *data1ValueIn[] = { "zhangSan", "liSi" };
     len = sizeof(data1ValueIn) / sizeof(data1ValueIn[0]);
     valueObject->putTexts(valueObject, data1ValueIn, len);
     predicates->in(nullptr, "data1", valueObject);
@@ -734,7 +735,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_020, TestSize.Level
 HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_021, TestSize.Level1)
 {
     OH_VObject *valueObject = OH_Rdb_CreateValueObject();
-    int64_t data2Value[] = {12000, 13000};
+    int64_t data2Value[] = { 12000, 13000 };
     uint32_t len = sizeof(data2Value) / sizeof(data2Value[0]);
     int errCode = valueObject->putInt64(nullptr, data2Value, len);
     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
@@ -756,7 +757,7 @@ HWTEST_F(RdbNativePredicatesTest, RDB_Native_predicates_test_021, TestSize.Level
     valueObject->putText(nullptr, data1Value);
     valueObject->putText(valueObject, nullptr);
 
-    const char *data1ValueTexts[] = {"zhangSan", "liSi"};
+    const char *data1ValueTexts[] = { "zhangSan", "liSi" };
     len = sizeof(data1ValueTexts) / sizeof(data1ValueTexts[0]);
     errCode = valueObject->putTexts(nullptr, data1ValueTexts, len);
     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
diff --git a/relational_store/test/ndk/unittest/rdb_store_test.cpp b/relational_store/test/ndk/unittest/rdb_store_test.cpp
index 7662475595a4c641135bb9673aa91168c50bd1b7..6340f98c575aa9b80e2050e38ab5211de792c4a2 100644
--- a/relational_store/test/ndk/unittest/rdb_store_test.cpp
+++ b/relational_store/test/ndk/unittest/rdb_store_test.cpp
@@ -13,16 +13,17 @@
  * limitations under the License.
  */
 #include <gtest/gtest.h>
-#include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
 
+#include <string>
+
 #include "accesstoken_kit.h"
 #include "common.h"
 #include "rdb_errno.h"
 #include "relational_store.h"
-#include "relational_store_impl.h"
 #include "relational_store_error_code.h"
+#include "relational_store_impl.h"
 #include "token_setproc.h"
 
 using namespace testing::ext;
@@ -56,10 +57,9 @@ OH_Rdb_Config RdbNativeStoreTest::config_ = { 0 };
 
 void RdbNativeStoreTest::MockHap(void)
 {
-    HapInfoParams info = { .userID = 100,
-        .bundleName = "com.example.distributed",
-        .instIndex = 0,
-        .appIDDesc = "com.example.distributed" };
+    HapInfoParams info = {
+        .userID = 100, .bundleName = "com.example.distributed", .instIndex = 0, .appIDDesc = "com.example.distributed"
+    };
     PermissionDef infoManagerTestPermDef = { .permissionName = "ohos.permission.test",
         .bundleName = "com.example.distributed",
         .grantMode = 1,
@@ -105,7 +105,7 @@ void RdbNativeStoreTest::SetUp(void)
     int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
     EXPECT_EQ(errCode, 0);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 1);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     valueBucket->putInt64(valueBucket, "data2", 12800);
@@ -161,7 +161,7 @@ Rdb_ProgressObserver observer = { nullptr, callback };
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_001, TestSize.Level1)
 {
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
     valueBucket->putReal(valueBucket, "data3", 200.1);
@@ -224,7 +224,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_001, TestSize.Level1)
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_002, TestSize.Level1)
 {
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
@@ -290,7 +290,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_003, TestSize.Level1)
     OH_Rdb_BeginTransaction(storeTestRdbStore_);
 
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
@@ -322,7 +322,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_004, TestSize.Level1)
     OH_Rdb_BeginTransaction(storeTestRdbStore_);
 
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
@@ -338,7 +338,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_004, TestSize.Level1)
 
     int rowCount = 0;
     cursor->getRowCount(cursor, &rowCount);
-    EXPECT_EQ(rowCount, 1);     // 回退至函数之前的状态
+    EXPECT_EQ(rowCount, 1); // 回退至函数之前的状态
 
     valueBucket->destroy(valueBucket);
     cursor->destroy(cursor);
@@ -351,7 +351,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_004, TestSize.Level1)
  */
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_005, TestSize.Level1)
 {
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     valueBucket->putInt64(valueBucket, "data2", 12800);
     valueBucket->putReal(valueBucket, "data3", 100.1);
@@ -403,7 +403,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_005, TestSize.Level1)
 
     // Continuous restore
     errCode = OH_Rdb_Restore(storeTestRdbStore_, backupPath3.c_str());
-    EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
+    EXPECT_EQ(errCode, 0);
     cursor = OH_Rdb_ExecuteQuery(storeTestRdbStore_, querySql);
     cursor->getRowCount(cursor, &rowCount);
     EXPECT_EQ(rowCount, 4);
@@ -443,7 +443,6 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_006, TestSize.Level1)
     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_FILE_PATH);
 }
 
-
 /**
  * @tc.name: RDB_Native_store_test_007
  * @tc.desc: Normal testCase of store for Backup、Restore.
@@ -452,11 +451,11 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_006, TestSize.Level1)
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_007, TestSize.Level1)
 {
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     valueBucket->putInt64(valueBucket, "data2", 12800);
     valueBucket->putReal(valueBucket, "data3", 100.1);
-    uint8_t arr[] = {1, 2, 3, 4, 5};
+    uint8_t arr[] = { 1, 2, 3, 4, 5 };
     int len = sizeof(arr) / sizeof(arr[0]);
     valueBucket->putBlob(valueBucket, "data4", arr, len);
     valueBucket->putText(valueBucket, "data5", "ABCDEFG");
@@ -523,7 +522,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_008, TestSize.Level1)
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_009, TestSize.Level1)
 {
     int errCode = 0;
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
@@ -564,7 +563,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_009, TestSize.Level1)
  */
 HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_0010, TestSize.Level1)
 {
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putText(valueBucket, "data1", "liSi");
     valueBucket->putInt64(valueBucket, "data2", 13800);
 
@@ -714,8 +713,8 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_014, TestSize.Level1)
     constexpr int TABLE_COUNT = 1;
     const char *table[TABLE_COUNT];
     table[0] = "store_test";
-    int errcode = OH_Rdb_SetDistributedTables(storeTestRdbStore_, table, TABLE_COUNT,
-        Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
+    int errcode = OH_Rdb_SetDistributedTables(
+        storeTestRdbStore_, table, TABLE_COUNT, Rdb_DistributedType::RDB_DISTRIBUTED_CLOUD, &config);
     EXPECT_EQ(errcode, RDB_E_INVALID_ARGS);
     config.version = DISTRIBUTED_CONFIG_VERSION;
     errcode =
@@ -796,8 +795,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_017, TestSize.Level1)
     values->putInt64(values, keys, 1);
 
     OH_Cursor *cursor;
-    cursor =
-        OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "ROWID", values);
+    cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdbstoreimpltest_integer", "ROWID", values);
     int rowCount;
     errCode = cursor->getRowCount(cursor, &rowCount);
     EXPECT_EQ(errCode, RDB_OK);
@@ -810,7 +808,6 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_017, TestSize.Level1)
     cursor->getInt64(cursor, 1, &time);
     EXPECT_EQ(time, 100000);
 
-
     cursor->destroy(cursor);
     char dropLogTableSql[] = "DROP TABLE IF EXISTS naturalbase_rdb_aux_rdbstoreimpltest_integer_log";
     errCode = OH_Rdb_Execute(storeTestRdbStore_, dropLogTableSql);
@@ -841,7 +838,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_018, TestSize.Level1)
     values->putInt64(values, keys, 1);
 
     // store is nullptr
-    OH_Cursor* cursor = OH_Rdb_FindModifyTime(nullptr, "rdbstoreimpltest_integer", "data_key", values);
+    OH_Cursor *cursor = OH_Rdb_FindModifyTime(nullptr, "rdbstoreimpltest_integer", "data_key", values);
     EXPECT_EQ(cursor, nullptr);
 
     // tabel name is nullptr
@@ -873,8 +870,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_018, TestSize.Level1)
     // keys is empty
     cursor->destroy(cursor);
     OH_VObject *emptyValues = OH_Rdb_CreateValueObject();
-    cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdb_aux_rdbstoreimpltest_integer", "data_key",
-        emptyValues);
+    cursor = OH_Rdb_FindModifyTime(storeTestRdbStore_, "rdb_aux_rdbstoreimpltest_integer", "data_key", emptyValues);
     cursor->getRowCount(cursor, &rowCount);
     EXPECT_EQ(errCode, OH_Rdb_ErrCode::RDB_E_INVALID_ARGS);
 
@@ -1105,7 +1101,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_024, TestSize.Level1)
     Rdb_DataObserver observer = { nullptr, { callback } };
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     // id is 2
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
@@ -1150,7 +1146,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_025, TestSize.Level1)
 
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putText(valueBucket, "data1", "liSi");
 
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
@@ -1233,7 +1229,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_027, TestSize.Level1)
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     // id is 2
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
@@ -1272,7 +1268,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_028, TestSize.Level1)
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
     EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer1), RDB_OK);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     // id is 2
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
@@ -1321,13 +1317,13 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_029, TestSize.Level1)
 
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
 
-    constexpr const char* createTableSql = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, "
+    constexpr const char *createTableSql = "CREATE TABLE test1 (id INTEGER PRIMARY KEY AUTOINCREMENT, "
                                            "data1 TEXT, data2 INTEGER, data3 FLOAT, data4 BLOB, data5 TEXT);";
     int errCode = OH_Rdb_Execute(storeTestRdbStore_, createTableSql);
     // errCode is 0
     EXPECT_EQ(errCode, 0);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 1);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     errCode = OH_Rdb_Insert(storeTestRdbStore_, "test1", valueBucket);
@@ -1336,7 +1332,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_029, TestSize.Level1)
 
     EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
 
-    constexpr const char* dropTableSql = "DROP TABLE IF EXISTS test1";
+    constexpr const char *dropTableSql = "DROP TABLE IF EXISTS test1";
     errCode = OH_Rdb_Execute(storeTestRdbStore_, dropTableSql);
     // errCode is 0
     EXPECT_EQ(errCode, 0);
@@ -1373,7 +1369,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_030, TestSize.Level1)
 {
     EXPECT_NE(storeTestRdbStore_, nullptr);
 
-    OH_VBucket* valueBucket1 = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket1 = OH_Rdb_CreateValuesBucket();
     valueBucket1->putText(valueBucket1, "data1", "zhangSan");
     int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket1);
     // rowId is 2
@@ -1384,7 +1380,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_030, TestSize.Level1)
 
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer), RDB_OK);
 
-    OH_VBucket* valueBucket2 = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket2 = OH_Rdb_CreateValuesBucket();
     valueBucket2->putText(valueBucket2, "data1", "liSi");
 
     OH_Predicates *predicates = OH_Rdb_CreatePredicates("store_test");
@@ -1437,7 +1433,7 @@ HWTEST_F(RdbNativeStoreTest, RDB_Native_store_test_031, TestSize.Level1)
     EXPECT_EQ(OH_Rdb_Subscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, &observer2), RDB_OK);
     EXPECT_EQ(OH_Rdb_Unsubscribe(storeTestRdbStore_, RDB_SUBSCRIBE_TYPE_LOCAL_DETAILS, nullptr), RDB_OK);
 
-    OH_VBucket* valueBucket = OH_Rdb_CreateValuesBucket();
+    OH_VBucket *valueBucket = OH_Rdb_CreateValuesBucket();
     valueBucket->putInt64(valueBucket, "id", 2);
     valueBucket->putText(valueBucket, "data1", "zhangSan");
     int errCode = OH_Rdb_Insert(storeTestRdbStore_, "store_test", valueBucket);
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 71e12da61e004fce9626f54e4d5858b17f3840d8..601f86cba24a5f19b9a6ddc4a6fb8083b852330b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -4,6 +4,7 @@ project(LDBTest)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS "-std=c++1y -fvisibility=default -D_GNU_SOURCE")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdata-sections -fPIC -fpic -ffunction-sections -D_GLIBC_MOCK")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-access-control")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--no-as-needed -ldl")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat=0 -fpermissive")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
@@ -82,7 +83,7 @@ target_include_directories(DataMgrServiceTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR
 target_include_directories(DataMgrServiceTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../datamgr_service/services/distributeddataservice/app/src/)
 target_include_directories(DataMgrServiceTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../relational_store/frameworks/native/rdb/include/)
 target_include_directories(DataMgrServiceTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../relational_store/interfaces/inner_api/rdb/include/)
-#************************************************DataMgrServiceTest start************************************************#
+#************************************************DataMgrServiceTest end************************************************#
 
 #************************************************RDBTest start************************************************#
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/../relational_store/test/native/dataability/unittest RelationalStoreTestSrc)
@@ -149,10 +150,14 @@ target_include_directories(DataObjectTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..
 
 #************************************************UdmfTest start************************************************#
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/innerkitsimpl/test/unittest UdmfTestSrc)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/innerkitsimpl/test/unittest/mock UdmfTestSrc)
 add_executable(UdmfTest ${UdmfTestSrc} ${mainSrc} ${serviceSrc})
-target_link_libraries(UdmfTest ${links} gtest_main gcov udmf)
+target_link_libraries(UdmfTest ${links} gtest_main gcov gmock udmf)
 target_include_directories(UdmfTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/common)
 target_include_directories(UdmfTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/innerkitsimpl/data)
+target_include_directories(UdmfTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/innerkitsimpl/service)
+target_include_directories(UdmfTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../udmf/framework/innerkitsimpl/test/unittest/mock/include)
+target_include_directories(UdmfTest PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../kv_store/frameworks/innerkitsimpl/distributeddatasvc/include)
 #************************************************UdmfTest end************************************************#
 
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/../datamgr_service/services/distributeddataservice/service/test/mock CloudTestSrc)
diff --git a/udmf/BUILD.gn b/udmf/BUILD.gn
index 4ad462942e5e2997bddebbd6c03606f7705536b1..9d1989c405fa6b9cd0ef66969e2524fcecebfbbf 100644
--- a/udmf/BUILD.gn
+++ b/udmf/BUILD.gn
@@ -21,6 +21,7 @@ group("udmf_packages") {
       "interfaces/jskits:udmf_data_napi",
       "interfaces/jskits:unifieddatachannel_napi",
       "interfaces/jskits:uniformtypedescriptor_napi",
+      "interfaces/ndk:libudmf",
     ]
   }
 }
@@ -29,8 +30,10 @@ group("unittest") {
   testonly = true
 
   deps = [
+    "framework/common/unittest:unittest",
     "framework/innerkitsimpl/test/unittest:unittest",
     "framework/jskitsimpl/unittest:unittest",
+    "framework/ndkimpl/unittest:unittest",
   ]
 }
 
diff --git a/udmf/CMakeLists.txt b/udmf/CMakeLists.txt
index 5186b532babf335890743296849ffbfb042ec745..3698522330403612262c8a985d56dde5c21cba52 100644
--- a/udmf/CMakeLists.txt
+++ b/udmf/CMakeLists.txt
@@ -14,18 +14,20 @@ add_definitions(-DNAPI_EXPERIMENTAL)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/common udmf_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/client udmf_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/common udmf_src)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/convert udmf_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/data udmf_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/service udmf_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/jskitsimpl/common udmf_channel_src)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/jskitsimpl/data udmf_channel_src)
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/ndkimpl/data udmf_ndk_src)
 list(REMOVE_ITEM udmf_channel_src "${CMAKE_CURRENT_SOURCE_DIR}/frameworks/jskitsimpl/data/uniform_type_descriptor_napi.cpp")
-aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/framework/service udmf_src)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/framework/common)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/service)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/data)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/interfaces/jskits/common)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/interfaces/jskits/data)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/interfaces/ndk/data)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../kv_store/frameworks/common)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../utils_native/base/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../utils_native/safwk/native/include)
@@ -38,7 +40,13 @@ add_library(udmf SHARED ${udmf_src})
 target_link_libraries(udmf ${links})
 target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/innerkits/client)
 target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/innerkits/common)
+target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/innerkits/convert)
 target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interfaces/innerkits/data)
+target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/framework/innerkitsimpl/client)
+target_include_directories(udmf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/framework/ndkimpl/data)
 
 add_library(udmf_channel SHARED ${udmf_channel_src})
-target_link_libraries(udmf_channel mock udmf)
\ No newline at end of file
+target_link_libraries(udmf_channel mock udmf)
+
+add_library(udmf_ndk SHARED ${udmf_ndk_src})
+target_link_libraries(udmf_ndk mock udmf)
\ No newline at end of file
diff --git a/udmf/adapter/BUILD.gn b/udmf/adapter/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..42963c5f41e80ea8bc7661d6dbb8a92af949feae
--- /dev/null
+++ b/udmf/adapter/BUILD.gn
@@ -0,0 +1,305 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/ohos.gni")
+import("//foundation/distributeddatamgr/udmf/adapter/arkui_x_udmf.gni")
+import("//foundation/distributeddatamgr/udmf/udmf.gni")
+
+config("udmf_client_config") {
+  include_dirs = [
+    "${udmf_interfaces_path}/innerkits/client",
+    "${udmf_interfaces_path}/innerkits/common",
+    "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_framework_path}/common",
+    "${udmf_framework_path}/innerkitsimpl/data",
+    "${udmf_framework_path}/innerkitsimpl/service",
+    "${kv_store_path}/frameworks/common",
+    "${third_party_path}/libuv/include",
+    "${third_party_path}/node/src",
+    "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include",
+    "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/src",
+    "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include",
+    "${kv_store_path}/interfaces/innerkits/distributeddata/include",
+    "${file_service_path}/interfaces/common/include",
+    "${file_service_path}/interfaces/innerkits/native/file_uri/include",
+  ]
+}
+
+config("udmf_napi_config") {
+  include_dirs = [
+    "${udmf_interfaces_path}/innerkits/client",
+    "${udmf_interfaces_path}/innerkits/common",
+    "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_interfaces_path}/jskits/common",
+    "${udmf_interfaces_path}/jskits/data",
+
+    "${udmf_framework_path}/common",
+    "${udmf_framework_path}/innerkits/service",
+
+    "${third_party_path}/libuv/include",
+    "${third_party_path}/node/src",
+
+    "${aafwk_inner_api_path}/ability_manager/include",
+    "${aafwk_kits_path}/appkit/native/app/include/",
+    "${aafwk_kits_path}/ability/native/include",
+    "${aafwk_napi_path}/inner/napi_common",
+    "${aafwk_service_path}/abilitymgr/include",
+    "${aafwk_service_path}/common/include",
+  ]
+}
+
+config("arkui_x_udmf_config") {
+  include_dirs = [
+    "${arkui_x_image_framework_path}/interfaces/innerkits/include",
+    "${arkui_x_image_framework_path}/interfaces/kits/js/common/include",
+    "${arkui_x_image_framework_path}/frameworks/innerkitsimpl/receiver/include",
+    "${arkui_x_image_framework_path}/frameworks/innerkitsimpl/utils/include",
+    "${arkui_x_graphic_2d_path}/rosen/modules/platform/ipc_core",
+    "${arkui_x_graphic_2d_path}/utils/color_manager/export",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/common",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/surface",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/utils",
+    "${third_party_path}/skia",
+  ]
+}
+
+arkui_x_public_source = [
+  "${udmf_framework_path}/innerkitsimpl/common/unified_key.cpp",
+  "${udmf_framework_path}/innerkitsimpl/common/unified_meta.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/application_defined_record.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/audio.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/file.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/flexible_type.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/folder.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/html.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/image.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/link.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/plain_text.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/preset_type_descriptors.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/system_defined_appitem.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/system_defined_form.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/system_defined_pixelmap.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/system_defined_record.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/text.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/type_descriptor.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/unified_data.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/unified_record.cpp",
+  "${udmf_framework_path}/innerkitsimpl/data/video.cpp",
+]
+
+ohos_source_set("arkui_x_udmf_data") {
+  sources = [
+    "${udmf_framework_path}/common/base32_utils.cpp",
+    "${udmf_framework_path}/common/custom_utd_json_parser.cpp",
+    "${udmf_framework_path}/common/custom_utd_store.cpp",
+    "${udmf_framework_path}/common/graph.cpp",
+    "${udmf_framework_path}/common/udmf_utils.cpp",
+    "${udmf_framework_path}/common/utd_cfgs_checker.cpp",
+    "${udmf_framework_path}/common/utd_graph.cpp",
+  ]
+
+  sources += arkui_x_public_source
+
+  deps = [
+    "${arkui_path}/ace_engine/adapter/${target_os}/build:libarkui_${target_os}",
+    "${arkui_x_c_utils_path}/base:utilsbase",
+    "${arkui_x_hilog_path}/interfaces/native/innerkits:libhilog_${target_os}",
+    "${third_party_path}/cJSON:cjson_static",
+  ]
+
+  configs = [
+    ":arkui_x_udmf_config",
+    ":udmf_client_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:want_params_config",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "udmf"
+}
+
+ohos_source_set("arkui_x_udmf_data_inner") {
+  sources = arkui_x_public_source
+
+  include_dirs = [ "${arkui_x_hilog_path}/interfaces/native/innerkits/include" ]
+
+  deps = [
+    "${arkui_path}/napi/:ace_napi",
+    "${arkui_x_c_utils_path}/base:utilsbase",
+    "${arkui_x_hilog_path}/interfaces/native/innerkits:libhilog_${target_os}",
+  ]
+
+  configs = [
+    ":arkui_x_udmf_config",
+    ":udmf_client_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:want_params_config",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "udmf"
+}
+
+config("arkui_x_udmf_napi_config") {
+  include_dirs = [
+    "${arkui_path}/napi/interfaces/kits",
+    "${arkui_path}/napi/interfaces/inner_api",
+    "${arkui_x_hilog_path}/interfaces/native/innerkits/include",
+    "${arkui_x_image_framework_path}/interfaces/kits/js/common/include",
+    "${arkui_x_image_framework_path}/frameworks/innerkitsimpl/receiver/include",
+    "${arkui_x_image_framework_path}/frameworks/innerkitsimpl/utils/include",
+    "${arkui_x_image_framework_path}/interfaces/innerkits/include",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/common",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/surface",
+    "${arkui_x_graphic_surface_path}/interfaces/inner_api/utils",
+    "${arkui_x_graphic_2d_path}/utils/color_manager/export",
+    "${arkui_x_graphic_2d_path}/rosen/modules/platform/ipc_core",
+    "${third_party_path}/skia",
+  ]
+}
+
+ohos_source_set("arkui_x_uniformtypedescriptor") {
+  include_dirs = [
+    "${ability_runtime_cross_platform_path}/frameworks/js/napi/napi_common",
+    "${udmf_framework_path}/innerkitsimpl/data",
+    "${udmf_root_path}/adapter/framework/innerkitsimpl/client",
+  ]
+
+  sources = [
+    "${udmf_framework_path}/jskitsimpl/common/napi_data_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_error_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_queue.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/type_descriptor_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/uniform_type_descriptor_napi.cpp",
+    "${udmf_interfaces_path}/jskits/module/uniform_type_descriptor_napi_module.cpp",
+    "${udmf_root_path}/adapter/framework/innerkitsimpl/client/udmf_client.cpp",
+    "${udmf_root_path}/adapter/framework/innerkitsimpl/client/utd_client.cpp",
+  ]
+  deps = [
+    ":arkui_x_udmf_data",
+    "${arkui_x_c_utils_path}/base:utilsbase",
+    "${arkui_x_hilog_path}/interfaces/native/innerkits:libhilog_${target_os}",
+    "${arkui_x_plugin_path}/libs/napi:napi_${target_os}",
+  ]
+
+  public_configs = [
+    ":udmf_napi_config",
+    ":arkui_x_udmf_napi_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/jsruntime:jsruntime_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/hilog:ability_cross_platform_hilog_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:want_params_config",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "udmf"
+}
+
+ohos_source_set("arkui_x_unifieddatachannel") {
+  include_dirs = [
+    "${ability_runtime_cross_platform_path}/frameworks/js/napi/napi_common",
+    "${udmf_root_path}/adapter/framework/innerkitsimpl/client",
+    "${third_party_path}/bounds_checking_function/include",
+  ]
+
+  sources = [
+    "${udmf_framework_path}/jskitsimpl/common/napi_data_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_error_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_queue.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/application_defined_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/audio_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/file_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/folder_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/html_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/image_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/link_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/plain_text_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/summary_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_appitem_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_form_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_pixelmap_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/text_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_data_channel_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_data_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_data_properties_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/video_napi.cpp",
+    "${udmf_interfaces_path}/jskits/module/unified_data_channel_napi_module.cpp",
+    "${udmf_root_path}/adapter/framework/innerkitsimpl/client/udmf_client.cpp",
+  ]
+
+  ldflags = [ "-Wl,--exclude-libs=ALL" ]
+
+  public_configs = [
+    ":udmf_napi_config",
+    ":arkui_x_udmf_napi_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/jsruntime:jsruntime_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/hilog:ability_cross_platform_hilog_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:want_params_config",
+  ]
+
+  deps = [
+    ":arkui_x_udmf_data",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:cross_platform_want_params",
+    "${arkui_x_c_utils_path}/base:utilsbase",
+    "${arkui_x_hilog_path}/interfaces/native/innerkits:libhilog_${target_os}",
+    "${arkui_x_plugin_path}/libs/napi:napi_${target_os}",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "udmf"
+}
+
+ohos_source_set("arkui_x_udmf_data_napi") {
+  include_dirs = [
+    "${ability_runtime_cross_platform_path}/frameworks/js/napi/napi_common",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want",
+  ]
+
+  sources = [
+    "${udmf_framework_path}/jskitsimpl/common/napi_data_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_error_utils.cpp",
+    "${udmf_framework_path}/jskitsimpl/common/napi_queue.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/application_defined_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/audio_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/file_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/folder_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/html_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/image_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/link_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/plain_text_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/summary_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_appitem_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_form_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_pixelmap_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/system_defined_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/text_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_data_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_data_properties_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/unified_record_napi.cpp",
+    "${udmf_framework_path}/jskitsimpl/data/video_napi.cpp",
+  ]
+
+  public_configs = [
+    ":udmf_napi_config",
+    ":arkui_x_udmf_napi_config",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:want_params_config",
+  ]
+
+  deps = [
+    ":arkui_x_udmf_data_inner",
+    "${ability_runtime_cross_platform_path}/frameworks/js/napi/napi_common:napi_common",
+    "${ability_runtime_cross_platform_path}/interfaces/inner_api/want:cross_platform_want_params",
+    "${arkui_x_c_utils_path}/base:utilsbase",
+  ]
+
+  subsystem_name = "distributeddatamgr"
+  part_name = "udmf"
+}
diff --git a/udmf/adapter/arkui_x_udmf.gni b/udmf/adapter/arkui_x_udmf.gni
new file mode 100644
index 0000000000000000000000000000000000000000..e629b3a11a3dee32571716c526525a9e1cf4c94c
--- /dev/null
+++ b/udmf/adapter/arkui_x_udmf.gni
@@ -0,0 +1,31 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+ability_runtime_cross_platform_path =
+    "//foundation/appframework/ability/ability_runtime/cross_platform"
+
+arkui_x_c_utils_path = "//commonlibrary/c_utils"
+
+arkui_x_hilog_path = "//base/hiviewdfx/hilog"
+
+arkui_x_plugin_path = "//plugins"
+
+arkui_x_multimedia_path = "//foundation/multimedia"
+
+arkui_x_image_framework_path = "${arkui_x_multimedia_path}/image_framework"
+
+arkui_x_graphic_root_path = "//foundation/graphic"
+
+arkui_x_graphic_2d_path = "${arkui_x_graphic_root_path}/graphic_2d"
+
+arkui_x_graphic_surface_path = "${arkui_x_graphic_root_path}/graphic_surface"
diff --git a/udmf/adapter/framework/innerkitsimpl/client/concurrent_map.h b/udmf/adapter/framework/innerkitsimpl/client/concurrent_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..68bd0943ba8e59c7916160947802963dc9a45464
--- /dev/null
+++ b/udmf/adapter/framework/innerkitsimpl/client/concurrent_map.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_UDMF_ADAPTER_FRAMEWORK_INNERKITSIMPL_CLIENT_CONCURRENT_MAP_H
+#define OHOS_UDMF_ADAPTER_FRAMEWORK_INNERKITSIMPL_CLIENT_CONCURRENT_MAP_H
+
+namespace OHOS {
+template<typename _Key, typename _Tp>
+class ConcurrentMap {
+public:
+    ConcurrentMap() = default;
+    ~ConcurrentMap() = default;
+};
+} // namespace OHOS
+#endif // OHOS_UDMF_ADAPTER_FRAMEWORK_INNERKITSIMPL_CLIENT_CONCURRENT_MAP_H
diff --git a/udmf/adapter/framework/innerkitsimpl/client/udmf_client.cpp b/udmf/adapter/framework/innerkitsimpl/client/udmf_client.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5984148f98da29544adbf79a28c6781707526608
--- /dev/null
+++ b/udmf/adapter/framework/innerkitsimpl/client/udmf_client.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "udmf_client.h"
+
+namespace OHOS {
+namespace UDMF {
+UdmfClient &UdmfClient::GetInstance()
+{
+    static UdmfClient instance;
+    return instance;
+}
+
+Status UdmfClient::SetData(CustomOption &option, UnifiedData &unifiedData, std::string &key)
+{
+    return E_OK;
+}
+
+Status UdmfClient::GetData(const QueryOption &query, UnifiedData &unifiedData)
+{
+    return E_OK;
+}
+
+Status UdmfClient::GetBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
+{
+    return E_OK;
+}
+
+Status UdmfClient::UpdateData(const QueryOption &query, UnifiedData &unifiedData)
+{
+    return E_OK;
+}
+
+Status UdmfClient::DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
+{
+    return E_OK;
+}
+
+Status UdmfClient::GetSummary(const QueryOption &query, Summary &summary)
+{
+    return E_OK;
+}
+
+Status UdmfClient::AddPrivilege(const QueryOption &query, Privilege &privilege)
+{
+    return E_OK;
+}
+
+Status UdmfClient::Sync(const QueryOption &query, const std::vector<std::string> &devices)
+{
+    return E_OK;
+}
+
+Status UdmfClient::IsRemoteData(const QueryOption &query, bool &result)
+{
+    return E_OK;
+}
+
+Status UdmfClient::SetAppShareOption(const std::string &intention, enum ShareOptions shareOption)
+{
+    return E_OK;
+}
+
+Status UdmfClient::GetAppShareOption(const std::string &intention, enum ShareOptions &shareOption)
+{
+    return E_OK;
+}
+
+
+Status UdmfClient::RemoveAppShareOption(const std::string &intention)
+{
+    return E_OK;
+}
+
+std::string UdmfClient::GetSelfBundleName()
+{
+    return std::string("");
+}
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/adapter/framework/innerkitsimpl/client/utd_client.cpp b/udmf/adapter/framework/innerkitsimpl/client/utd_client.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec365eed0abfceffc8d500eb26593533edd3dbe8
--- /dev/null
+++ b/udmf/adapter/framework/innerkitsimpl/client/utd_client.cpp
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "utd_client.h"
+namespace OHOS {
+namespace UDMF {
+UtdClient::UtdClient()
+{
+    Init();
+}
+
+UtdClient::~UtdClient()
+{
+}
+
+UtdClient &UtdClient::GetInstance()
+{
+    static auto instance = new UtdClient();
+    return *instance;
+}
+
+void UtdClient::Init()
+{
+}
+
+Status UtdClient::GetTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor)
+{
+    return Status::E_OK;
+}
+
+bool UtdClient::IsValidFileExtension(const std::string &fileExtension)
+{
+    return true;
+}
+
+bool UtdClient::IsValidMimeType(const std::string &mimeType)
+{
+    return true;
+}
+
+Status UtdClient::GetFlexibleTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor)
+{
+    return Status::E_OK;
+}
+
+Status UtdClient::GetUniformDataTypeByFilenameExtension(const std::string &fileExtension, std::string &typeId,
+    std::string belongsTo)
+{
+    return Status::E_OK;
+}
+
+Status UtdClient::GetUniformDataTypeByMIMEType(const std::string &mimeType, std::string &typeId,
+    std::string belongsTo)
+{
+    return Status::E_OK;
+}
+
+Status UtdClient::IsUtd(std::string typeId, bool &result)
+{
+    return Status::E_OK;
+}
+} // namespace UDMF
+} // namespace OHOS
diff --git a/udmf/bundle.json b/udmf/bundle.json
index 69f4b376af76846f8927a5875bd278004dfe3f4e..7f91324869212c0a834caebf27069799a7edfb2a 100644
--- a/udmf/bundle.json
+++ b/udmf/bundle.json
@@ -30,6 +30,7 @@
         "bundle_framework",
         "cJSON",
         "c_utils",
+        "common_event_service",
         "hilog",
         "hisysevent",
         "hitrace",
@@ -39,6 +40,7 @@
         "napi",
         "samgr",
         "app_file_service",
+        "os_account",
         "selinux_adapter"
       ],
       "third_party": [
@@ -50,6 +52,19 @@
         "//foundation/distributeddatamgr/udmf:udmf_packages"
       ],
       "inner_kits": [
+        {
+          "name": "//foundation/distributeddatamgr/udmf/interfaces/ndk:libudmf",
+          "header": {
+            "header_files": [
+              "udmf_meta.h",
+              "uds.h",
+              "utd.h",
+              "udmf.h",
+              "udmf_err_code.h"
+            ],
+            "header_base":"//foundation/distributeddatamgr/udmf/interfaces/ndk/data"
+          }
+        },
         {
           "name": "//foundation/distributeddatamgr/udmf/interfaces/innerkits:udmf_client",
           "header": {
@@ -98,6 +113,15 @@
             "header_base":"//foundation/distributeddatamgr/udmf/interfaces/innerkits/data"
           }
         },
+        {
+          "name": "//foundation/distributeddatamgr/udmf/interfaces/innerkits:udmf_client",
+          "header": {
+            "header_files": [
+              "ndk_data_conversion.h"
+            ],
+            "header_base":"//foundation/distributeddatamgr/udmf/interfaces/innerkits/convert"
+          }
+        },
         {
           "name": "//foundation/distributeddatamgr/udmf/interfaces/jskits:udmf_data_napi",
           "header": {
diff --git a/udmf/framework/common/base32_utils.cpp b/udmf/framework/common/base32_utils.cpp
index 890866731b5f01984000c261b8ae7e372a97c42d..d41d1703c3393585edb869bdb567dbe997f41e05 100644
--- a/udmf/framework/common/base32_utils.cpp
+++ b/udmf/framework/common/base32_utils.cpp
@@ -15,8 +15,6 @@
 
 #include "base32_utils.h"
 
-#include <string>
-
 namespace OHOS {
 namespace UDMF {
 static char BASE32_CHARS[33] = "abcdefghijklmnopqrstuvwxyz234567";
diff --git a/udmf/framework/common/custom_utd_json_parser.cpp b/udmf/framework/common/custom_utd_json_parser.cpp
index b492f41c5b6ea894246ec55cb392c14945eaeb10..91285e4c26e3ea01b85a908d024becbb4053fa5c 100644
--- a/udmf/framework/common/custom_utd_json_parser.cpp
+++ b/udmf/framework/common/custom_utd_json_parser.cpp
@@ -14,9 +14,6 @@
  */
 #define LOG_TAG "CustomUtdJsonParser"
 #include "custom_utd_json_parser.h"
-#include <fstream>
-#include <cJSON.h>
-#include "error_code.h"
 #include "logger.h"
 namespace OHOS {
 namespace UDMF {
diff --git a/udmf/framework/common/endian_converter.cpp b/udmf/framework/common/endian_converter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5c127b0cecf42da53e2b8f65f78342f51376c54d
--- /dev/null
+++ b/udmf/framework/common/endian_converter.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "EndianConverter"
+#include "endian_converter.h"
+
+#include "error_code.h"
+#include "logger.h"
+#include "securec.h"
+
+namespace OHOS {
+namespace UDMF {
+float HostToNet(float value)
+{
+    uint32_t temp;
+    auto err = memcpy_s(&temp, sizeof(temp), &value, sizeof(temp));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    temp = htole32(temp);
+    err = memcpy_s(&value, sizeof(value), &temp, sizeof(value));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    return value;
+}
+
+float NetToHost(float value)
+{
+    uint32_t temp;
+    auto err = memcpy_s(&temp, sizeof(temp), &value, sizeof(temp));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    temp = le32toh(temp);
+    err = memcpy_s(&value, sizeof(value), &temp, sizeof(value));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    return value;
+}
+
+double HostToNet(double value)
+{
+    uint64_t temp;
+    auto err = memcpy_s(&temp, sizeof(temp), &value, sizeof(temp));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    temp = htole64(temp);
+    err = memcpy_s(&value, sizeof(value), &temp, sizeof(value));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    return value;
+}
+
+double NetToHost(double value)
+{
+    uint64_t temp;
+    auto err = memcpy_s(&temp, sizeof(temp), &value, sizeof(temp));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    temp = le64toh(temp);
+    err = memcpy_s(&value, sizeof(value), &temp, sizeof(value));
+    if (err != E_OK) {
+        LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s error: %{public}d", err);
+    }
+    return value;
+}
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/common/endian_converter.h b/udmf/framework/common/endian_converter.h
index 5101b9d921ae257657d587b453fa586f3bf18896..9224b6c8e066a2cafb2b0e4eb3acc6492fb066e6 100644
--- a/udmf/framework/common/endian_converter.h
+++ b/udmf/framework/common/endian_converter.h
@@ -99,25 +99,13 @@ static inline uint64_t NetToHost(uint64_t value)
     return le64toh(value);
 }
 
-static inline float HostToNet(float value)
-{
-    return htole32(*reinterpret_cast<uint32_t*>(&value));
-}
+float HostToNet(float value);
 
-static inline float NetToHost(float value)
-{
-    return le32toh(*reinterpret_cast<uint32_t*>(&value));
-}
+float NetToHost(float value);
 
-static inline double HostToNet(double value)
-{
-    return htole64(*reinterpret_cast<uint64_t*>(&value));
-}
+double HostToNet(double value);
 
-static inline double NetToHost(double value)
-{
-    return le64toh(*reinterpret_cast<uint64_t*>(&value));
-}
+double NetToHost(double value);
 } // namespace UDMF
 } // namespace OHOS
 #endif // UDMF_ENDIAN_CONVERTER_H
diff --git a/udmf/framework/common/graph.cpp b/udmf/framework/common/graph.cpp
index 9c588411182fc36588bdc61aac69177c8665f4e3..8d34a8b5dabf3e7d62878d29484f444e996b4668 100644
--- a/udmf/framework/common/graph.cpp
+++ b/udmf/framework/common/graph.cpp
@@ -24,6 +24,18 @@ Graph::Graph(uint32_t vertexNum):vertexNum_(vertexNum)
     fill(visited_.begin(), visited_.end(), 0);
 }
 
+Graph::~Graph()
+{
+    for (auto &vertexNode : adjList_) {
+        EdgeNode *edge = vertexNode.firstEdge;
+        while (edge != nullptr) {
+            EdgeNode *nextEdge = edge->next;
+            delete edge;
+            edge = nextEdge;
+        }
+    }
+}
+
 void Graph::AddEdge(uint32_t start, uint32_t end)
 {
     EdgeNode *edge = new EdgeNode;  // add new edge
diff --git a/udmf/framework/common/graph.h b/udmf/framework/common/graph.h
index cdff7e238741e638a64a4611a404d2960c963250..f6b9e2b9b3d02bbb887527c58e43f8d4b0f16541 100644
--- a/udmf/framework/common/graph.h
+++ b/udmf/framework/common/graph.h
@@ -36,6 +36,7 @@ struct VertexNode {
 class Graph {
 public:
     explicit Graph(uint32_t vertexNum);
+    ~Graph();
     using Action = std::function<bool(uint32_t node)>;
     void AddEdge(uint32_t start, uint32_t end);
     bool Dfs(uint32_t startNode, Action action, bool isInit = true);
diff --git a/udmf/framework/common/logger.h b/udmf/framework/common/logger.h
index 19f4d7e68024f6e0d4e0bccd51f8c9c6b30c94c9..acf5b67a8eaaf688c7efa061969a4affe0957d6d 100644
--- a/udmf/framework/common/logger.h
+++ b/udmf/framework/common/logger.h
@@ -28,6 +28,7 @@ enum UdmfSubModule {
     UDMF_KITS_NAPI,     // for udmf napi kits module
     UDMF_CLIENT,        // for udmf client module
     UDMF_SERVICE,       // for udmf service module
+    UDMF_CAPI,          // for udmf capi module
     UDMF_TEST,          // for udmf test module
 };
 
diff --git a/udmf/framework/common/tlv_object.cpp b/udmf/framework/common/tlv_object.cpp
index f3adc1689e8eac2605f954b2c81e328d7de15765..b49a8c6410a8d3e8f7384986f472b667b8719530 100644
--- a/udmf/framework/common/tlv_object.cpp
+++ b/udmf/framework/common/tlv_object.cpp
@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
+#define LOG_TAG "TlvObject"
 #include "tlv_object.h"
-#include <string>
-#include <map>
+#include "logger.h"
 
 namespace OHOS {
 namespace UDMF {
@@ -123,6 +123,67 @@ void TLVObject::Count(const UDVariant &value)
     total_ += sizeof(TLVHead);
 }
 
+void TLVObject::Count(const ValueType &value)
+{
+    total_ += sizeof(TLVHead);
+    auto int32Value = std::get_if<int32_t>(&value);
+    if (int32Value != nullptr) {
+        Count(std::get<int32_t>(value));
+        return;
+    }
+    auto int64Value = std::get_if<int64_t>(&value);
+    if (int64Value != nullptr) {
+        Count(std::get<int64_t>(value));
+        return;
+    }
+    auto boolValue = std::get_if<bool>(&value);
+    if (boolValue != nullptr) {
+        Count(std::get<bool>(value));
+        return;
+    }
+    auto doubleValue = std::get_if<double>(&value);
+    if (doubleValue != nullptr) {
+        Count(std::get<double>(value));
+        return;
+    }
+    auto strValue = std::get_if<std::string>(&value);
+    if (strValue != nullptr) {
+        Count(std::get<std::string>(value));
+        return;
+    }
+    auto vecValue = std::get_if<std::vector<uint8_t>>(&value);
+    if (vecValue != nullptr) {
+        Count(std::get<std::vector<uint8_t>>(value));
+        return;
+    }
+    auto wantValue = std::get_if<std::shared_ptr<OHOS::AAFwk::Want>>(&value);
+    if (wantValue != nullptr) {
+        Count(std::get<std::shared_ptr<OHOS::AAFwk::Want>>(value));
+        return;
+    }
+    auto pixelMapValue = std::get_if<std::shared_ptr<OHOS::Media::PixelMap>>(&value);
+    if (pixelMapValue != nullptr) {
+        Count(std::get<std::shared_ptr<OHOS::Media::PixelMap>>(value));
+        return;
+    }
+    auto objectValue = std::get_if<std::shared_ptr<Object>>(&value);
+    if (objectValue != nullptr) {
+        Count(std::get<std::shared_ptr<Object>>(value));
+        return;
+    }
+    auto undefinedValue = std::get_if<std::monostate>(&value);
+    if (undefinedValue != nullptr) {
+        Count(std::get<std::monostate>(value));
+        return;
+    }
+    auto nullValue = std::get_if<nullptr_t>(&value);
+    if (nullValue != nullptr) {
+        Count(std::get<nullptr_t>(value));
+        return;
+    }
+    total_ += sizeof(TLVHead);
+}
+
 void TLVObject::Count(const UDDetails &value)
 {
     for (auto &item : value) {
@@ -147,6 +208,49 @@ void TLVObject::Count(const Privilege &value)
     Count(value.writePermission);
 }
 
+void TLVObject::Count(const std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+    std::size_t expectSize = sizeof(TLVHead);
+    Parcel parcel;
+    if (!value->Marshalling(parcel)) {
+        LOG_ERROR(TlvObject, "Marshalling Want failed.");
+        return;
+    }
+    expectSize += parcel.GetDataSize();
+    total_ += expectSize;
+}
+
+void TLVObject::Count(const std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+    std::size_t expectSize = sizeof(TLVHead);
+    std::vector<std::uint8_t> val;
+    if (!value->EncodeTlv(val)) {
+        LOG_ERROR(TlvObject, "Marshalling PixelMap failed.");
+        return;
+    }
+    expectSize += val.size();
+    total_ += expectSize;
+}
+
+void TLVObject::Count(const std::shared_ptr<Object> &value)
+{
+    for (auto &item : value->value_) {
+        Count(item.first);
+        Count(item.second);
+    }
+    total_ += sizeof(TLVHead);
+}
+
+void TLVObject::Count(const std::monostate &value)
+{
+    total_ += sizeof(TLVHead);
+}
+
+void TLVObject::Count(const void *value)
+{
+    total_ += sizeof(TLVHead);
+}
+
 bool TLVObject::WriteString(const std::string &value)
 {
     PrepareBuffer(sizeof(TLVHead) + value.size());
@@ -298,7 +402,9 @@ bool TLVObject::WriteVariant(const UDVariant &value)
     if (!WriteVariantInner(tag, value)) {
         return false;
     }
-    PrepareHeader(cursor_, tagCursor, valueCursor);
+    if (!PrepareHeader(cursor_, tagCursor, valueCursor)) {
+        return false;
+    }
     WriteHead(static_cast<uint16_t>(tag), tagCursor, cursor_ - valueCursor);
     if (!SaveBufferToFile()) {
         return false;
@@ -398,6 +504,227 @@ bool TLVObject::ReadVariant(UDVariant &value)
     return true;
 }
 
+bool TLVObject::WriteVariantInner(TAG &tag, const ValueType &value)
+{
+    if (std::get_if<int32_t>(&value) != nullptr) {
+        if (!WriteBasic(TAG::TAG_INT32, std::get<int32_t>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_INT32;
+    } else if (std::get_if<int64_t>(&value) != nullptr) {
+        if (!WriteBasic(TAG::TAG_INT64, std::get<int64_t>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_INT64;
+    } else if (std::get_if<bool>(&value) != nullptr) {
+        if (!WriteBasic(TAG::TAG_BOOL, std::get<bool>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_BOOL;
+    } else if (std::get_if<double>(&value) != nullptr) {
+        if (!WriteBasic(TAG::TAG_DOUBLE, std::get<double>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_DOUBLE;
+    } else if (std::get_if<std::string>(&value) != nullptr) {
+        if (!WriteString(std::get<std::string>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_STRING;
+    } else if (std::get_if<std::vector<uint8_t>>(&value) != nullptr) {
+        if (!WriteVector(std::get<std::vector<uint8_t>>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_VECTOR;
+    } else if (std::get_if<std::shared_ptr<OHOS::AAFwk::Want>>(&value) != nullptr) {
+        if (!WriteWant(std::get<std::shared_ptr<OHOS::AAFwk::Want>>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_WANT;
+    } else if (std::get_if<std::shared_ptr<OHOS::Media::PixelMap>>(&value) != nullptr) {
+        if (!WritePixelMap(std::get<std::shared_ptr<OHOS::Media::PixelMap>>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_PIXELMAP;
+    } else if (std::get_if<std::shared_ptr<Object>>(&value) != nullptr) {
+        if (!WriteObject(std::get<std::shared_ptr<Object>>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_OBJECT;
+    } else if (std::get_if<std::monostate>(&value) != nullptr) {
+        if (!WriteUndefined(std::get<std::monostate>(value))) {
+            return false;
+        }
+        tag = TAG::TAG_UNDEFINED;
+    } else if (std::get_if<nullptr_t>(&value) != nullptr) {
+        if (!WriteNull(nullptr)) {
+            return false;
+        }
+        tag = TAG::TAG_NULL;
+    }
+    return true;
+}
+
+bool TLVObject::WriteVariant(const ValueType &value)
+{
+    if (!HasExpectBuffer(sizeof(TLVHead))) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        std::vector<uint8_t> reserved {};
+        reserved.resize(sizeof(TLVHead));
+        if (fwrite(reserved.data(), sizeof(uint8_t), reserved.size(), file_) != reserved.size()) {
+            return false;
+        }
+    }
+    auto tagCursor = cursor_;
+    cursor_ += sizeof(TLVHead);
+    auto valueCursor = cursor_;
+    TAG tag = TAG::TAG_BUTT;
+    if (!WriteVariantInner(tag, value)) {
+        return false;
+    }
+    if (!PrepareHeader(cursor_, tagCursor, valueCursor)) {
+        return false;
+    }
+    WriteHead(static_cast<uint16_t>(tag), tagCursor, cursor_ - valueCursor);
+    if (!SaveBufferToFile()) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        fseek(file_, 0, SEEK_END);
+        cursor_ += sizeof(TLVHead);
+    }
+    return true;
+}
+
+bool TLVObject::ReadVariantInner(uint16_t tag, ValueType &value)
+{
+    switch (tag) {
+        case static_cast<uint16_t>(TAG::TAG_INT32): {
+            int32_t int32Value;
+            if (!ReadBasic(int32Value)) {
+                return false;
+            }
+            value.emplace<int32_t>(int32Value);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_INT64): {
+            int64_t int64Value;
+            if (!ReadBasic(int64Value)) {
+                return false;
+            }
+            value.emplace<int64_t>(int64Value);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_BOOL): {
+            bool boolValue;
+            if (!ReadBasic(boolValue)) {
+                return false;
+            }
+            value.emplace<bool>(boolValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_DOUBLE): {
+            double doubleValue;
+            if (!ReadBasic(doubleValue)) {
+                return false;
+            }
+            value.emplace<double>(doubleValue);
+            break;
+        }
+        default: {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool TLVObject::ReadVariant(ValueType &value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    switch (head.tag) {
+        case static_cast<uint16_t>(TAG::TAG_INT32):
+        case static_cast<uint16_t>(TAG::TAG_INT64):
+        case static_cast<uint16_t>(TAG::TAG_BOOL):
+        case static_cast<uint16_t>(TAG::TAG_DOUBLE): {
+            if (!ReadVariantInner(head.tag, value)) {
+                return false;
+            }
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_STRING): {
+            std::string stringValue;
+            if (!ReadString(stringValue)) {
+                return false;
+            }
+            value.emplace<std::string>(stringValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_VECTOR): {
+            std::vector<uint8_t> vectorValue;
+            if (!ReadVector(vectorValue)) {
+                return false;
+            }
+            value.emplace<std::vector<uint8_t>>(vectorValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_WANT): {
+            std::shared_ptr<OHOS::AAFwk::Want> wantValue = nullptr;
+            if (!ReadWant(wantValue)) {
+                return false;
+            }
+            value.emplace<std::shared_ptr<OHOS::AAFwk::Want>>(wantValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_PIXELMAP): {
+            std::shared_ptr<OHOS::Media::PixelMap> pixelMapValue = nullptr;
+            if (!ReadPixelMap(pixelMapValue)) {
+                return false;
+            }
+            value.emplace<std::shared_ptr<OHOS::Media::PixelMap>>(pixelMapValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_OBJECT): {
+            std::shared_ptr<Object> objectValue = nullptr;
+            if (!ReadObject(objectValue)) {
+                return false;
+            }
+            value.emplace<std::shared_ptr<Object>>(objectValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_UNDEFINED): {
+            std::monostate monoValue;
+            if (!ReadUndefined(monoValue)) {
+                return false;
+            }
+            value.emplace<std::monostate>(monoValue);
+            break;
+        }
+        case static_cast<uint16_t>(TAG::TAG_NULL): {
+            nullptr_t nullValue = nullptr;
+            if (!ReadNull(nullValue)) {
+                return false;
+            }
+            value.emplace<nullptr_t>(nullValue);
+            break;
+        }
+        default: {
+            return false;
+        }
+    }
+    if (file_ != nullptr) {
+        cursor_ += sizeof(TLVHead);
+    }
+    return true;
+}
+
 bool TLVObject::WriteMap(const UDDetails &value)
 {
     if (!HasExpectBuffer(sizeof(TLVHead))) {
@@ -427,7 +754,9 @@ bool TLVObject::WriteMap(const UDDetails &value)
         }
         total += cursor_;
     }
-    PrepareHeader(total, tagCursor, valueCursor);
+    if (!PrepareHeader(total, tagCursor, valueCursor)) {
+        return false;
+    }
     WriteHead(static_cast<uint16_t>(TAG::TAG_MAP), tagCursor, cursor_ - valueCursor);
     if (!SaveBufferToFile()) {
         return false;
@@ -468,6 +797,260 @@ bool TLVObject::ReadMap(UDDetails &value)
     return true;
 }
 
+bool TLVObject::WriteObject(const std::shared_ptr<Object> &value)
+{
+    if (!HasExpectBuffer(sizeof(TLVHead))) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        std::vector<uint8_t> reserved {};
+        reserved.resize(sizeof(TLVHead));
+        if (fwrite(reserved.data(), sizeof(uint8_t), reserved.size(), file_) != reserved.size()) {
+            return false;
+        }
+    }
+
+    auto tagCursor = cursor_;
+    cursor_ += sizeof(TLVHead);
+    auto valueCursor = cursor_;
+
+    size_t total = 0;
+    for (const auto &item : value->value_) {
+        if (!WriteString(item.first)) {
+            return false;
+        }
+        total += cursor_;
+
+        if (!WriteVariant(item.second)) {
+            return false;
+        }
+        total += cursor_;
+    }
+    if (!PrepareHeader(total, tagCursor, valueCursor)) {
+        return false;
+    }
+    WriteHead(static_cast<uint16_t>(TAG::TAG_OBJECT), tagCursor, cursor_ - valueCursor);
+    if (!SaveBufferToFile()) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        fseek(file_, 0, SEEK_END);
+    }
+    return true;
+}
+
+bool TLVObject::ReadObject(std::shared_ptr<Object> &value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        cursor_ = 0;
+    }
+    value = std::make_shared<Object>();
+    auto mapEnd = cursor_ + head.len;
+    size_t total = 0;
+    while ((file_ == nullptr && cursor_ < mapEnd) || (file_ != nullptr && total < head.len)) {
+        std::string itemKey = "";
+        if (!ReadString(itemKey)) {
+            return false;
+        }
+        total += cursor_;
+        ValueType itemValue;
+        if (!ReadVariant(itemValue)) {
+            return false;
+        }
+        total += cursor_;
+        value->value_.emplace(itemKey, itemValue);
+    }
+    return true;
+}
+
+bool TLVObject::WriteWant(const std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+    Parcel parcel;
+    if (!value->Marshalling(parcel)) {
+        LOG_ERROR(TlvObject, "Marshalling Want failed.");
+        return false;
+    }
+    auto size = parcel.GetDataSize();
+    auto buffer = parcel.GetData();
+
+    PrepareBuffer(sizeof(TLVHead) + size);
+    if (!HasExpectBuffer(sizeof(TLVHead) + size)) {
+        return false;
+    }
+    WriteHead(static_cast<uint16_t>(TAG::TAG_WANT), cursor_, size);
+    cursor_ += sizeof(TLVHead);
+
+    if (size != 0) {
+        auto err = memcpy_s(buffer_->data() + cursor_, buffer_->size() - cursor_,
+            reinterpret_cast<const void *>(buffer), size);
+        if (err != EOK) {
+            return false;
+        }
+    }
+    if (SaveBufferToFile()) {
+        return false;
+    }
+    cursor_ += size;
+    return true;
+}
+
+bool TLVObject::ReadWant(std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    if (!LoadBufferFormFile(head.len)) {
+        return false;
+    }
+    std::vector<uint8_t> buff(buffer_->data() + cursor_, buffer_->data() + cursor_ + head.len);
+
+    auto buffer = (uintptr_t)(buff.data() + cursor_);
+    cursor_ += head.len;
+    if (file_ != nullptr) {
+        cursor_ += sizeof(TLVHead);
+    }
+
+    Parcel parcel;
+    if (!parcel.ParseFrom(buffer, head.len)) {
+        return false;
+    }
+    auto want = AAFwk::Want::Unmarshalling(parcel);
+    if (want == nullptr) {
+        return false;
+    }
+    value = std::make_shared<OHOS::AAFwk::Want>(*want);
+    return true;
+}
+
+bool TLVObject::WritePixelMap(const std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+    std::vector<std::uint8_t> val;
+    if (!value->EncodeTlv(val)) {
+        return false;
+    }
+
+    PrepareBuffer(sizeof(TLVHead) + val.size());
+    if (!HasExpectBuffer(sizeof(TLVHead) + val.size())) {
+        return false;
+    }
+    WriteHead(static_cast<uint16_t>(TAG::TAG_PIXELMAP), cursor_, val.size());
+    cursor_ += sizeof(TLVHead);
+
+    if (!val.empty()) {
+        auto err = memcpy_s(buffer_->data() + cursor_, buffer_->size() - cursor_, val.data(), val.size());
+        if (err != EOK) {
+            return false;
+        }
+    }
+    if (!SaveBufferToFile()) {
+        return false;
+    }
+    cursor_ += val.size();
+    return true;
+}
+
+bool TLVObject::ReadPixelMap(std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    if (!LoadBufferFormFile(head.len)) {
+        return false;
+    }
+    std::vector<uint8_t> buff(buffer_->data() + cursor_, buffer_->data() + cursor_ + head.len);
+    value = std::shared_ptr<OHOS::Media::PixelMap>(OHOS::Media::PixelMap::DecodeTlv(buff));
+
+    cursor_ += head.len;
+    if (file_ != nullptr) {
+        cursor_ += sizeof(TLVHead);
+    }
+    return true;
+}
+
+bool TLVObject::WriteUndefined(const std::monostate &value)
+{
+    PrepareBuffer(sizeof(TLVHead));
+    if (!HasExpectBuffer(sizeof(TLVHead))) {
+        return false;
+    }
+    auto *tlvHead = reinterpret_cast<TLVHead *>(buffer_->data() + cursor_);
+    tlvHead->tag = HostToNet(static_cast<uint16_t>(TAG::TAG_UNDEFINED));
+    tlvHead->len = HostToNet((uint32_t)0);
+    if (!SaveBufferToFile()) {
+        return false;
+    }
+    cursor_ += sizeof(TLVHead);
+    return true;
+}
+
+bool TLVObject::ReadUndefined(std::monostate &value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    if (!LoadBufferFormFile(head.len)) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        cursor_ += sizeof(TLVHead);
+    }
+    return true;
+}
+
+bool TLVObject::WriteNull(const void *value)
+{
+    PrepareBuffer(sizeof(TLVHead));
+    if (!HasExpectBuffer(sizeof(TLVHead))) {
+        return false;
+    }
+    auto *tlvHead = reinterpret_cast<TLVHead *>(buffer_->data() + cursor_);
+    tlvHead->tag = HostToNet(static_cast<uint16_t>(TAG::TAG_NULL));
+    tlvHead->len = HostToNet((uint32_t)0);
+    if (!SaveBufferToFile()) {
+        return false;
+    }
+    cursor_ += sizeof(TLVHead);
+    return true;
+}
+
+bool TLVObject::ReadNull(void *value)
+{
+    TLVHead head {};
+    if (!ReadHead(head)) {
+        return false;
+    }
+    if (!HasExpectBuffer(head.len)) {
+        return false;
+    }
+    if (!LoadBufferFormFile(head.len)) {
+        return false;
+    }
+    if (file_ != nullptr) {
+        cursor_ += sizeof(TLVHead);
+    }
+    value = nullptr;
+    return true;
+}
+
 bool TLVObject::ReadHead(TLVHead &head)
 {
     if (!LoadBufferFormFile(sizeof(TLVHead))) {
@@ -505,15 +1088,26 @@ bool TLVObject::HasExpectBuffer(const uint32_t expectLen) const
     return buffer_->size() >= cursor_ && buffer_->size() - cursor_ >= expectLen;
 }
 
-void TLVObject::PrepareHeader(size_t size, size_t &tagCursor, size_t &valueCursor)
+bool TLVObject::PrepareHeader(size_t size, size_t &tagCursor, size_t &valueCursor)
 {
     if (file_ != nullptr) {
         cursor_ = size;
-        fseek(file_, -static_cast<long long>(cursor_) - sizeof(TLVHead), SEEK_CUR);
+        if (cursor_ > static_cast<size_t>(std::numeric_limits<long>::max()) ||
+            sizeof(TLVHead) > static_cast<size_t>(std::numeric_limits<long>::max()) ||
+            cursor_ > static_cast<size_t>(std::numeric_limits<long>::max()) - sizeof(TLVHead)) {
+            LOG_ERROR(TlvObject, "Values are out of range, cursor_:%{public}zu, TLVHead:%{public}zu",
+                cursor_, sizeof(TLVHead));
+            return false;
+        }
+        if (fseek(file_, -static_cast<long>(cursor_) - static_cast<long>(sizeof(TLVHead)), SEEK_CUR) != 0) {
+            LOG_ERROR(TlvObject, "fseek failed, error: %{public}d", errno);
+            return false;
+        }
         buffer_->resize(sizeof(TLVHead));
         tagCursor  = 0;
         valueCursor = 0;
     }
+    return true;
 }
 
 void TLVObject::PrepareBuffer(size_t size)
diff --git a/udmf/framework/common/tlv_object.h b/udmf/framework/common/tlv_object.h
index c4f83b477665670a93a3bfadd50a021ca6ebb76d..ca27d12876ef23519b22d36cf13170d13e863f07 100644
--- a/udmf/framework/common/tlv_object.h
+++ b/udmf/framework/common/tlv_object.h
@@ -35,6 +35,11 @@ enum class TAG {
     TAG_STRING,
     TAG_VECTOR,
     TAG_MAP,
+    TAG_WANT,
+    TAG_PIXELMAP,
+    TAG_OBJECT,
+    TAG_NULL,
+    TAG_UNDEFINED,
     TAG_BUTT,
 };
 
@@ -63,9 +68,16 @@ public:
     void Count(const std::string &value);
     void Count(const std::vector<uint8_t> &value);
     void Count(const UDVariant &value);
+    void Count(const ValueType &value);
     void Count(const UDDetails &value);
     void Count(const UnifiedKey &value);
     void Count(const Privilege &value);
+    void Count(const std::shared_ptr<OHOS::AAFwk::Want> &value);
+    void Count(const std::shared_ptr<OHOS::Media::PixelMap> &value);
+    void Count(const std::shared_ptr<Object> &value);
+    void Count(const std::monostate &value);
+    void Count(const void *value);
+
     template<typename T> bool WriteBasic(TAG type, const T &value);
     template<typename T> bool ReadBasic(T &value);
     bool WriteString(const std::string &value);
@@ -74,16 +86,30 @@ public:
     bool ReadVector(std::vector<uint8_t> &value);
     bool WriteVariant(const UDVariant &value);
     bool ReadVariant(UDVariant &value);
+    bool WriteVariant(const ValueType &value);
+    bool ReadVariant(ValueType &value);
     bool WriteMap(const UDDetails &value);
     bool ReadMap(UDDetails &value);
+    bool WriteObject(const std::shared_ptr<Object> &value);
+    bool ReadObject(std::shared_ptr<Object> &value);
+    bool WriteWant(const std::shared_ptr<OHOS::AAFwk::Want> &value);
+    bool ReadWant(std::shared_ptr<OHOS::AAFwk::Want> &value);
+    bool WritePixelMap(const std::shared_ptr<OHOS::Media::PixelMap> &value);
+    bool ReadPixelMap(std::shared_ptr<OHOS::Media::PixelMap> &value);
+    bool WriteUndefined(const std::monostate &value);
+    bool ReadUndefined(std::monostate &value);
+    bool WriteNull(const void *value);
+    bool ReadNull(void *value);
 
 private:
     bool WriteVariantInner(TAG &tag, const UDVariant &value);
     bool ReadVariantInner(uint16_t tag, UDVariant &value);
+    bool WriteVariantInner(TAG &tag, const ValueType &value);
+    bool ReadVariantInner(uint16_t tag, ValueType &value);
     bool ReadHead(TLVHead &head);
     void WriteHead(uint16_t type, size_t tagCursor, uint32_t len);
     bool HasExpectBuffer(const uint32_t expectLen) const;
-    void PrepareHeader(size_t size, size_t &tagCursor, size_t &valueCursor);
+    bool PrepareHeader(size_t size, size_t &tagCursor, size_t &valueCursor);
     void PrepareBuffer(size_t size);
     bool SaveBufferToFile();
     bool LoadBufferFormFile(size_t size);
diff --git a/udmf/framework/common/tlv_util.cpp b/udmf/framework/common/tlv_util.cpp
index cc0dab625d7ee3d6a9beb60ef4f06f0e0b4715fa..c18433256fd97c465948dbdffe5bac721fe0ad6f 100644
--- a/udmf/framework/common/tlv_util.cpp
+++ b/udmf/framework/common/tlv_util.cpp
@@ -210,10 +210,18 @@ bool CountBufferSize(const std::shared_ptr<UnifiedRecord> &input, TLVObject &dat
             data.Count(record->GetRawData());
             break;
         }
+        case UDType::FILE_URI: {
+            if (input == nullptr) {
+                return false;
+            }
+            data.Count(input->GetValue());
+            break;
+        }
         default: {
             return false;
         }
     }
+    data.Count(input->GetOriginValue());
     return true;
 }
 
@@ -367,6 +375,18 @@ bool Reading(UDVariant &output, TLVObject &data)
     return data.ReadVariant(output);
 }
 
+template<>
+bool Writing(const ValueType &input, TLVObject &data)
+{
+    return data.WriteVariant(input);
+}
+
+template<>
+bool Reading(ValueType &output, TLVObject &data)
+{
+    return data.ReadVariant(output);
+}
+
 template<>
 bool Writing(const UDDetails &input, TLVObject &data)
 {
@@ -878,7 +898,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (text == nullptr) {
                 return false;
             }
-            return Writing(*text, data);
+            if (!Writing(*text, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::PLAIN_TEXT: {
             auto plainText = static_cast<PlainText *>(input.get());
@@ -892,7 +915,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (text == nullptr) {
                 return false;
             }
-            return Writing(*text, data);
+            if (!Writing(*text, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::HTML: {
             auto html = static_cast<Html *>(input.get());
@@ -906,7 +932,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (text == nullptr) {
                 return false;
             }
-            return Writing(*text, data);
+            if (!Writing(*text, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::HYPERLINK: {
             auto link = static_cast<Link *>(input.get());
@@ -920,14 +949,20 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (text == nullptr) {
                 return false;
             }
-            return Writing(*text, data);
+            if (!Writing(*text, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::FILE: {
             auto file = static_cast<File *>(input.get());
             if (file == nullptr) {
                 return false;
             }
-            return Writing(*file, data);
+            if (!Writing(*file, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::IMAGE: {
             auto image = static_cast<Image *>(input.get());
@@ -941,7 +976,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (file == nullptr) {
                 return false;
             }
-            return Writing(*file, data);
+            if (!Writing(*file, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::VIDEO: {
             auto video = static_cast<Video *>(input.get());
@@ -955,7 +993,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (file == nullptr) {
                 return false;
             }
-            return Writing(*file, data);
+            if (!Writing(*file, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::AUDIO: {
             auto audio = static_cast<Audio *>(input.get());
@@ -969,7 +1010,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (file == nullptr) {
                 return false;
             }
-            return Writing(*file, data);
+            if (!Writing(*file, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::FOLDER: {
             auto folder = static_cast<Folder *>(input.get());
@@ -983,14 +1027,20 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (file == nullptr) {
                 return false;
             }
-            return Writing(*file, data);
+            if (!Writing(*file, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::SYSTEM_DEFINED_RECORD: {
             auto sdRecord = static_cast<SystemDefinedRecord *>(input.get());
             if (sdRecord == nullptr) {
                 return false;
             }
-            return Writing(*sdRecord, data);
+            if (!Writing(*sdRecord, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::SYSTEM_DEFINED_FORM: {
             auto form = static_cast<SystemDefinedForm *>(input.get());
@@ -1004,7 +1054,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (sdRecord == nullptr) {
                 return false;
             }
-            return Writing(*sdRecord, data);
+            if (!Writing(*sdRecord, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::SYSTEM_DEFINED_APP_ITEM: {
             auto appItem = static_cast<SystemDefinedAppItem *>(input.get());
@@ -1018,7 +1071,10 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (sdRecord == nullptr) {
                 return false;
             }
-            return Writing(*sdRecord, data);
+            if (!Writing(*sdRecord, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::SYSTEM_DEFINED_PIXEL_MAP: {
             auto pixelMap = static_cast<SystemDefinedPixelMap *>(input.get());
@@ -1032,19 +1088,38 @@ bool Writing(const std::shared_ptr<UnifiedRecord> &input, TLVObject &data)
             if (sdRecord == nullptr) {
                 return false;
             }
-            return Writing(*sdRecord, data);
+            if (!Writing(*sdRecord, data)) {
+                return false;
+            }
+            break;
         }
         case UDType::APPLICATION_DEFINED_RECORD: {
             auto record = static_cast<ApplicationDefinedRecord *>(input.get());
             if (record == nullptr) {
                 return false;
             }
-            return Writing(*record, data);
+            if (!Writing(*record, data)) {
+                return false;
+            }
+            break;
+        }
+        case UDType::FILE_URI: {
+            if (input == nullptr) {
+                return false;
+            }
+            if (!Writing(input->GetValue(), data)) {
+                return false;
+            }
+            break;
         }
         default: {
             return false;
         }
     }
+    if (!Writing(input->GetOriginValue(), data)) {
+        return false;
+    }
+    return true;
 }
 
 template<>
@@ -1171,12 +1246,21 @@ bool Reading(std::shared_ptr<UnifiedRecord> &output, TLVObject &data)
             output = record;
             break;
         }
+        case UDType::FILE_URI: {
+            output = std::make_shared<UnifiedRecord>();
+            break;
+        }
         default: {
             return false;
         }
     }
+    ValueType value;
+    if (!Reading(value, data)) {
+        LOG_WARN(UDMF_CLIENT, "Reading value empty.");
+    }
     output->SetUid(uid);
     output->SetType(type);
+    output->SetValue(value);
     return true;
 }
 
diff --git a/udmf/framework/common/tlv_util.h b/udmf/framework/common/tlv_util.h
index 6767dfa9e1775a37f895ecda67b6d8ebce4a7af1..30b46ada635ae604c1e715e0d6ffc49b331b2a82 100644
--- a/udmf/framework/common/tlv_util.h
+++ b/udmf/framework/common/tlv_util.h
@@ -104,6 +104,11 @@ bool API_EXPORT Writing(const UDVariant &input, TLVObject &data);
 template<>
 bool API_EXPORT Reading(UDVariant &output, TLVObject &data);
 
+template<>
+bool API_EXPORT Writing(const ValueType &input, TLVObject &data);
+template<>
+bool API_EXPORT Reading(ValueType &output, TLVObject &data);
+
 template<>
 bool API_EXPORT Writing(const UDDetails &input, TLVObject &data);
 template<>
diff --git a/udmf/framework/common/udmf_radar_reporter.cpp b/udmf/framework/common/udmf_radar_reporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e93009b3fc8c89f0e889e517329a0feb8f746a7c
--- /dev/null
+++ b/udmf/framework/common/udmf_radar_reporter.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UdmfRadarReporter"
+
+#include "udmf_radar_reporter.h"
+
+namespace OHOS {
+namespace UDMF {
+using namespace RadarReporter;
+void RadarReporterAdapter::ReportNormal(const std::string &func, int32_t scene,
+                                        int32_t stage, int32_t stageRes, int32_t state)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "BIZ_STATE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = state },
+            .arraySize = 0 }
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporterAdapter::ReportFail(
+    const std::string &func, int32_t scene, int32_t stage, int32_t stageRes, int32_t errorCode, int32_t state)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "ERROR_CODE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "BIZ_STATE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = state },
+            .arraySize = 0 }
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+
+void RadarReporterAdapter::ReportFail(
+    const std::string &func, int32_t scene, int32_t stage, int32_t stageRes, int32_t errorCode)
+{
+    struct HiSysEventParam params[] = {
+        { .name = { "ORG_PKG" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(ORG_PKG) },
+            .arraySize = 0 },
+        { .name = { "FUNC" },
+            .t = HISYSEVENT_STRING,
+            .v = { .s = const_cast<char *>(func.c_str()) },
+            .arraySize = 0 },
+        { .name = { "BIZ_SCENE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = scene },
+            .arraySize = 0 },
+        { .name = { "BIZ_STAGE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stage },
+            .arraySize = 0 },
+        { .name = { "STAGE_RES" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = stageRes },
+            .arraySize = 0 },
+        { .name = { "ERROR_CODE" },
+            .t = HISYSEVENT_INT32,
+            .v = { .i32 = errorCode },
+            .arraySize = 0 }
+    };
+    OH_HiSysEvent_Write(
+        DOMAIN,
+        EVENT_NAME,
+        HISYSEVENT_BEHAVIOR,
+        params,
+        sizeof(params) / sizeof(params[0])
+    );
+}
+}
+}
diff --git a/udmf/framework/common/udmf_radar_reporter.h b/udmf/framework/common/udmf_radar_reporter.h
index 378f523f1fe9f86a56f3bf667a4df2e6417c2158..1a21c91a98f69a14d3aa763fdb8eeaa10b215302 100644
--- a/udmf/framework/common/udmf_radar_reporter.h
+++ b/udmf/framework/common/udmf_radar_reporter.h
@@ -16,68 +16,68 @@
 #ifndef UDMF_RADAR_REPORTER_H
 #define UDMF_RADAR_REPORTER_H
 
-#include "hisysevent.h"
+#include "hisysevent_c.h"
+#include "visibility.h"
+#include <string>
 
 namespace OHOS {
 namespace UDMF {
 namespace RadarReporter {
-enum BizScene : std::int32_t {
+enum BizScene : int32_t {
     SET_DATA = 1,
     SYNC_DATA = 2,
     GET_DATA = 3,
     UTD_REGISTER = 4
 };
 
-enum SetDataStage : std::int32_t {
+enum SetDataStage : int32_t {
     SET_DATA_BEGIN = 1,
     VERIFY_SHARE_PERMISSIONS = 2,
     GERERATE_DFS_URI = 3,
     SET_DATA_END = 4
 };
 
-enum SyncDataStage : std::int32_t {
+enum SyncDataStage : int32_t {
     SYNC_BEGIN = 1,
     SYNC_END = 2
 };
 
-enum GetDataStage : std::int32_t {
+enum GetDataStage : int32_t {
     GET_DATA_BEGIN = 1,
     VERIFY_PRIVILEGE = 2,
     GRANT_URI_PERMISSION = 3,
     GET_DATA_END = 4
 };
 
-enum UtdRegisterStage : std::int32_t {
+enum UtdRegisterStage : int32_t {
     UTD_REGISTER_BEGIN = 1,
     UTD_REGISTER_END = 2,
 };
 
-enum StageRes : std::int32_t {
+enum StageRes : int32_t {
     IDLE = 0,
     SUCCESS = 1,
     FAILED = 2,
     CANCELLED = 3
 };
-enum BizState : std::int32_t {
+
+enum BizState : int32_t {
     DFX_BEGIN = 0,
     DFX_NORMAL_END = 1,
     DFX_ABNORMAL_END = 2
 };
-
-const constexpr char BIZ_STATE[] = "BIZ_STATE";
-const constexpr char ERROR_CODE[] = "ERROR_CODE";
-} // namespace RadarReporter
-
 const constexpr char DOMAIN[] = "DISTDATAMGR";
 const constexpr char EVENT_NAME[] = "DISTRIBUTED_UDMF_BEHAVIOR";
-const constexpr HiviewDFX::HiSysEvent::EventType TYPE = HiviewDFX::HiSysEvent::EventType::BEHAVIOR;
 const constexpr char ORG_PKG[] = "distributeddata";
+} // namespace RadarReporter
 
-#define RADAR_REPORT(bizScene, bizStage, stageRes, ...)                                            \
-({                                                                                                 \
-    HiSysEventWrite(DOMAIN, EVENT_NAME, TYPE, "ORG_PKG", ORG_PKG, "FUNC", __FUNCTION__,            \
-        "BIZ_SCENE", bizScene, "BIZ_STAGE", bizStage, "STAGE_RES", stageRes, ##__VA_ARGS__);       \
-})
+class API_EXPORT RadarReporterAdapter {
+public:
+    static  void ReportNormal(const std::string &func, int32_t scene, int32_t stage, int32_t stageRes, int32_t state);
+    static  void ReportFail(
+        const std::string &func, int32_t scene, int32_t stage, int32_t stageRes, int32_t errorCode, int32_t state);
+    static  void ReportFail(const std::string &func, int32_t scene, int32_t stage, int32_t stageRes, int32_t errorCode);
+};
 } // namespace UDMF
 } // namespace OHOS
 #endif // UDMF_RADAR_REPORTER_H
\ No newline at end of file
diff --git a/udmf/framework/common/udmf_types_util.cpp b/udmf/framework/common/udmf_types_util.cpp
index 7573ebad72db2bdb1e52dc3c901be660e29df623..6e4de8bf9ea0fd51d26b5fda9846e5aa49925330 100644
--- a/udmf/framework/common/udmf_types_util.cpp
+++ b/udmf/framework/common/udmf_types_util.cpp
@@ -15,8 +15,6 @@
 #define LOG_TAG "UdmfTypesUtil"
 #include "udmf_types_util.h"
 
-#include <string>
-
 #include "logger.h"
 #include "tlv_util.h"
 
@@ -195,5 +193,34 @@ bool Unmarshalling(Intention &output, MessageParcel &parcel)
     output = static_cast<Intention>(intention);
     return true;
 }
+
+template<>
+bool API_EXPORT Marshalling(const AsyncProcessInfo &input, MessageParcel &parcel)
+{
+    uint32_t syncStatus = input.syncStatus;
+    uint32_t permStatus = input.permStatus;
+    return ITypesUtil::Marshal(parcel, syncStatus, permStatus, input.srcDevName, input.syncFinished, input.syncTotal,
+        input.syncId, input.permFnished, input.permTotal);
+}
+
+template<>
+bool API_EXPORT Unmarshalling(AsyncProcessInfo &output, MessageParcel &parcel)
+{
+    uint32_t syncStatus;
+    uint32_t permStatus;
+    if (!ITypesUtil::Unmarshal(parcel, syncStatus, permStatus, output.srcDevName, output.syncFinished, output.syncTotal,
+        output.syncId, output.permFnished, output.permTotal)) {
+        LOG_ERROR(UDMF_FRAMEWORK, "Unmarshal AsyncProcessInfo failed!");
+        return false;
+    }
+
+    if (syncStatus > ASYNC_FAILURE || permStatus > ASYNC_FAILURE) {
+        LOG_ERROR(UDMF_FRAMEWORK, "invalid SyncStatus!");
+        return false;
+    }
+    output.syncStatus = static_cast<AsyncTaskStatus>(syncStatus);
+    output.permStatus = static_cast<AsyncTaskStatus>(permStatus);
+    return true;
+}
 } // namespace ITypesUtil
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/common/udmf_types_util.h b/udmf/framework/common/udmf_types_util.h
index e2170d8b08dc87b69576e76dc287f566dfcb2e8f..f6293c989ee26fa89dc113e6d4dd8f597cdc7449 100644
--- a/udmf/framework/common/udmf_types_util.h
+++ b/udmf/framework/common/udmf_types_util.h
@@ -31,6 +31,7 @@ using CustomOption = UDMF::CustomOption;
 using QueryOption = UDMF::QueryOption;
 using UDType = UDMF::UDType;
 using Intention = UDMF::Intention;
+using AsyncProcessInfo = UDMF::AsyncProcessInfo;
 
 template<>
 bool API_EXPORT Marshalling(const UnifiedData &input, MessageParcel &parcel);
@@ -71,6 +72,11 @@ template<>
 bool API_EXPORT Marshalling(const Intention &input, MessageParcel &parcel);
 template<>
 bool API_EXPORT Unmarshalling(Intention &output, MessageParcel &parcel);
+
+template<>
+bool API_EXPORT Marshalling(const AsyncProcessInfo &input, MessageParcel &parcel);
+template<>
+bool API_EXPORT Unmarshalling(AsyncProcessInfo &output, MessageParcel &parcel);
 } // namespace ITypesUtil
 } // namespace OHOS
 #endif // UDMF_TYPES_UTIL_H
\ No newline at end of file
diff --git a/udmf/framework/common/udmf_utils.cpp b/udmf/framework/common/udmf_utils.cpp
index 45d9935b630af49d8d301f5f1d7204750acf5333..2c0c1b1756a7a32f37dc8e6a0333d6529f319fb9 100644
--- a/udmf/framework/common/udmf_utils.cpp
+++ b/udmf/framework/common/udmf_utils.cpp
@@ -15,7 +15,6 @@
 #include "udmf_utils.h"
 #include <random>
 #include <sstream>
-#include <cstring>
 
 namespace OHOS {
 namespace UDMF {
@@ -23,18 +22,19 @@ namespace UTILS {
 static constexpr int ID_LEN = 32;
 static constexpr int MINIMUM = 48;
 static constexpr int MAXIMUM = 121;
-const char SPECIAL = '^';
+constexpr char SPECIAL = '^';
 
-std::vector<std::string> StrSplit(std::string str, std::string subStr)
+std::vector<std::string> StrSplit(const std::string &str, const std::string &delimiter)
 {
     std::vector<std::string> result;
-    char *s = str.data();
-    char *p = strtok(s, subStr.c_str());
-    while (p) {
-        std::string tmp = p;
-        result.push_back(p);
-        p = strtok(NULL, subStr.c_str());
+    size_t start = 0;
+    size_t end = str.find(delimiter);
+    while (end != std::string::npos) {
+        result.push_back(str.substr(start, end - start));
+        start = end + delimiter.length();
+        end = str.find(delimiter, start);
     }
+    result.push_back(str.substr(start));
     return result;
 }
 
diff --git a/udmf/framework/common/udmf_utils.h b/udmf/framework/common/udmf_utils.h
index 87a606804aa8137e92c4bd5fbcfc682107775a87..7f5c7934710c77dc1c023a0b486f02b842b585d0 100644
--- a/udmf/framework/common/udmf_utils.h
+++ b/udmf/framework/common/udmf_utils.h
@@ -22,7 +22,7 @@
 namespace OHOS {
 namespace UDMF {
 namespace UTILS {
-std::vector<std::string> StrSplit(std::string str, std::string subStr);
+std::vector<std::string> StrSplit(const std::string &str, const std::string &delimiter);
 std::vector<uint8_t> Random(int32_t len, int32_t minimum = 0,
                             int32_t maximum = std::numeric_limits<uint8_t>::max());
 std::string GenerateId();
diff --git a/udmf/framework/common/unittest/BUILD.gn b/udmf/framework/common/unittest/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..86c362826c460c014d446466d857ac2911b1ff87
--- /dev/null
+++ b/udmf/framework/common/unittest/BUILD.gn
@@ -0,0 +1,82 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/udmf/udmf.gni")
+
+module_output_path = "udmf/common"
+
+###############################################################################
+config("module_private_config") {
+  include_dirs = [
+    "${udmf_interfaces_path}/innerkits/common",
+    "${udmf_framework_path}/innerkitsimpl/data",
+    "${udmf_framework_path}/common",
+    "${kv_store_path}/frameworks/common",
+    "${udmf_interfaces_path}/innerkits/data",
+  ]
+}
+
+common_deps = [ "${udmf_interfaces_path}/innerkits:udmf_client" ]
+
+common_external_deps = [
+  "ability_base:want",
+  "c_utils:utils",
+  "hilog:libhilog",
+  "image_framework:image",
+  "ipc:ipc_core",
+]
+
+ohos_unittest("UtdCfgsCheckerTest") {
+  module_out_path = module_output_path
+
+  sources = [
+    "${udmf_framework_path}/common/graph.cpp",
+    "${udmf_framework_path}/common/utd_cfgs_checker.cpp",
+    "${udmf_framework_path}/common/utd_graph.cpp",
+    "utd_cfgs_checker_test.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+}
+
+ohos_unittest("UdmfTypesUtilTest") {
+  module_out_path = module_output_path
+
+  sources = [ "udmf_types_util_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+###############################################################################
+group("unittest") {
+  testonly = true
+
+  deps = [
+    ":UdmfTypesUtilTest",
+    ":UtdCfgsCheckerTest",
+  ]
+}
+###############################################################################
diff --git a/udmf/framework/common/unittest/udmf_types_util_test.cpp b/udmf/framework/common/unittest/udmf_types_util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e7db0b1abfc7cedbac703e523a0e50111f2de1c5
--- /dev/null
+++ b/udmf/framework/common/unittest/udmf_types_util_test.cpp
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UdmfTypesUtilTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_types_util.h"
+#include "unified_meta.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class UdmfTypesUtilTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void UdmfTypesUtilTest::SetUpTestCase()
+{
+}
+
+void UdmfTypesUtilTest::TearDownTestCase()
+{
+}
+
+void UdmfTypesUtilTest::SetUp()
+{
+}
+
+void UdmfTypesUtilTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Unmarshalling001
+* @tc.desc: Abnormal testcase of Unmarshalling, parcel is null
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling001 begin.");
+    UnifiedData input;
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Unmarshalling(input, parcel);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unmarshalling001 end.");
+}
+
+/**
+* @tc.name: Unmarshalling002
+* @tc.desc: Abnormal testcase of Unmarshalling, parcel is null
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling002 begin.");
+    std::vector<UnifiedData> output = std::vector<UnifiedData>();
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Unmarshalling(output, parcel);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unmarshalling002 end.");
+}
+
+/**
+* @tc.name: Marshalling001
+* @tc.desc: Normal testcase of Marshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Marshalling001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Marshalling001 begin.");
+    const Summary input{};
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(input, parcel);
+    EXPECT_EQ(ret, ITypesUtil::Marshal(parcel, input.summary, input.totalSize));
+    LOG_INFO(UDMF_TEST, "Marshalling001 end.");
+}
+
+/**
+* @tc.name: Unmarshalling003
+* @tc.desc: Normal testcase of Unmarshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling003 begin.");
+    const Privilege input{};
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(input, parcel);
+    EXPECT_EQ(ret, ITypesUtil::Marshal(parcel, input.tokenId, input.readPermission, input.writePermission));
+    LOG_INFO(UDMF_TEST, "Unmarshalling003 end.");
+}
+
+/**
+* @tc.name: Unmarshalling004
+* @tc.desc: Normal testcase of Unmarshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling004 begin.");
+    CustomOption output;
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(output, parcel);
+    EXPECT_EQ(ret, ITypesUtil::Unmarshal(parcel, output.intention));
+    LOG_INFO(UDMF_TEST, "Unmarshalling004 end.");
+}
+
+/**
+* @tc.name: Unmarshalling005
+* @tc.desc: Normal testcase of Unmarshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling005 begin.");
+    QueryOption output;
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(output, parcel);
+    EXPECT_EQ(ret, ITypesUtil::Unmarshal(parcel, output.key, output.intention));
+    LOG_INFO(UDMF_TEST, "Unmarshalling005 end.");
+}
+
+/**
+* @tc.name: Marshalling002
+* @tc.desc: Normal testcase of Marshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Marshalling002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Marshalling002 begin.");
+    const UDType input{};
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(input, parcel);
+    EXPECT_EQ(ret, ITypesUtil::Marshal(parcel, input));
+    LOG_INFO(UDMF_TEST, "Marshalling002 end.");
+}
+
+/**
+* @tc.name: Unmarshalling006
+* @tc.desc: Normal testcase of Unmarshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling006, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling006 begin.");
+    UDType output{};
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Unmarshalling(output, parcel);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unmarshalling006 end.");
+}
+
+/**
+* @tc.name: Unmarshalling007
+* @tc.desc: Normal testcase of Unmarshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Unmarshalling007, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unmarshalling007 begin.");
+    Intention output;
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Unmarshalling(output, parcel);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unmarshalling007 end.");
+}
+
+/**
+* @tc.name: Marshalling003
+* @tc.desc: Normal testcase of Marshalling
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfTypesUtilTest, Marshalling003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Marshalling003 begin.");
+    const AsyncProcessInfo input{};
+    MessageParcel parcel;
+    bool ret = ITypesUtil::Marshalling(input, parcel);
+    EXPECT_NE(ret, false);
+    LOG_INFO(UDMF_TEST, "Marshalling003 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/common/unittest/utd_cfgs_checker_test.cpp b/udmf/framework/common/unittest/utd_cfgs_checker_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a727441db1442faad6c98fe4ba47846bb0ad75b
--- /dev/null
+++ b/udmf/framework/common/unittest/utd_cfgs_checker_test.cpp
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "UtdCfgsCheckerTest"
+
+#include "utd_cfgs_checker.h"
+#include <gtest/gtest.h>
+#include "logger.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+
+namespace OHOS::Test {
+class UtdCfgsCheckerTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void UtdCfgsCheckerTest::SetUpTestCase(void) {}
+void UtdCfgsCheckerTest::TearDownTestCase(void) {}
+void UtdCfgsCheckerTest::SetUp(void) {}
+void UtdCfgsCheckerTest::TearDown(void) {}
+
+/**
+ * @tc.name: CheckTypeDescriptors_001
+ * @tc.desc: Normal testcase of CheckTypeDescriptors
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckTypeDescriptors_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_001 begin.");
+    CustomUtdCfgs typeCfgs;
+    TypeDescriptorCfg tdc1;
+    tdc1.typeId = "com.demo.test.type";
+    tdc1.filenameExtensions = {".abc"};
+    tdc1.belongingToTypes = {"com.demo.test.parent"};
+    tdc1.mimeTypes = {"parent/abc"};
+    std::vector<TypeDescriptorCfg> first = {tdc1};
+    TypeDescriptorCfg tdc2;
+    tdc2.typeId = "com.demo.test.type2";
+    tdc2.filenameExtensions = {".abc2"};
+    tdc2.belongingToTypes = {"com.demo.test.parent2"};
+    tdc2.mimeTypes = {"parent2/abc"};
+    std::vector<TypeDescriptorCfg> second = {tdc2};
+    CustomUtdCfgs customUtdCfgs = {first, second};
+
+    TypeDescriptorCfg preTdc1;
+    preTdc1.typeId = "com.demo.test.parent";
+    TypeDescriptorCfg preTdc2;
+    preTdc2.typeId = "com.demo.test.parent2";
+    std::vector<TypeDescriptorCfg> presetCfgs = {preTdc1, preTdc2};
+
+    std::vector<TypeDescriptorCfg> customCfgs = {};
+    std::string bundleName("com.demo.test");
+
+    bool result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_TRUE(result);
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_001 end.");
+}
+
+/**
+ * @tc.name: CheckTypeDescriptors_002
+ * @tc.desc: testcase of CheckTypeDescriptors: failed to match the regular expression
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckTypeDescriptors_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_002 begin.");
+    CustomUtdCfgs typeCfgs;
+    TypeDescriptorCfg tdc1;
+    tdc1.typeId = "com.demo.test.type";
+    std::vector<TypeDescriptorCfg> first = {tdc1};
+    TypeDescriptorCfg tdc2;
+    tdc2.typeId = "errorTypeId";
+    std::vector<TypeDescriptorCfg> second = {tdc2};
+    CustomUtdCfgs customUtdCfgs1 = {first, second};
+
+    TypeDescriptorCfg preTdc1;
+    preTdc1.typeId = "com.demo.test.parent";
+    TypeDescriptorCfg preTdc2;
+    preTdc2.typeId = "com.demo.test.parent2";
+    std::vector<TypeDescriptorCfg> presetCfgs = {preTdc1, preTdc2};
+
+    std::vector<TypeDescriptorCfg> customCfgs = {};
+    std::string bundleName("com.demo.test");
+
+    bool result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs1, presetCfgs, customCfgs,
+        bundleName);
+    EXPECT_FALSE(result);
+
+    CustomUtdCfgs customUtdCfgs2 = {second, first};
+    result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs2, presetCfgs, customCfgs, bundleName);
+    EXPECT_FALSE(result);
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_002 end.");
+}
+
+/**
+ * @tc.name: CheckTypeDescriptors_003
+ * @tc.desc: testcase of CheckTypeDescriptors: empty testcase
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckTypeDescriptors_003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_003 begin.");
+    CustomUtdCfgs typeCfgs;
+    std::vector<TypeDescriptorCfg> first = {};
+    std::vector<TypeDescriptorCfg> second = {};
+    CustomUtdCfgs customUtdCfgs = {first, second};
+    std::vector<TypeDescriptorCfg> presetCfgs = {};
+    std::vector<TypeDescriptorCfg> customCfgs = {};
+    std::string bundleName("com.demo.test");
+
+    bool result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_FALSE(result);
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_003 end.");
+}
+
+/**
+ * @tc.name: CheckTypeDescriptors_004
+ * @tc.desc: testcase of CheckTypeDescriptors: filename, belongingToType or mimeType not match
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckTypeDescriptors_004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_004 begin.");
+    CustomUtdCfgs typeCfgs;
+    TypeDescriptorCfg tdc1;
+    tdc1.typeId = "com.demo.test.type";
+    std::vector<TypeDescriptorCfg> first = {tdc1};
+    TypeDescriptorCfg tdc2;
+    tdc2.typeId = "com.demo.test.type2";
+    tdc2.filenameExtensions = {".abc2"};
+    tdc2.belongingToTypes = {"com.demo.test.parent2"};
+    tdc2.mimeTypes = {"parent2/abc"};
+    std::vector<TypeDescriptorCfg> second = {tdc2};
+    CustomUtdCfgs customUtdCfgs = {first, second};
+
+    TypeDescriptorCfg preTdc1;
+    preTdc1.typeId = "com.demo.test.parent";
+    TypeDescriptorCfg preTdc2;
+    preTdc2.typeId = "com.demo.test.parent2";
+    std::vector<TypeDescriptorCfg> presetCfgs = {preTdc1, preTdc2};
+
+    std::vector<TypeDescriptorCfg> customCfgs = {};
+    std::string bundleName("com.demo.test");
+
+    bool result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_FALSE(result);
+
+    tdc1.filenameExtensions = {".abc"};
+    first = {tdc1};
+    customUtdCfgs = {first, second};
+    result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_FALSE(result);
+
+    tdc1.belongingToTypes = {"com.demo.test.parent"};
+    tdc1.mimeTypes = {""};
+    first = {tdc1};
+    customUtdCfgs = {first, second};
+    result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_FALSE(result);
+
+    tdc1.mimeTypes = {"parent/abc"};
+    first = {tdc1};
+    customUtdCfgs = {first, second};
+    result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_TRUE(result);
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_004 end.");
+}
+
+/**
+ * @tc.name: CheckBelongingToTypes_001
+ * @tc.desc: Normal testcase of CheckTypeDescriptors
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckBelongingToTypes_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckBelongingToTypes_001 begin.");
+    TypeDescriptorCfg tdc1;
+    tdc1.typeId = "com.demo.test.type";
+    tdc1.filenameExtensions = {".abc"};
+    tdc1.belongingToTypes = {""};
+    tdc1.mimeTypes = {"parent/abc"};
+    std::vector<TypeDescriptorCfg> typeCfgs = {tdc1};
+
+    TypeDescriptorCfg preTdc1;
+    preTdc1.typeId = "com.demo.test.parent";
+    TypeDescriptorCfg preTdc2;
+    preTdc2.typeId = "com.demo.test.parent2";
+    std::vector<TypeDescriptorCfg> presetCfgs = {preTdc1, preTdc2};
+
+    bool result = UtdCfgsChecker::GetInstance().CheckBelongingToTypes(typeCfgs, presetCfgs);
+    EXPECT_FALSE(result);
+
+    tdc1.belongingToTypes = {"com.demo.test.type"};
+    typeCfgs = {tdc1};
+    result = UtdCfgsChecker::GetInstance().CheckBelongingToTypes(typeCfgs, presetCfgs);
+    EXPECT_FALSE(result);
+
+    tdc1.belongingToTypes = {"com.demo.test.parent3"};
+    typeCfgs = {tdc1};
+    result = UtdCfgsChecker::GetInstance().CheckBelongingToTypes(typeCfgs, presetCfgs);
+    EXPECT_FALSE(result);
+
+    tdc1.belongingToTypes = {"com.demo.test.parent"};
+    typeCfgs = {tdc1};
+    result = UtdCfgsChecker::GetInstance().CheckBelongingToTypes(typeCfgs, presetCfgs);
+    EXPECT_TRUE(result);
+
+    LOG_INFO(UDMF_TEST, "CheckBelongingToTypes_001 end.");
+}
+
+/**
+ * @tc.name: CheckTypeDescriptors_005
+ * @tc.desc: Normal testcase of CheckTypeDescriptors
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdCfgsCheckerTest, CheckTypeDescriptors_005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_005 begin.");
+    TypeDescriptorCfg tdc1;
+    tdc1.typeId = "com.demo.test.type";
+    tdc1.filenameExtensions = {".abc"};
+    tdc1.belongingToTypes = {"com.demo.test.parent"};
+    tdc1.mimeTypes = {"parent/abc"};
+    TypeDescriptorCfg tdc2;
+    tdc2.typeId = "com.demo.test.type2";
+    tdc2.filenameExtensions = {".abc2"};
+    tdc2.belongingToTypes = {"com.demo.test.parent2"};
+    tdc2.mimeTypes = {"parent2/abc"};
+    std::vector<TypeDescriptorCfg> first = {tdc1, tdc2};
+    TypeDescriptorCfg tdc3;
+    tdc3.typeId = "com.demo.test.parent";
+    tdc3.filenameExtensions = {".abc3"};
+    tdc3.belongingToTypes = {"com.demo.test.parent3"};
+    tdc3.mimeTypes = {"parent3/abc"};
+    TypeDescriptorCfg tdc4;
+    tdc4.typeId = "com.demo.test.parent2";
+    tdc4.filenameExtensions = {".abc4"};
+    tdc4.belongingToTypes = {"com.demo.test.parent4"};
+    tdc4.mimeTypes = {"parent4/abc"};
+    std::vector<TypeDescriptorCfg> second = {tdc3, tdc4};
+    CustomUtdCfgs customUtdCfgs = {first, second};
+
+    TypeDescriptorCfg presetCfg1;
+    presetCfg1.typeId = "com.demo.test.parent3";
+    presetCfg1.filenameExtensions = {".abca3"};
+    presetCfg1.belongingToTypes = {"com.demo.test.parent5"};
+    presetCfg1.mimeTypes = {"parent3/abc"};
+    TypeDescriptorCfg presetCfg2;
+    presetCfg2.typeId = "com.demo.test.parent4";
+    presetCfg2.filenameExtensions = {".abca3"};
+    presetCfg2.belongingToTypes = {"com.demo.test.parent6"};
+    presetCfg2.mimeTypes = {"parent3/abc"};
+    std::vector<TypeDescriptorCfg> presetCfgs = {presetCfg1, presetCfg2};
+    
+    std::vector<TypeDescriptorCfg> customCfgs = {tdc1, tdc3};
+
+    std::string bundleName("com.demo.test");
+    bool result = UtdCfgsChecker::GetInstance().CheckTypeDescriptors(customUtdCfgs, presetCfgs, customCfgs, bundleName);
+    EXPECT_TRUE(result);
+    LOG_INFO(UDMF_TEST, "CheckTypeDescriptors_005 end.");
+}
+
+}
diff --git a/udmf/framework/common/utd_cfgs_checker.cpp b/udmf/framework/common/utd_cfgs_checker.cpp
index cd8e5d24740543e3d17e6ab1c1813982ea0ba912..baecb3e5eb2effaae10cabf368215aa07094cea6 100644
--- a/udmf/framework/common/utd_cfgs_checker.cpp
+++ b/udmf/framework/common/utd_cfgs_checker.cpp
@@ -15,7 +15,6 @@
 #define LOG_TAG "UtdCfgsChecker"
 #include "utd_cfgs_checker.h"
 
-#include <vector>
 #include <regex>
 #include "utd_graph.h"
 #include "logger.h"
diff --git a/udmf/framework/common/utd_common.h b/udmf/framework/common/utd_common.h
index 0fbd28e15fc9069764e032c4dc6cf62ef6f2aca1..ac39da62cb8b33586f54fe5f4d2486804674b9b1 100644
--- a/udmf/framework/common/utd_common.h
+++ b/udmf/framework/common/utd_common.h
@@ -47,6 +47,8 @@ constexpr const char* UTD_CUSTOM_REFERENCE = "ReferenceUniformDataTypeDeclaratio
 constexpr const char* UTD_CUSTOM = "CustomUTDs";
 
 constexpr const char* DEFAULT_TYPE_ID = "#default";
+
+constexpr const int32_t DEFAULT_USER_ID = 100;
 } // namespace UDMF
 } // namespace OHOS
 #endif // UDMF_UTD_TYPE
diff --git a/udmf/framework/common/utd_graph.cpp b/udmf/framework/common/utd_graph.cpp
index 5a2696730c51d885d2f1483edc7ee66a02981c0e..525fe3b40c42a90cef7fed5b70106ad209de4fbc 100644
--- a/udmf/framework/common/utd_graph.cpp
+++ b/udmf/framework/common/utd_graph.cpp
@@ -55,8 +55,8 @@ void UtdGraph::InitUtdGraph(const std::vector<TypeDescriptorCfg> &descriptorCfgs
 {
     typeIdIndex_.clear();
     uint32_t descriptorsNum = static_cast<uint32_t>(descriptorCfgs.size());
-    std::unique_lock<std::mutex> Lock(graphMutex_);
-    graph_ = new Graph(descriptorsNum);
+    std::unique_lock<std::mutex> lock(graphMutex_);
+    graph_ = std::make_unique<Graph>(descriptorsNum);
     for (uint32_t i = 0; i < descriptorsNum; i++) {
         typeIdIndex_.insert(std::make_pair(descriptorCfgs[i].typeId, i));
     }
@@ -91,7 +91,7 @@ bool UtdGraph::IsLowerLevelType(const std::string &lowerLevelType, const std::st
     }
     uint32_t uStart = static_cast<uint32_t>(start);
     uint32_t uEnd = static_cast<uint32_t>(end);
-    std::unique_lock<std::mutex> Lock(graphMutex_);
+    std::unique_lock<std::mutex> lock(graphMutex_);
     graph_->Dfs(uStart, [&isFind, &uEnd](uint32_t currNode)-> bool {
         if (uEnd == currNode) {
             isFind = true;
@@ -104,7 +104,7 @@ bool UtdGraph::IsLowerLevelType(const std::string &lowerLevelType, const std::st
 
 bool UtdGraph::IsDAG()
 {
-    std::unique_lock<std::mutex> Lock(graphMutex_);
+    std::unique_lock<std::mutex> lock(graphMutex_);
     return graph_->DfsUnconnectedGraph([&](uint32_t currNode) -> bool {return false; });
 }
 } // namespace UDMF
diff --git a/udmf/framework/common/utd_graph.h b/udmf/framework/common/utd_graph.h
index db4c491da05fdc81ab2f507b8f2a61180d152dbc..a4861b6ec8d548f8334364b6f5bcdae1c610bde3 100644
--- a/udmf/framework/common/utd_graph.h
+++ b/udmf/framework/common/utd_graph.h
@@ -21,6 +21,7 @@
 #include <stack>
 #include <string>
 #include <shared_mutex>
+#include <memory>
 #include "graph.h"
 #include "utd_common.h"
 #include "preset_type_descriptors.h"
@@ -42,7 +43,7 @@ private:
     int32_t GetIndex(const std::string &node);
     void AddEdge(const std::string &startNode, const std::string &endNode);
     std::mutex graphMutex_;
-    Graph *graph_ = nullptr;
+    std::unique_ptr<Graph> graph_;
     std::map<std::string, uint32_t> typeIdIndex_;
 };
 } // namespace UDMF
diff --git a/udmf/framework/innerkitsimpl/client/async_obtain_data.cpp b/udmf/framework/innerkitsimpl/client/async_obtain_data.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e64b3da343f55c08b8ba929f57cd3df3c28e000f
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/client/async_obtain_data.cpp
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "async_obtain_data.h"
+#define LOG_TAG "AsyncObtainData"
+#include <cstdint>
+#include <algorithm>
+#include "unified_types.h"
+#include "logger.h"
+#include "udmf_service_client.h"
+#include "securec.h"
+
+namespace OHOS {
+namespace UDMF {
+static constexpr size_t MAX_THREADS = 2;
+static constexpr size_t MIN_THREADS = 0;
+static constexpr uint32_t MAX_PROGRESS = 100;
+static constexpr double MAX_PROGRESS_DOUBLE = 100.0;
+static constexpr double SYNC_COEFF = 0.5;
+static constexpr double PERM_COEFF = 0.4;
+
+AsyncObtainData::AsyncObtainData() : executor_(MAX_THREADS, MIN_THREADS) {}
+
+Status AsyncObtainData::InitTask(const QueryOption &query, ObtainDataCallback callback)
+{
+    if (callback == nullptr) {
+        LOG_ERROR(UDMF_CLIENT, "callback invalid");
+        taskStatus_ = ASYNC_FAILURE;
+        return E_INVALID_PARAMETERS;
+    }
+
+    serviceClient_ = UdmfServiceClient::GetInstance();
+    if (serviceClient_ == nullptr) {
+        LOG_ERROR(UDMF_CLIENT, "Service unavailable");
+        taskStatus_ = ASYNC_FAILURE;
+        return E_IPC;
+    }
+
+    initialized_ = true;
+    query_ = query;
+    callback_ = callback;
+    taskStatus_ = ASYNC_RUNNING;
+    processInfo_.syncStatus = ASYNC_RUNNING;
+    return E_OK;
+}
+
+Status AsyncObtainData::RunTask()
+{
+    LOG_DEBUG(UDMF_CLIENT, "Enter");
+    if (serviceClient_ == nullptr) {
+        LOG_ERROR(UDMF_CLIENT, "failed! service client is nullptr");
+        return E_IPC;
+    }
+    if (!initialized_) {
+        LOG_ERROR(UDMF_CLIENT, "failed! not init");
+        return E_ERROR;
+    }
+    obtainDataTaskId_ = executor_.Execute(std::bind(&AsyncObtainData::ObtainDataTask, this));
+    progressTaskId_ = executor_.Execute(std::bind(&AsyncObtainData::ProgressTask, this));
+
+    return E_OK;
+}
+
+void AsyncObtainData::ObtainDataTask()
+{
+    LOG_DEBUG(UDMF_CLIENT, "Enter");
+    if ((taskStatus_ == ASYNC_RUNNING) && (processInfo_.syncStatus == ASYNC_RUNNING)) {
+        Executor::Duration delay = std::chrono::milliseconds(500);
+        obtainDataTaskId_ = executor_.Schedule(delay, std::bind(&AsyncObtainData::ObtainDataTask, this));
+        return;
+    }
+
+    UnifiedData unifiedData;
+    if (taskStatus_ != ASYNC_FAILURE) {
+        if (serviceClient_ == nullptr) {
+            LOG_ERROR(UDMF_CLIENT, "failed! serviceClient_ is nullptr");
+            return;
+        }
+        int32_t ret = serviceClient_->GetData(query_, unifiedData);
+        if (ret != E_OK) {
+            LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
+            taskStatus_ = ASYNC_FAILURE;
+        } else {
+            taskStatus_ = ASYNC_SUCCESS;
+        }
+    }
+    InvokeCallback(unifiedData);
+    ClearTask();
+}
+
+void AsyncObtainData::ProgressTask()
+{
+    LOG_DEBUG(UDMF_CLIENT, "Enter");
+    if (serviceClient_ == nullptr) {
+        LOG_ERROR(UDMF_CLIENT, "failed! serviceClient_ is nullptr");
+        return;
+    }
+    AsyncProcessInfo processInfo;
+    int32_t ret = serviceClient_->ObtainAsynProcess(processInfo);
+    if (ret != E_OK) {
+        LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
+        taskStatus_ = ASYNC_FAILURE;
+        return;
+    }
+
+    UpdateProcessInfo(processInfo);
+
+    UnifiedData unifiedData;
+    InvokeCallback(unifiedData);
+
+    if ((taskStatus_ == ASYNC_RUNNING) &&
+        ((processInfo.syncStatus == ASYNC_RUNNING) || (processInfo.permStatus == ASYNC_RUNNING))) {
+        Executor::Duration delay = std::chrono::milliseconds(500);
+        progressTaskId_ = executor_.Schedule(delay, std::bind(&AsyncObtainData::ProgressTask, this));
+    }
+}
+
+void AsyncObtainData::InvokeCallback(UnifiedData &data)
+{
+    ProgressInfo progress{ "", ASYNC_IDLE, 0 };
+    progress.status = taskStatus_;
+    progress.srcDevName = processInfo_.srcDevName;
+
+    progress.progress = CalProgress();
+    if (progress.progress <= lastProgress_) {
+        progress.progress = lastProgress_;
+    } else {
+        lastProgress_ = progress.progress;
+    }
+    if (callback_ == nullptr) {
+        LOG_ERROR(UDMF_CLIENT, "failed! callback_ is nullptr");
+        return;
+    }
+    callback_(progress, data);
+}
+
+void AsyncObtainData::UpdateProcessInfo(AsyncProcessInfo &info)
+{
+    processInfo_.syncStatus = info.syncStatus;
+    processInfo_.permStatus = info.permStatus;
+    processInfo_.srcDevName = (info.syncStatus == ASYNC_IDLE ? "Local" : info.srcDevName);
+    processInfo_.syncFinished = info.syncFinished;
+    processInfo_.syncTotal = info.syncTotal;
+    processInfo_.syncId = info.syncId;
+    processInfo_.permFnished = info.permFnished;
+    processInfo_.permTotal = info.permTotal;
+
+    if (processInfo_.syncStatus == ASYNC_FAILURE || processInfo_.permStatus == ASYNC_FAILURE) {
+        taskStatus_ = ASYNC_FAILURE;
+    }
+}
+
+void AsyncObtainData::ClearTask()
+{
+    initialized_ = false;
+    taskStatus_ = ASYNC_IDLE;
+    lastProgress_ = 0;
+    progressTaskId_ = ExecutorPool::INVALID_TASK_ID;
+    obtainDataTaskId_ = ExecutorPool::INVALID_TASK_ID;
+    (void)memset_s(&processInfo_, sizeof(processInfo_), 0, sizeof(processInfo_));
+
+    serviceClient_ = UdmfServiceClient::GetInstance();
+    if (serviceClient_ == nullptr) {
+        return;
+    }
+    auto ret = serviceClient_->ClearAsynProcess();
+    if (ret != E_OK) {
+        LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
+    }
+    serviceClient_ = nullptr;
+}
+
+uint32_t AsyncObtainData::CalProgress()
+{
+    if (taskStatus_ == ASYNC_SUCCESS) {
+        return MAX_PROGRESS;
+    }
+    if ((taskStatus_ == ASYNC_FAILURE) || (processInfo_.syncStatus == ASYNC_FAILURE) ||
+        processInfo_.permStatus == ASYNC_FAILURE) {
+        return lastProgress_;
+    }
+
+    uint32_t syncProgress = CalSyncProgress();
+    uint32_t permProgress = CalPermProgress();
+    double totalProgress = syncProgress * SYNC_COEFF + permProgress * PERM_COEFF;
+    return static_cast<uint32_t>(totalProgress);
+}
+
+uint32_t AsyncObtainData::CalSyncProgress()
+{
+    if (processInfo_.syncStatus == ASYNC_SUCCESS || processInfo_.syncStatus == ASYNC_IDLE) {
+        return MAX_PROGRESS;
+    }
+    if (processInfo_.syncTotal == 0) {
+        return 0;
+    }
+    return std::min(MAX_PROGRESS,
+        static_cast<uint32_t>(processInfo_.syncFinished * MAX_PROGRESS_DOUBLE / processInfo_.syncTotal));
+}
+
+uint32_t AsyncObtainData::CalPermProgress()
+{
+    if (processInfo_.permStatus == ASYNC_SUCCESS) {
+        return MAX_PROGRESS;
+    }
+    if (processInfo_.permTotal == 0) {
+        return 0;
+    }
+    return std::min(MAX_PROGRESS,
+        static_cast<uint32_t>(processInfo_.permFnished * MAX_PROGRESS_DOUBLE / processInfo_.permTotal));
+}
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/client/async_obtain_data.h b/udmf/framework/innerkitsimpl/client/async_obtain_data.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c0f58a017f90eb27d22cdb1691473fc58dcbde1
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/client/async_obtain_data.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ASYNC_OBTAIN_DATA_H
+#define ASYNC_OBTAIN_DATA_H
+
+#include "executor_pool.h"
+#include "udmf_service.h"
+
+namespace OHOS {
+namespace UDMF {
+using ObtainDataCallback = std::function<void(ProgressInfo progress, UnifiedData &unifiedData)>;
+
+class AsyncObtainData {
+public:
+    AsyncObtainData();
+    ~AsyncObtainData() = default;
+
+public:
+    Status InitTask(const QueryOption &query, ObtainDataCallback callback);
+    Status RunTask();
+    void ClearTask();
+
+private:
+    void InvokeCallback(UnifiedData &data);
+    void ObtainDataTask();
+    void ProgressTask();
+
+    void UpdateProcessInfo(AsyncProcessInfo &info);
+    uint32_t CalProgress();
+    uint32_t CalSyncProgress();
+    uint32_t CalPermProgress();
+
+private:
+    bool initialized_{ false };
+    ExecutorPool executor_;
+    ExecutorPool::TaskId progressTaskId_ = ExecutorPool::INVALID_TASK_ID;
+    ExecutorPool::TaskId obtainDataTaskId_ = ExecutorPool::INVALID_TASK_ID;
+    AsyncTaskStatus taskStatus_{ ASYNC_IDLE };
+    QueryOption query_;
+    ObtainDataCallback callback_{ nullptr };
+    uint32_t lastProgress_{ 0 };
+    AsyncProcessInfo processInfo_;
+    std::shared_ptr<UdmfService> serviceClient_{ nullptr };
+};
+} // namespace UDMF
+} // namespace OHOS
+
+#endif
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/client/getter_system.cpp b/udmf/framework/innerkitsimpl/client/getter_system.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b678eab51dfe0b6d77bb03f47fbc56bc02418406
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/client/getter_system.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "getter_system.h"
+
+namespace OHOS {
+namespace UDMF {
+GetterSystem &GetterSystem::GetInstance()
+{
+    static GetterSystem system;
+    return system;
+}
+
+void GetterSystem::RegisterCreator(const std::string &name, Creator creator)
+{
+    creators_.InsertOrAssign(name, std::move(creator));
+}
+
+GetterSystem::Getter GetterSystem::GetGetter(const std::string &name)
+{
+    auto [flag, creator] = creators_.Find(name);
+    if (!flag) {
+        return nullptr;
+    }
+    return creator();
+}
+
+GetterSystem::GeneralGetter::~GeneralGetter()
+{
+}
+
+ValueType GetterSystem::GeneralGetter::GetValueByType(uint32_t dataId, uint32_t recordId, const std::string &utdId)
+{
+    return ValueType();
+}
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/client/udmf_client.cpp b/udmf/framework/innerkitsimpl/client/udmf_client.cpp
index 64f5312253b9acaff10fdf312d20624db10897cd..3b494222ea47c18038f805b3169e6da578cbba53 100644
--- a/udmf/framework/innerkitsimpl/client/udmf_client.cpp
+++ b/udmf/framework/innerkitsimpl/client/udmf_client.cpp
@@ -18,7 +18,6 @@
 #include "dds_trace.h"
 #include "udmf_radar_reporter.h"
 
-#include "error_code.h"
 #include "logger.h"
 #include "udmf_service_client.h"
 #include "udmf_utils.h"
@@ -28,7 +27,7 @@
 
 namespace OHOS {
 namespace UDMF {
-const std::string TAG = "UdmfClient::";
+constexpr const char *TAG = "UdmfClient::";
 using namespace OHOS::DistributedDataDfx;
 using namespace RadarReporter;
 UdmfClient &UdmfClient::GetInstance()
@@ -41,12 +40,13 @@ Status UdmfClient::SetData(CustomOption &option, UnifiedData &unifiedData, std::
 {
     DdsTrace trace(
         std::string(TAG) + std::string(__FUNCTION__), TraceSwitch::BYTRACE_ON | TraceSwitch::TRACE_CHAIN_ON);
-    RADAR_REPORT(BizScene::SET_DATA, SetDataStage::SET_DATA_BEGIN, StageRes::IDLE, BIZ_STATE, BizState::DFX_BEGIN);
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::SET_DATA, SetDataStage::SET_DATA_BEGIN, StageRes::IDLE, BizState::DFX_BEGIN);
     auto service = UdmfServiceClient::GetInstance();
     if (service == nullptr) {
         LOG_ERROR(UDMF_CLIENT, "Service unavailable");
-        RADAR_REPORT(BizScene::SET_DATA, SetDataStage::SET_DATA_BEGIN, StageRes::FAILED, ERROR_CODE, E_IPC,
-                     BIZ_STATE, BizState::DFX_ABNORMAL_END);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::SET_DATA, SetDataStage::SET_DATA_BEGIN, StageRes::FAILED, E_IPC, BizState::DFX_ABNORMAL_END);
         return E_IPC;
     }
 
@@ -65,19 +65,19 @@ Status UdmfClient::SetData(CustomOption &option, UnifiedData &unifiedData, std::
             dataCache_.Clear();
             dataCache_.Insert(key, unifiedData);
             LOG_INFO(UDMF_CLIENT, "SetData in app success, bundleName:%{public}s.", bundleName.c_str());
-            RADAR_REPORT(BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::SUCCESS,
-                         BIZ_STATE, BizState::DFX_NORMAL_END);
+            RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+                BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
             return E_OK;
         }
     }
     int32_t ret = service->SetData(option, unifiedData, key);
     if (ret != E_OK) {
-        RADAR_REPORT(BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::FAILED, ERROR_CODE, ret,
-                     BIZ_STATE, BizState::DFX_ABNORMAL_END);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::FAILED, ret, BizState::DFX_ABNORMAL_END);
         LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
     }
-    RADAR_REPORT(BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::SUCCESS,
-                 BIZ_STATE, BizState::DFX_NORMAL_END);
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::SET_DATA, SetDataStage::SET_DATA_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
     return static_cast<Status>(ret);
 }
 
@@ -85,32 +85,32 @@ Status UdmfClient::GetData(const QueryOption &query, UnifiedData &unifiedData)
 {
     DdsTrace trace(
         std::string(TAG) + std::string(__FUNCTION__), TraceSwitch::BYTRACE_ON | TraceSwitch::TRACE_CHAIN_ON);
-    RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GET_DATA_BEGIN, StageRes::IDLE, BIZ_STATE, BizState::DFX_BEGIN);
-
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::GET_DATA, GetDataStage::GET_DATA_BEGIN, StageRes::IDLE, BizState::DFX_BEGIN);
     auto service = UdmfServiceClient::GetInstance();
     if (service == nullptr) {
         LOG_ERROR(UDMF_CLIENT, "Service unavailable");
-        RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GET_DATA_BEGIN, StageRes::FAILED, ERROR_CODE, E_IPC,
-                     BIZ_STATE, BizState::DFX_ABNORMAL_END);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::GET_DATA, GetDataStage::GET_DATA_BEGIN, StageRes::FAILED, E_IPC, BizState::DFX_ABNORMAL_END);
         return E_IPC;
     }
     auto it = dataCache_.Find(query.key);
     if (it.first) {
         unifiedData = it.second;
         dataCache_.Erase(query.key);
-        RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::SUCCESS,
-                     BIZ_STATE, BizState::DFX_NORMAL_END);
+        RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+            BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
         return E_OK;
     }
     LOG_WARN(UDMF_CLIENT, "query data from cache failed! key = %{public}s", query.key.c_str());
     int32_t ret = service->GetData(query, unifiedData);
     if (ret != E_OK) {
-        RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::FAILED, ERROR_CODE, ret,
-                     BIZ_STATE, BizState::DFX_ABNORMAL_END);
+        RadarReporterAdapter::ReportFail(std::string(__FUNCTION__),
+            BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::FAILED, ret, BizState::DFX_ABNORMAL_END);
         LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
     }
-    RADAR_REPORT(BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::SUCCESS,
-                 BIZ_STATE, BizState::DFX_NORMAL_END);
+    RadarReporterAdapter::ReportNormal(std::string(__FUNCTION__),
+        BizScene::GET_DATA, GetDataStage::GET_DATA_END, StageRes::SUCCESS, BizState::DFX_NORMAL_END);
     return static_cast<Status>(ret);
 }
 
@@ -264,7 +264,7 @@ Status UdmfClient::GetAppShareOption(const std::string &intention, enum ShareOpt
         shareOption = static_cast<ShareOptions>(shareOptionRet);
     }
     if (ret != E_OK) {
-        LOG_ERROR(UDMF_CLIENT, "failed! ret = %{public}d", ret);
+        LOG_INFO(UDMF_CLIENT, "No share option was obtained, ret = %{public}d", ret);
     }
     return static_cast<Status>(ret);
 }
@@ -296,5 +296,29 @@ std::string UdmfClient::GetSelfBundleName()
     }
     return hapInfo.bundleName;
 }
+
+Status UdmfClient::GetDataAsync(const QueryOption &query, ObtainDataCallback callback)
+{
+    asyncObtainData_.ClearTask();
+
+    auto it = this->dataCache_.Find(query.key);
+    if (it.first) {
+        dataCache_.Erase(query.key);
+        ProgressInfo info{ "Local", ASYNC_SUCCESS, 100 };
+        callback(info, it.second);
+        return E_OK;
+    }
+
+    auto ret = asyncObtainData_.InitTask(query, callback);
+    if (ret == E_OK) {
+        ret = asyncObtainData_.RunTask();
+    }
+    if (ret != E_OK) {
+        LOG_ERROR(UDMF_CLIENT, "InitTask or RunTask faile ret=%{public}d", ret);
+        asyncObtainData_.ClearTask();
+        return ret;
+    }
+    return E_OK;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/client/utd_client.cpp b/udmf/framework/innerkitsimpl/client/utd_client.cpp
index 331d2b11e6984432ac1fc7f2fd471bc1e2d0cfaf..f4fa0dcc7ff88a8b2aef763f3c8d05b330d42dca 100644
--- a/udmf/framework/innerkitsimpl/client/utd_client.cpp
+++ b/udmf/framework/innerkitsimpl/client/utd_client.cpp
@@ -13,26 +13,46 @@
  * limitations under the License.
  */
 #define LOG_TAG "UtdClient"
-#include <algorithm>
-#include <regex>
 #include "utd_client.h"
+
+#include <mutex>
+#include <regex>
+#include <thread>
+
+#include "accesstoken_kit.h"
+#include "common_event_manager.h"
+#include "common_event_subscriber.h"
+#include "common_event_support.h"
+#include "custom_utd_store.h"
+#include "ipc_skeleton.h"
 #include "logger.h"
+#include "os_account_manager.h"
 #include "utd_graph.h"
-#include "custom_utd_store.h"
-#include "base32_utils.h"
-#include "udmf_utils.h"
 namespace OHOS {
 namespace UDMF {
-constexpr const char* CUSTOM_TYPE_CFG_PATH = "/data/utd/utd-adt.json";
+constexpr const char *CUSTOM_UTD_HAP_DIR = "/data/utd/utd-adt.json";
+constexpr const char *CUSTOM_UTD_SA_DIR = "/data/service/el1/";
+constexpr const char *CUSTOM_UTD_SA_SUB_DIR = "/distributeddata/utd/utd-adt.json";
+
+class UtdChangeSubscriber final : public EventFwk::CommonEventSubscriber {
+public:
+    explicit UtdChangeSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo,
+        const std::function<void()> &callback);
+    virtual ~UtdChangeSubscriber() = default;
+    void OnReceiveEvent(const EventFwk::CommonEventData &data) override;
+
+private:
+    std::function<void()> callback_;
+};
+
 UtdClient::UtdClient()
 {
     Init();
+    SubscribeUtdChange();
     LOG_INFO(UDMF_CLIENT, "construct UtdClient sucess.");
 }
 
-UtdClient::~UtdClient()
-{
-}
+UtdClient::~UtdClient() {}
 
 UtdClient &UtdClient::GetInstance()
 {
@@ -42,27 +62,35 @@ UtdClient &UtdClient::GetInstance()
 
 void UtdClient::Init()
 {
+    std::unique_lock<std::shared_mutex> lock(utdMutex_);
     descriptorCfgs_ = PresetTypeDescriptors::GetInstance().GetPresetTypes();
-    std::vector<TypeDescriptorCfg> customTypes =
-        CustomUtdStore::GetInstance().GetTypeCfgs(CUSTOM_TYPE_CFG_PATH);
-    if (!customTypes.empty()) {
-        descriptorCfgs_.insert(descriptorCfgs_.end(), customTypes.begin(), customTypes.end());
+    std::string customUtdPath = GetCustomUtdPath();
+    if (!customUtdPath.empty()) {
+        std::vector<TypeDescriptorCfg> customTypes = CustomUtdStore::GetInstance().GetTypeCfgs(customUtdPath);
+        LOG_INFO(UDMF_CLIENT, "get customUtd. path:%{public}s, size:%{public}zu", customUtdPath.c_str(),
+            customTypes.size());
+        if (!customTypes.empty()) {
+            descriptorCfgs_.insert(descriptorCfgs_.end(), customTypes.begin(), customTypes.end());
+        }
     }
     UtdGraph::GetInstance().InitUtdGraph(descriptorCfgs_);
 }
 
 Status UtdClient::GetTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor)
 {
-    for (const auto &utdTypeCfg : descriptorCfgs_) {
-        if (utdTypeCfg.typeId == typeId) {
-            descriptor = std::make_shared<TypeDescriptor>(utdTypeCfg);
-            LOG_DEBUG(UDMF_CLIENT, "get descriptor success. %{public}s ", typeId.c_str());
-            return Status::E_OK;
+    {
+        std::shared_lock<std::shared_mutex> guard(utdMutex_);
+        for (const auto &utdTypeCfg : descriptorCfgs_) {
+            if (utdTypeCfg.typeId == typeId) {
+                descriptor = std::make_shared<TypeDescriptor>(utdTypeCfg);
+                LOG_DEBUG(UDMF_CLIENT, "get descriptor success. %{public}s ", typeId.c_str());
+                return Status::E_OK;
+            }
         }
     }
     if (typeId.find(FLEXIBLE_TYPE_FLAG) != typeId.npos) {
-        LOG_INFO(UDMF_CLIENT, "get flexible descriptor. %{public}s ", typeId.c_str());
-        GetFlexibleTypeDescriptor(typeId, descriptor);
+        LOG_DEBUG(UDMF_CLIENT, "get flexible descriptor. %{public}s ", typeId.c_str());
+        return GetFlexibleTypeDescriptor(typeId, descriptor);
     }
     return Status::E_OK;
 }
@@ -75,7 +103,7 @@ bool UtdClient::IsValidFileExtension(const std::string &fileExtension)
     if (fileExtension[0] != '.' || fileExtension.find("?") != fileExtension.npos ||
         fileExtension.find(":") != fileExtension.npos || fileExtension.find("=") != fileExtension.npos ||
         fileExtension.find("\\") != fileExtension.npos) {
-            return false;
+        return false;
     }
 
     return true;
@@ -87,8 +115,8 @@ bool UtdClient::IsValidMimeType(const std::string &mimeType)
         return false;
     }
     if (mimeType.find("?") != mimeType.npos || mimeType.find(":") != mimeType.npos ||
-        mimeType.find("=") != mimeType.npos ||mimeType.find("\\") != mimeType.npos) {
-            return false;
+        mimeType.find("=") != mimeType.npos || mimeType.find("\\") != mimeType.npos) {
+        return false;
     }
     return true;
 }
@@ -96,31 +124,35 @@ bool UtdClient::IsValidMimeType(const std::string &mimeType)
 Status UtdClient::GetFlexibleTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor)
 {
     TypeDescriptorCfg flexibleTypeDescriptorCfg;
-    FlexibleType::ParseFlexibleUtd(typeId, flexibleTypeDescriptorCfg);
+    if (!FlexibleType::ParseFlexibleUtd(typeId, flexibleTypeDescriptorCfg)) {
+        LOG_ERROR(UDMF_CLIENT, "ParseFlexibleUtd failed, invalid typeId: %{public}s", typeId.c_str());
+        return Status::E_ERROR;
+    }
     descriptor = std::make_shared<TypeDescriptor>(flexibleTypeDescriptorCfg);
     return Status::E_OK;
 }
 
 Status UtdClient::GetUniformDataTypeByFilenameExtension(const std::string &fileExtension, std::string &typeId,
-                                                        std::string belongsTo)
+    std::string belongsTo)
 {
     std::string lowerFileExtension = fileExtension;
     std::transform(lowerFileExtension.begin(), lowerFileExtension.end(), lowerFileExtension.begin(), ::tolower);
     if (belongsTo != DEFAULT_TYPE_ID && !UtdGraph::GetInstance().IsValidType(belongsTo)) {
         LOG_ERROR(UDMF_CLIENT, "invalid belongsTo. fileExtension:%{public}s, belongsTo:%{public}s ",
-                  fileExtension.c_str(), belongsTo.c_str());
+            fileExtension.c_str(), belongsTo.c_str());
         return Status::E_INVALID_PARAMETERS;
     }
-
-    for (const auto &utdTypeCfg : descriptorCfgs_) {
-        std::vector<std::string> fileExtensions = utdTypeCfg.filenameExtensions;
-        if (find(fileExtensions.begin(), fileExtensions.end(), lowerFileExtension) != fileExtensions.end() ||
-            find(fileExtensions.begin(), fileExtensions.end(), fileExtension) != fileExtensions.end()) {
-            typeId = utdTypeCfg.typeId;
-            break;
+    {
+        std::shared_lock<std::shared_mutex> guard(utdMutex_);
+        for (const auto &utdTypeCfg : descriptorCfgs_) {
+            std::vector<std::string> fileExtensions = utdTypeCfg.filenameExtensions;
+            if (find(fileExtensions.begin(), fileExtensions.end(), lowerFileExtension) != fileExtensions.end() ||
+                find(fileExtensions.begin(), fileExtensions.end(), fileExtension) != fileExtensions.end()) {
+                typeId = utdTypeCfg.typeId;
+                break;
+            }
         }
     }
-
     // the find typeId is not belongsTo to the belongsTo.
     if (!typeId.empty() && belongsTo != DEFAULT_TYPE_ID && belongsTo != typeId &&
         !UtdGraph::GetInstance().IsLowerLevelType(belongsTo, typeId)) {
@@ -130,7 +162,7 @@ Status UtdClient::GetUniformDataTypeByFilenameExtension(const std::string &fileE
     if (typeId.empty()) {
         if (!IsValidFileExtension(lowerFileExtension)) {
             LOG_ERROR(UDMF_CLIENT, "invalid fileExtension. fileExtension:%{public}s, belongsTo:%{public}s ",
-                      fileExtension.c_str(), belongsTo.c_str());
+                fileExtension.c_str(), belongsTo.c_str());
             return Status::E_INVALID_PARAMETERS;
         }
         typeId = FlexibleType::GenFlexibleUtd("", lowerFileExtension, belongsTo);
@@ -138,43 +170,154 @@ Status UtdClient::GetUniformDataTypeByFilenameExtension(const std::string &fileE
     return Status::E_OK;
 }
 
-Status UtdClient::GetUniformDataTypeByMIMEType(const std::string &mimeType, std::string &typeId,
-                                               std::string belongsTo)
+Status UtdClient::GetUniformDataTypesByFilenameExtension(const std::string &fileExtension,
+    std::vector<std::string> &typeIds, const std::string &belongsTo)
 {
-    std::string lowerMimeType = mimeType;
-    std::transform(lowerMimeType.begin(), lowerMimeType.end(), lowerMimeType.begin(), ::tolower);
     if (belongsTo != DEFAULT_TYPE_ID && !UtdGraph::GetInstance().IsValidType(belongsTo)) {
-        LOG_ERROR(UDMF_CLIENT, "invalid belongsTo. mimeType:%{public}s, belongsTo:%{public}s ",
-                  mimeType.c_str(), belongsTo.c_str());
+        LOG_ERROR(UDMF_CLIENT, "invalid belongsTo. fileExtension:%{public}s, belongsTo:%{public}s ",
+            fileExtension.c_str(), belongsTo.c_str());
+        return Status::E_INVALID_PARAMETERS;
+    }
+    if (!IsValidFileExtension(fileExtension)) {
+        LOG_ERROR(UDMF_CLIENT, "invalid fileExtension. fileExtension:%{public}s, belongsTo:%{public}s ",
+            fileExtension.c_str(), belongsTo.c_str());
         return Status::E_INVALID_PARAMETERS;
     }
 
-    for (const auto &utdTypeCfg : descriptorCfgs_) {
-        std::vector<std::string> mimeTypes = utdTypeCfg.mimeTypes;
-        if (find(mimeTypes.begin(), mimeTypes.end(), lowerMimeType) != mimeTypes.end() ||
-            find(mimeTypes.begin(), mimeTypes.end(), mimeType) != mimeTypes.end()) {
-            typeId = utdTypeCfg.typeId;
-            break;
+    std::string lowerFileExtension = fileExtension;
+    std::transform(lowerFileExtension.begin(), lowerFileExtension.end(), lowerFileExtension.begin(), ::tolower);
+    std::vector<std::string> typeIdsInCfg;
+    {
+        std::shared_lock<std::shared_mutex> guard(utdMutex_);
+        for (const auto &utdTypeCfg : descriptorCfgs_) {
+            std::vector<std::string> fileExtensions = utdTypeCfg.filenameExtensions;
+            if (find(fileExtensions.begin(), fileExtensions.end(), lowerFileExtension) != fileExtensions.end()) {
+                typeIdsInCfg.push_back(utdTypeCfg.typeId);
+            }
+        }
+    }
+    typeIds.clear();
+    for (const auto &typeId : typeIdsInCfg) {
+        // the find typeId is not belongsTo to the belongsTo.
+        if (belongsTo != DEFAULT_TYPE_ID && belongsTo != typeId &&
+            !UtdGraph::GetInstance().IsLowerLevelType(belongsTo, typeId)) {
+            continue;
         }
+        typeIds.emplace_back(typeId);
+    }
+    if (typeIds.empty()) {
+        typeIds.emplace_back(FlexibleType::GenFlexibleUtd("", lowerFileExtension, belongsTo));
+    }
+    return Status::E_OK;
+}
+
+Status UtdClient::GetUniformDataTypeByMIMEType(const std::string &mimeType, std::string &typeId, std::string belongsTo)
+{
+    std::string lowerMimeType = mimeType;
+    std::transform(lowerMimeType.begin(), lowerMimeType.end(), lowerMimeType.begin(), ::tolower);
+    if (belongsTo != DEFAULT_TYPE_ID && !UtdGraph::GetInstance().IsValidType(belongsTo)) {
+        LOG_ERROR(UDMF_CLIENT, "invalid belongsTo. mimeType:%{public}s, belongsTo:%{public}s ", mimeType.c_str(),
+            belongsTo.c_str());
+        return Status::E_INVALID_PARAMETERS;
     }
+    typeId = GetTypeIdFromCfg(lowerMimeType);
     // the find typeId is not belongsTo to the belongsTo.
     if (!typeId.empty() && belongsTo != DEFAULT_TYPE_ID && belongsTo != typeId &&
         !UtdGraph::GetInstance().IsLowerLevelType(belongsTo, typeId)) {
         typeId = "";
     }
-    
     if (typeId.empty()) {
         if (!IsValidMimeType(mimeType)) {
-            LOG_ERROR(UDMF_CLIENT, "invalid mimeType. mimeType:%{public}s, belongsTo:%{public}s ",
-                      mimeType.c_str(), belongsTo.c_str());
+            LOG_ERROR(UDMF_CLIENT, "invalid mimeType. mimeType:%{public}s, belongsTo:%{public}s ", mimeType.c_str(),
+                belongsTo.c_str());
             return Status::E_INVALID_PARAMETERS;
         }
         typeId = FlexibleType::GenFlexibleUtd(lowerMimeType, "", belongsTo);
     }
+    return Status::E_OK;
+}
 
+std::string UtdClient::GetTypeIdFromCfg(const std::string &mimeType)
+{
+    std::shared_lock<std::shared_mutex> guard(utdMutex_);
+    for (const auto &utdTypeCfg : descriptorCfgs_) {
+        for (auto mime : utdTypeCfg.mimeTypes) {
+            std::transform(mime.begin(), mime.end(), mime.begin(), ::tolower);
+            if (mime == mimeType) {
+                return utdTypeCfg.typeId;
+            }
+        }
+    }
+    if (mimeType.empty() || mimeType.back() != '*') {
+        return "";
+    }
+    std::string prefixType = mimeType.substr(0, mimeType.length() - 1);
+    for (const auto &utdTypeCfg : descriptorCfgs_) {
+        for (auto mime : utdTypeCfg.mimeTypes) {
+            std::transform(mime.begin(), mime.end(), mime.begin(), ::tolower);
+            if (mime.rfind(prefixType, 0) == 0 && utdTypeCfg.belongingToTypes.size() > 0) {
+                return utdTypeCfg.belongingToTypes[0];
+            }
+        }
+    }
+    return "";
+}
+
+Status UtdClient::GetUniformDataTypesByMIMEType(const std::string &mimeType, std::vector<std::string> &typeIds,
+    const std::string &belongsTo)
+{
+    if (belongsTo != DEFAULT_TYPE_ID && !UtdGraph::GetInstance().IsValidType(belongsTo)) {
+        LOG_ERROR(UDMF_CLIENT, "invalid belongsTo. mimeType:%{public}s, belongsTo:%{public}s ", mimeType.c_str(),
+            belongsTo.c_str());
+        return Status::E_INVALID_PARAMETERS;
+    }
+    if (!IsValidMimeType(mimeType)) {
+        LOG_ERROR(UDMF_CLIENT, "invalid mimeType. mimeType:%{public}s, belongsTo:%{public}s ", mimeType.c_str(),
+            belongsTo.c_str());
+        return Status::E_INVALID_PARAMETERS;
+    }
+
+    std::string lowerMimeType = mimeType;
+    std::transform(lowerMimeType.begin(), lowerMimeType.end(), lowerMimeType.begin(), ::tolower);
+    std::vector<std::string> typeIdsInCfg = GetTypeIdsFromCfg(lowerMimeType);
+    typeIds.clear();
+    for (const auto &typeId : typeIdsInCfg) {
+        // the find typeId is not belongsTo to the belongsTo.
+        if (belongsTo != DEFAULT_TYPE_ID && belongsTo != typeId &&
+            !UtdGraph::GetInstance().IsLowerLevelType(belongsTo, typeId)) {
+            continue;
+        }
+        typeIds.emplace_back(typeId);
+    }
+    if (typeIds.empty()) {
+        typeIds.emplace_back(FlexibleType::GenFlexibleUtd(lowerMimeType, "", belongsTo));
+    }
     return Status::E_OK;
 }
 
+std::vector<std::string> UtdClient::GetTypeIdsFromCfg(const std::string &mimeType)
+{
+    bool prefixMatch = false;
+    std::string prefixType;
+    if (!mimeType.empty() && mimeType.back() == '*') {
+        prefixType = mimeType.substr(0, mimeType.length() - 1);
+        prefixMatch = true;
+    }
+    std::vector<std::string> typeIdsInCfg;
+
+    std::shared_lock<std::shared_mutex> guard(utdMutex_);
+    for (const auto &utdTypeCfg : descriptorCfgs_) {
+        for (auto mime : utdTypeCfg.mimeTypes) {
+            std::transform(mime.begin(), mime.end(), mime.begin(), ::tolower);
+            if ((mime == mimeType) || (prefixMatch && mime.rfind(prefixType, 0) == 0)) {
+                typeIdsInCfg.push_back(utdTypeCfg.typeId);
+                break;
+            }
+        }
+    }
+    return typeIdsInCfg;
+}
+
 Status UtdClient::IsUtd(std::string typeId, bool &result)
 {
     try {
@@ -187,7 +330,7 @@ Status UtdClient::IsUtd(std::string typeId, bool &result)
             return Status::E_OK;
         }
         constexpr const char *preSetTypeIdRegexRule =
-            R"(^(general\.|openharmony\.|org\.|com\.|macos\.|debian\.|io\.|de\.|net\.)[a-z0-9-\.]+(\-[a-z0-9-]+)*$)";
+            R"(^(general\.|openharmony\.|org\.|com\.|macos\.|debian\.|redhat\.|io\.|de\.|net\.)[a-z0-9-\.]+(\-[a-z0-9-]+)*$)";
         if (std::regex_match(typeId, std::regex(preSetTypeIdRegexRule))) {
             result = true;
             return Status::E_OK;
@@ -208,5 +351,72 @@ Status UtdClient::IsUtd(std::string typeId, bool &result)
     return Status::E_OK;
 }
 
+bool UtdClient::IsHapTokenType()
+{
+    uint32_t tokenId = IPCSkeleton::GetSelfTokenID();
+    auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
+    LOG_DEBUG(UDMF_CLIENT, "GetTokenTypeFlag, tokenType = %{public}d.", tokenType);
+    if (tokenType == Security::AccessToken::TypeATokenTypeEnum::TOKEN_HAP) {
+        return true;
+    }
+    return false;
+}
+
+std::string UtdClient::GetCustomUtdPath()
+{
+    if (IsHapTokenType()) {
+        return std::string(CUSTOM_UTD_HAP_DIR);
+    }
+    int32_t userId = DEFAULT_USER_ID;
+    if (GetCurrentActiveUserId(userId) != Status::E_OK) {
+        return "";
+    }
+    std::string customUtdSaPath =
+        std::string(CUSTOM_UTD_SA_DIR) + std::to_string(userId) + std::string(CUSTOM_UTD_SA_SUB_DIR);
+    return customUtdSaPath;
+}
+
+Status UtdClient::GetCurrentActiveUserId(int32_t &userId)
+{
+    std::vector<int32_t> localIds;
+    int32_t status = OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(localIds);
+    if (status != Status::E_OK || localIds.empty()) {
+        LOG_ERROR(UDMF_CLIENT, "Get OsAccountId fail, status:%{public}d", status);
+        return Status::E_ERROR;
+    }
+    userId = localIds[0];
+    return Status::E_OK;
+}
+
+void UtdClient::SubscribeUtdChange()
+{
+    if (IsHapTokenType()) {
+        return;
+    }
+    LOG_INFO(UDMF_CLIENT, "subscribe utd change callback.");
+    EventFwk::MatchingSkills matchingSkills;
+    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED);
+    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_CHANGED);
+    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
+    EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
+    auto updateTask = []() {
+        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+        UtdClient::GetInstance().Init();
+    };
+    subscriber_ = std::make_shared<UtdChangeSubscriber>(subscribeInfo, updateTask);
+    (void)EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
+}
+
+UtdChangeSubscriber::UtdChangeSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo,
+    const std::function<void()> &callback)
+    : EventFwk::CommonEventSubscriber(subscribeInfo), callback_(callback)
+{
+}
+
+void UtdChangeSubscriber::OnReceiveEvent(const EventFwk::CommonEventData &data)
+{
+    LOG_INFO(UDMF_CLIENT, "start.");
+    std::thread(callback_).detach();
+}
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/framework/innerkitsimpl/common/unified_key.cpp b/udmf/framework/innerkitsimpl/common/unified_key.cpp
index 31d02c89ca0beb9ed8337f8f76673a02237dcaa5..1fa7eed11b4a209e37850ecfba6a379165939f7c 100644
--- a/udmf/framework/innerkitsimpl/common/unified_key.cpp
+++ b/udmf/framework/innerkitsimpl/common/unified_key.cpp
@@ -22,10 +22,10 @@ namespace UDMF {
 static std::bitset<MAX_BIT_SIZE> g_ruleIntention;
 static std::bitset<MAX_BIT_SIZE> g_ruleBundleName;
 static std::bitset<MAX_BIT_SIZE> g_ruleGroupId;
-static const std::string UNIFIED_KEY_SCHEMA = "udmf://";
-static const std::string ALPHA_AGGREGATE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-static const std::string DIGIT_AGGREGATE = "0123456789";
-static const std::string SYMBOL_AGGREGATE = ":;<=>?@[\\]_`";
+static constexpr const char *UNIFIED_KEY_SCHEMA = "udmf://";
+static constexpr const char *ALPHA_AGGREGATE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+static constexpr const char *DIGIT_AGGREGATE = "0123456789";
+static constexpr const char *SYMBOL_AGGREGATE = ":;<=>?@[\\]_`";
 UnifiedKey::UnifiedKey(std::string key)
 {
     this->key = std::move(key);
@@ -128,21 +128,21 @@ void UnifiedKey::PreliminaryWork()
 {
     // All intentions are composed of uppercase and lowercase letters and underscores.
     if (g_ruleIntention.none()) {
-        std::string intentionTmp = ALPHA_AGGREGATE + "_";
+        std::string intentionTmp = std::string(ALPHA_AGGREGATE) + "_";
         for (char i : intentionTmp) {
             g_ruleIntention.set(i);
         }
     }
     // All bundle name are composed of uppercase and lowercase letters and dots.
     if (g_ruleBundleName.none()) {
-        std::string bundleAggregate = ALPHA_AGGREGATE + DIGIT_AGGREGATE + "._";
+        std::string bundleAggregate = std::string(ALPHA_AGGREGATE) + DIGIT_AGGREGATE + "._";
         for (char i : bundleAggregate) {
             g_ruleBundleName.set(i);
         }
     }
     // Characters of groupId are taken from Ascii codes 48 to 122.
     if (g_ruleGroupId.none()) {
-        std::string idAggregate = DIGIT_AGGREGATE + ALPHA_AGGREGATE + SYMBOL_AGGREGATE;
+        std::string idAggregate = std::string(DIGIT_AGGREGATE) + ALPHA_AGGREGATE + SYMBOL_AGGREGATE;
         for (char i : idAggregate) {
             g_ruleGroupId.set(i);
         }
diff --git a/udmf/framework/innerkitsimpl/common/unified_meta.cpp b/udmf/framework/innerkitsimpl/common/unified_meta.cpp
index 3c20802e6f9dbe3c9a8a6c1c891ec4c51fd179cf..d02a1ad0a885f002ab395dc3ed2fdd8e8be7f118 100644
--- a/udmf/framework/innerkitsimpl/common/unified_meta.cpp
+++ b/udmf/framework/innerkitsimpl/common/unified_meta.cpp
@@ -13,8 +13,10 @@
  * limitations under the License.
  */
 
+#define LOG_TAG "UnifiedMeta"
 #include "unified_meta.h"
 
+#include "logger.h"
 #include "unified_key.h"
 
 namespace OHOS {
@@ -414,13 +416,47 @@ static constexpr UtdType UTD_TYPES[] = {
     { MICROSOFT_EMAIL, "MICROSOFT_EMAIL", "com.microsoft.email" },
     { MICROSOFT_MESSAGE, "MICROSOFT_MESSAGE", "com.microsoft.message" },
     { MICROSOFT_PST, "MICROSOFT_PST", "com.microsoft.pst" },
-    { KINSOFT_OFFICE, "KINSOFT_OFFICE", "com.kingsoft.office	general.zip-archive" },
-    { KINSOFT_WRITER_WPS, "KINSOFT_WRITER_WPS", "com.kingsoft.office.writer.wps" },
-    { KINSOFT_WRITER_WPT, "KINSOFT_WRITER_WPT", "com.kingsoft.office.writer.wpt" },
-    { KINSOFT_PRESENTATION_DPS, "KINSOFT_PRESENTATION_DPS", "com.kingsoft.office.presentation.dps" },
-    { KINSOFT_PRESENTATION_TEMPLATE, "KINSOFT_PRESENTATION_TEMPLATE", "com.kingsoft.office.presentation.template" },
-    { KINSOFT_SPREADSHEETS_ET, "KINSOFT_SPREADSHEETS_ET", "com.kingsoft.office.spreadsheets.et" },
-    { KINSOFT_SPREADSHEETS_TEMPLATE, "KINSOFT_SPREADSHEETS_TEMPLATE", "com.kingsoft.office.spreadsheets.template" }
+    { KINGSOFT_OFFICE, "KINGSOFT_OFFICE", "com.kingsoft.office	general.zip-archive" },
+    { KINGSOFT_WRITER_WPS, "KINGSOFT_WRITER_WPS", "com.kingsoft.office.writer.wps" },
+    { KINGSOFT_WRITER_WPT, "KINGSOFT_WRITER_WPT", "com.kingsoft.office.writer.wpt" },
+    { KINGSOFT_PRESENTATION_DPS, "KINGSOFT_PRESENTATION_DPS", "com.kingsoft.office.presentation.dps" },
+    { KINGSOFT_PRESENTATION_TEMPLATE, "KINGSOFT_PRESENTATION_TEMPLATE", "com.kingsoft.office.presentation.template" },
+    { KINGSOFT_SPREADSHEETS_ET, "KINGSOFT_SPREADSHEETS_ET", "com.kingsoft.office.spreadsheets.et" },
+    { KINGSOFT_SPREADSHEETS_TEMPLATE, "KINGSOFT_SPREADSHEETS_TEMPLATE", "com.kingsoft.office.spreadsheets.template" },
+    { MICROSOFT_INI, "MICROSOFT_INI", "com.microsoft.ini" },
+    { JSON, "JSON", "general.json" },
+    { YAML, "YAML", "general.yaml" },
+    { LOG, "LOG", "general.log" },
+    { URI, "URI", "general.uri" },
+    { FILE_URI, "FILE_URI", "general.file-uri" },
+    { TEXT_LST, "TEXT_LST", "general.text-lst" },
+    { ANDROID_APK, "ANDROID_APK", "com.android.apk" },
+    { BZ_ARCHIVE, "BZ_ARCHIVE", "general.bz-archive" },
+    { TBZ_ARCHIVE, "TBZ_ARCHIVE", "general.tar-bzip-archive" },
+    { TBZ2_ARCHIVE, "TBZ2_ARCHIVE", "general.tar-bzip2-archive" },
+    { XZ_ARCHIVE, "XZ_ARCHIVE", "org.tukaani.xz-archive" },
+    { TXZ_ARCHIVE, "TXZ_ARCHIVE", "org.tukaani.tar-xz-archive" },
+    { XAR_ARCHIVE, "XAR_ARCHIVE", "general.xar-archive" },
+    { CAB_ARCHIVE, "CAB_ARCHIVE", "com.microsoft.cab-archive" },
+    { RPM_ARCHIVE, "RPM_ARCHIVE", "redhat.rpm-archive" },
+    { TPZ_ARCHIVE, "TPZ_ARCHIVE", "org.godotengine.tpz-archive", },
+    { LZA_ARCHIVE, "LZA_ARCHIVE", "general.lza-archive" },
+    { ARJ_ARCHIVE, "ARJ_ARCHIVE", "general.arj-archive" },
+    { ZIPX_ARCHIVE, "ZIPX_ARCHIVE", "com.winzip.zipx" },
+    { LZMA_ARCHIVE, "LZMA_ARCHIVE", "general.lzma-archive" },
+    { LZMA86_ARCHIVE, "LZMA86_ARCHIVE", "general.lzma86-archive" },
+    { XPI_ARCHIVE, "XPI_ARCHIVE", "org.mozilla.xpinstall" },
+    { HFS_DISK_IMAGE, "HFS_DISK_IMAGE", "general.hfs-disk-image" },
+    { IMG_DISK_IMAGE, "IMG_DISK_IMAGE", "general.img-disk-image" },
+    { ISZ_DISK_IMAGE, "ISZ_DISK_IMAGE", "com.ezbsystems.zipped-iso" },
+    { WIM_DISK_IMAGE, "WIM_DISK_IMAGE", "com.microsoft.wim" },
+    { SWM_DISK_IMAGE, "SWM_DISK_IMAGE", "com.microsoft.swm" },
+    { KINGSOFT_SPREADSHEETS_ETX, "KINGSOFT_SPREADSHEETS_ETX", "com.kingsoft.office.spreadsheets.etx" },
+    { KINGSOFT_SPREADSHEETS_ETTX, "KINGSOFT_SPREADSHEETS_ETTX", "com.kingsoft.office.spreadsheets.ettx" },
+    { EXCEL_DIF, "EXCEL_DIF", "com.microsoft.excel.dif" },
+    { OPENHARMONY_APP, "OPENHARMONY_APP", "openharmony.app" },
+    { HMOS_WIFI, "HMOS_WIFI", "com.huawei.hmos.settings.wifi" },
+    { TEL, "TEL", "general.tel" }
 };
 
 namespace UtdUtils {
@@ -579,5 +615,45 @@ bool UnifiedDataUtils::IsValidOptions(const std::string &key, std::string &inten
     }
     return false;
 }
+
+bool Object::GetValue(const std::string &key, std::string &value)
+{
+    auto it = value_.find(key);
+    if (it != value_.end() && std::holds_alternative<std::string>(it->second)) {
+        value = std::get<std::string>(it->second);
+        return true;
+    }
+    return false;
+}
+
+bool Object::GetValue(const std::string &key, std::shared_ptr<Object> &value)
+{
+    auto it = value_.find(key);
+    if (it != value_.end() && std::holds_alternative<std::shared_ptr<Object>>(it->second)) {
+        value = std::get<std::shared_ptr<Object>>(it->second);
+        return true;
+    }
+    return false;
+}
+
+std::shared_ptr<Object> ObjectUtils::ConvertToObject(UDDetails &details)
+{
+    Object object;
+    for (auto [key, value] : details) {
+        ConvertVariant(std::move(value), object.value_[key]);
+    }
+    return std::make_shared<Object>(object);
+}
+
+UDDetails ObjectUtils::ConvertToUDDetails(std::shared_ptr<Object> object)
+{
+    UDDetails details;
+    for (auto [key, value] : object->value_) {
+        if (!ConvertVariant(std::move(value), details[key])) {
+            LOG_ERROR(UnifiedRecord, "object convert to UDDetails failed, object key is %{public}s", key.c_str());
+        }
+    }
+    return details;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/convert/ndk_data_conversion.cpp b/udmf/framework/innerkitsimpl/convert/ndk_data_conversion.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f29312d903cbc952f8da7cc471e59c5d8de2d095
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/convert/ndk_data_conversion.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ndk_data_conversion.h"
+
+#include "udmf_capi_common.h"
+namespace OHOS::UDMF {
+Status NdkDataConversion::GetNativeUnifiedData(OH_UdmfData *ndkData, std::shared_ptr<UnifiedData> &data)
+{
+    if (ndkData == nullptr || data == nullptr || ndkData->cid != NdkStructId::UDMF_UNIFIED_DATA_STRUCT_ID) {
+        return Status::E_INVALID_PARAMETERS;
+    }
+    data = ndkData->unifiedData_;
+    return Status::E_OK;
+}
+
+Status NdkDataConversion::GetNdkUnifiedData(std::shared_ptr<UnifiedData> data, OH_UdmfData *ndkData)
+{
+    if (data == nullptr || ndkData == nullptr || ndkData->cid != NdkStructId::UDMF_UNIFIED_DATA_STRUCT_ID) {
+        return Status::E_INVALID_PARAMETERS;
+    }
+    ndkData->unifiedData_ = data;
+    return Status::E_OK;
+}
+} // namespace OHOS::UDMF
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/application_defined_record.cpp b/udmf/framework/innerkitsimpl/data/application_defined_record.cpp
index d8c73a454ca8b54b9175ffd5b77a2c4e34b5220e..121e9520e50939ebe8627a50e71b31bb181534b4 100644
--- a/udmf/framework/innerkitsimpl/data/application_defined_record.cpp
+++ b/udmf/framework/innerkitsimpl/data/application_defined_record.cpp
@@ -33,8 +33,10 @@ ApplicationDefinedRecord::ApplicationDefinedRecord(std::string type, std::vector
     this->rawData_ = std::move(data);
 }
 
-ApplicationDefinedRecord::ApplicationDefinedRecord(UDType type, ValueType value) : UnifiedRecord(type, value)
+ApplicationDefinedRecord::ApplicationDefinedRecord(UDType type, ValueType value)
+    : UnifiedRecord(type, value)
 {
+    this->dataType_ = APPLICATION_DEFINED_RECORD;
     if (std::holds_alternative<std::vector<uint8_t>>(value)) {
         rawData_ = std::get<std::vector<uint8_t>>(value);
     }
diff --git a/udmf/framework/innerkitsimpl/data/audio.cpp b/udmf/framework/innerkitsimpl/data/audio.cpp
index 95e06c0708fd9435ab531312164dcd0b98bb43c4..15682d94777a25e5bc20f7da77afabc3532cc21d 100644
--- a/udmf/framework/innerkitsimpl/data/audio.cpp
+++ b/udmf/framework/innerkitsimpl/data/audio.cpp
@@ -26,6 +26,9 @@ Audio::Audio(const std::string &uri) : File(uri)
     this->dataType_ = AUDIO;
 }
 
-Audio::Audio(UDType type, ValueType value) : File(type, value) {}
+Audio::Audio(UDType type, ValueType value) : File(type, value)
+{
+    this->dataType_ = AUDIO;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/file.cpp b/udmf/framework/innerkitsimpl/data/file.cpp
index 646e0cfe6512fc10a539f72d9108a1b571b54092..7a7130560ecbc3e088a11dc5aa847f3440f9163a 100644
--- a/udmf/framework/innerkitsimpl/data/file.cpp
+++ b/udmf/framework/innerkitsimpl/data/file.cpp
@@ -28,6 +28,7 @@ File::File(const std::string &uri) : UnifiedRecord(FILE)
 
 File::File(UDType type, ValueType value) : UnifiedRecord(type, value)
 {
+    this->dataType_ = FILE;
     if (std::holds_alternative<std::string>(value)) {
         oriUri_ = std::get<std::string>(value);
     }
diff --git a/udmf/framework/innerkitsimpl/data/flexible_type.cpp b/udmf/framework/innerkitsimpl/data/flexible_type.cpp
index 772699792547b2b2318c28c78ae27d07e4025c4b..df90795277a41289214c0d4613b0c085de204770 100644
--- a/udmf/framework/innerkitsimpl/data/flexible_type.cpp
+++ b/udmf/framework/innerkitsimpl/data/flexible_type.cpp
@@ -39,15 +39,23 @@ bool FlexibleType::ParseFlexibleUtd(const std::string &typeId, TypeDescriptorCfg
     std::string flexibleFlag = FLEXIBLE_TYPE_FLAG;
     flexibleUtd.erase(0, flexibleFlag.size());
     std::string flexibleUtdDecode = Base32::Decode(flexibleUtd);
-    
-    LOG_INFO(UDMF_CLIENT, "The typeId be parsed, flexibleUtdDecode：%{public}s ", flexibleUtdDecode.c_str());
-    if (flexibleUtdDecode[0] != '?' || flexibleUtdDecode.find("=") == flexibleUtdDecode.npos) {
+
+    LOG_DEBUG(UDMF_CLIENT, "The typeId be parsed, flexibleUtdDecode: %{public}s", flexibleUtdDecode.c_str());
+    if (flexibleUtdDecode.empty() || flexibleUtdDecode[0] != '?' ||
+            flexibleUtdDecode.find("=") == flexibleUtdDecode.npos) {
         LOG_WARN(UDMF_CLIENT, "The typeId cannot be parsed, %{public}s ", typeId.c_str());
         return false;
     }
     std::vector<std::string> flexibleTypeAttrs = UTILS::StrSplit(flexibleUtdDecode, ":");
     for (auto attr : flexibleTypeAttrs) {
         std::vector<std::string> attrkv = UTILS::StrSplit(attr, "=");
+        if (attrkv.size() != ATTRIBUTE_PAIR_SIZE) {
+            continue;
+        }
+        if (attrkv[1].length() > MAX_TYPE_SIZE) {
+            LOG_ERROR(UDMF_CLIENT, "Attribute too long, attribute: %{public}s", attr.c_str());
+            return false;
+        }
         std::string attrName = attrkv[0];
         if (attrName.find(std::to_string(BELONGINGTO_TYPE)) != attrName.npos) {
             flexibleTypeDescriptorCfg.belongingToTypes.push_back(attrkv[1]);
@@ -73,7 +81,10 @@ std::string FlexibleType::GenFlexibleUtd(const std::string &mimeType, const std:
     if (!fileExtension.empty()) {
         flexibleUtd += ":" + std::to_string(FILE_EXTENTSION) + "=" + fileExtension;
     }
-    return FLEXIBLE_TYPE_FLAG + Base32::Encode(flexibleUtd);
+    std::string encodeUtd = Base32::Encode(flexibleUtd);
+    LOG_DEBUG(UDMF_CLIENT, "FlexibleUtd typeId is: %{public}s, encodeUtd is: %{public}s",
+        flexibleUtd.c_str(), encodeUtd.c_str());
+    return FLEXIBLE_TYPE_FLAG + encodeUtd;
 }
 
 } // namespace UDMF
diff --git a/udmf/framework/innerkitsimpl/data/folder.cpp b/udmf/framework/innerkitsimpl/data/folder.cpp
index 2e6f74c83ca63f9d9ff26145825f752d2d0e7518..3bb45e93fcd697eea507c13fd5bfbd127fbdc002 100644
--- a/udmf/framework/innerkitsimpl/data/folder.cpp
+++ b/udmf/framework/innerkitsimpl/data/folder.cpp
@@ -26,6 +26,9 @@ Folder::Folder(const std::string &uri) : File(uri)
     this->dataType_ = FOLDER;
 }
 
-Folder::Folder(UDType type, ValueType value) : File(type, value) {}
+Folder::Folder(UDType type, ValueType value) : File(type, value)
+{
+    this->dataType_ = FOLDER;
+}
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/framework/innerkitsimpl/data/html.cpp b/udmf/framework/innerkitsimpl/data/html.cpp
index 9746f209246d64d6ca5670dae356a6470f31b458..cc25b026ea3d69bc88f304bc4b455f3b0595f29b 100644
--- a/udmf/framework/innerkitsimpl/data/html.cpp
+++ b/udmf/framework/innerkitsimpl/data/html.cpp
@@ -19,7 +19,7 @@ namespace OHOS {
 namespace UDMF {
 Html::Html()
 {
-    this->dataType_ = HTML;
+    SetType(HTML);
 }
 
 Html::Html(const std::string &htmlContent, const std::string &plainContent)
@@ -27,15 +27,24 @@ Html::Html(const std::string &htmlContent, const std::string &plainContent)
     if (plainContent.length() >= MAX_TEXT_LEN || htmlContent.length() >= MAX_TEXT_LEN) {
         return;
     }
-    this->dataType_ = HTML;
+    SetType(HTML);
     this->htmlContent_ = htmlContent;
     this->plainContent_ = plainContent;
 }
 
 Html::Html(UDType type, ValueType value) : Text(type, value)
 {
+    SetType(HTML);
     if (std::holds_alternative<std::string>(value)) {
         htmlContent_ = std::get<std::string>(value);
+    } else if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        auto object = std::get<std::shared_ptr<Object>>(value);
+        object->GetValue(HTML_CONTENT, htmlContent_);
+        object->GetValue(PLAINT_CONTENT, plainContent_);
+        std::shared_ptr<Object> detailObj = nullptr;
+        if (object->GetValue(DETAILS, detailObj)) {
+            details_ = ObjectUtils::ConvertToUDDetails(detailObj);
+        }
     }
 }
 
@@ -55,6 +64,7 @@ void Html::SetHtmlContent(const std::string &htmlContent)
         return;
     }
     this->htmlContent_ = htmlContent;
+    InitObject();
 }
 
 std::string Html::GetPlainContent() const
@@ -68,6 +78,27 @@ void Html::SetPlainContent(const std::string &plainContent)
         return;
     }
     this->plainContent_ = plainContent;
+    InitObject();
+}
+
+ValueType Html::GetValue()
+{
+    if (std::holds_alternative<std::monostate>(value_)) {
+        value_ = std::make_shared<Object>();
+    }
+    InitObject();
+    return value_;
+}
+
+void Html::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[UNIFORM_DATA_TYPE] = UtdUtils::GetUtdIdFromUtdEnum(dataType_);
+        object->value_[HTML_CONTENT] = htmlContent_;
+        object->value_[PLAINT_CONTENT] = plainContent_;
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
 }
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/image.cpp b/udmf/framework/innerkitsimpl/data/image.cpp
index 0af8a8543ce2c40adbaad0ffaac7e1c4e9755402..a2a891d3a0c4e12d26a49326a2e96ccf7aa6f9aa 100644
--- a/udmf/framework/innerkitsimpl/data/image.cpp
+++ b/udmf/framework/innerkitsimpl/data/image.cpp
@@ -26,6 +26,9 @@ Image::Image(const std::string &uri) : File(uri)
     this->dataType_ = IMAGE;
 }
 
-Image::Image(UDType type, ValueType value) : File(type, value) {}
+Image::Image(UDType type, ValueType value) : File(type, value)
+{
+    this->dataType_ = IMAGE;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/link.cpp b/udmf/framework/innerkitsimpl/data/link.cpp
index bbfecd8c1695551bef3b328b42eb4f83922481e4..eb41e2da081a0b51ed6dd527bb49a7aab425a49d 100644
--- a/udmf/framework/innerkitsimpl/data/link.cpp
+++ b/udmf/framework/innerkitsimpl/data/link.cpp
@@ -27,8 +27,17 @@ Link::Link(const std::string &url) : Link(url, "")
 
 Link::Link(UDType type, ValueType value) : Text(type, value)
 {
+    SetType(HYPERLINK);
     if (std::holds_alternative<std::string>(value)) {
         url_ = std::get<std::string>(value);
+    } else if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        auto object = std::get<std::shared_ptr<Object>>(value);
+        object->GetValue(URL, url_);
+        object->GetValue(DESCRIPTION, description_);
+        std::shared_ptr<Object> detailObj = nullptr;
+        if (object->GetValue(DETAILS, detailObj)) {
+            details_ = ObjectUtils::ConvertToUDDetails(detailObj);
+        }
     }
 }
 
@@ -37,7 +46,7 @@ Link::Link(const std::string &url, const std::string &description)
     if (url.length() >= MAX_TEXT_LEN || description.length() >= MAX_TEXT_LEN) {
         return;
     }
-    this->dataType_ = HYPERLINK;
+    SetType(HYPERLINK);
     this->url_ = url;
     this->description_ = description;
 }
@@ -58,6 +67,7 @@ void Link::SetUrl(const std::string &url)
         return;
     }
     this->url_ = url;
+    InitObject();
 }
 
 std::string Link::GetDescription() const
@@ -71,6 +81,27 @@ void Link::SetDescription(const std::string &description)
         return;
     }
     this->description_ = description;
+    InitObject();
+}
+
+ValueType Link::GetValue()
+{
+    if (std::holds_alternative<std::monostate>(value_)) {
+        value_ = std::make_shared<Object>();
+    }
+    InitObject();
+    return value_;
+}
+
+void Link::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[UNIFORM_DATA_TYPE] = UtdUtils::GetUtdIdFromUtdEnum(dataType_);
+        object->value_[URL] = url_;
+        object->value_[DESCRIPTION] = description_;
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
 }
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/plain_text.cpp b/udmf/framework/innerkitsimpl/data/plain_text.cpp
index 88a019099638e5fa0ba43c3c44d10d2b55e927f3..718ccdf4a9445e792fa9e8d06f214dc2e80012d1 100644
--- a/udmf/framework/innerkitsimpl/data/plain_text.cpp
+++ b/udmf/framework/innerkitsimpl/data/plain_text.cpp
@@ -26,15 +26,24 @@ PlainText::PlainText(const std::string &content, const std::string &abstract)
     if (content.length() >= MAX_TEXT_LEN) {
         return;
     }
-    this->dataType_ = PLAIN_TEXT;
+    SetType(PLAIN_TEXT);
     this->content_ = content;
     this->abstract_ = abstract;
 }
 
 PlainText::PlainText(UDType type, ValueType value) : Text(type, value)
 {
+    SetType(PLAIN_TEXT);
     if (std::holds_alternative<std::string>(value)) {
         content_ = std::get<std::string>(value);
+    } else if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        auto object = std::get<std::shared_ptr<Object>>(value);
+        object->GetValue(TEXT_CONTENT, content_);
+        object->GetValue(ABSTRACT, abstract_);
+        std::shared_ptr<Object> detailObj = nullptr;
+        if (object->GetValue(DETAILS, detailObj)) {
+            details_ = ObjectUtils::ConvertToUDDetails(detailObj);
+        }
     }
 }
 
@@ -54,6 +63,7 @@ void PlainText::SetContent(const std::string &text)
         return;
     }
     this->content_ = text;
+    InitObject();
 }
 
 std::string PlainText::GetAbstract() const
@@ -67,6 +77,27 @@ void PlainText::SetAbstract(const std::string &abstract)
         return;
     }
     this->abstract_ = abstract;
+    InitObject();
+}
+
+ValueType PlainText::GetValue()
+{
+    if (std::holds_alternative<std::monostate>(value_)) {
+        value_ = std::make_shared<Object>();
+    }
+    InitObject();
+    return value_;
+}
+
+void PlainText::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[UNIFORM_DATA_TYPE] = UtdUtils::GetUtdIdFromUtdEnum(dataType_);
+        object->value_[TEXT_CONTENT] = content_;
+        object->value_[ABSTRACT] = abstract_;
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
 }
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/framework/innerkitsimpl/data/preset_type_descriptors.cpp b/udmf/framework/innerkitsimpl/data/preset_type_descriptors.cpp
index 685e7c2483178dca0da5d78b47130d415023ce33..a4aaafcd45174af08b4af1880f55d676e7d66717 100644
--- a/udmf/framework/innerkitsimpl/data/preset_type_descriptors.cpp
+++ b/udmf/framework/innerkitsimpl/data/preset_type_descriptors.cpp
@@ -105,7 +105,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"general.source-code",
-         {"general.plain-text"},
+         {"general.text"},
          {},
          {},
          "Generic source code.",
@@ -177,7 +177,7 @@ void PresetTypeDescriptors::InitDescriptors()
         {"general.c-header",
          {"general.source-code"},
          {".h"},
-         {"text/-chdr"},
+         {"text/x-chdr"},
          "C header file.",
          REFERENCE_URL,
          ""},
@@ -205,13 +205,13 @@ void PresetTypeDescriptors::InitDescriptors()
         {"general.java-source",
          {"general.source-code"},
          {".java", ".jav"},
-         {},
+         {"text/x-java"},
          "Java source code.",
          REFERENCE_URL,
          ""},
          {"general.markdown",
-         {"general.plain-text"},
-         {".md"},
+         {"general.text"},
+         {".md", ".markdown", ".markdn", ".mdown"},
          {"text/markdown"},
          "Markdown format.",
          REFERENCE_URL,
@@ -666,7 +666,7 @@ void PresetTypeDescriptors::InitDescriptors()
          "sys.media.ohos_ic_normal_white_grid_compress"},
         {"general.bz2-archive",
          {"general.archive"},
-         {".bz2"},
+         {".bz2", ".bzip2"},
          {"application/x-bzip2"},
          "BZip2 archive.",
          REFERENCE_URL,
@@ -721,7 +721,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          "sys.media.ohos_ic_normal_white_grid_compress"},
         {"org.openxmlformats.openxml",
-         {"general.zip-archive"},
+         {"general.archive"},
          {},
          {},
          "Office Open XML.",
@@ -749,7 +749,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"org.oasis.opendocument",
-         {"general.zip-archive"},
+         {"general.archive"},
          {},
          {},
          "Open Document Format for Office Applications.",
@@ -916,20 +916,6 @@ void PresetTypeDescriptors::InitDescriptors()
          "PostScript font.",
          REFERENCE_URL,
          ""},
-        {"com.adobe.postscript-pfb-font",
-         {"com.adobe.postscript-font"},
-         {".pfb"},
-         {},
-         "Printer Font Binary, PostScript Type 1 outline font.",
-         REFERENCE_URL,
-         ""},
-        {"com.adobe.postscript-pfa-font",
-         {"com.adobe.postscript-font"},
-         {".pfa"},
-         {},
-         "Printer Pont ASCII file, PostScript Type 1 outline font.",
-         REFERENCE_URL,
-         ""},
         {"openharmony.form",
          {"general.object"},
          {},
@@ -1323,7 +1309,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"general.virtual-cd",
-         {"general.image"},
+         {"general.disk-image"},
          {".vcd"},
          {"application/x-cdlink"},
          "Virtual CD",
@@ -1876,7 +1862,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"org.openoffice",
-         {"general.zip-archive"},
+         {"general.archive"},
          {},
          {},
          "OpenOffice document format for open-source office software suite",
@@ -1953,7 +1939,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"com.staroffice",
-         {"general.zip-archive"},
+         {"general.archive"},
          {},
          {},
          "StarOffice document format",
@@ -2478,14 +2464,14 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"com.edrawsoft.edrawmax",
-         {"general.xml"},
+         {"general.composite-object"},
          {".eddx"},
          {"application/x-eddx"},
          "Edraw Max XML file",
          REFERENCE_URL,
          ""},
         {"com.edrawsoft.edrawmind",
-         {"general.xml"},
+         {"general.composite-object"},
          {".emmx"},
          {"application/x-emmx"},
          "Edraw MindMaster XML file",
@@ -2695,7 +2681,7 @@ void PresetTypeDescriptors::InitDescriptors()
          REFERENCE_URL,
          ""},
         {"com.kingsoft.office",
-         {"general.zip-archive"},
+         {"general.archive"},
          {},
          {},
          "Kingsoft office suite",
@@ -2742,7 +2728,259 @@ void PresetTypeDescriptors::InitDescriptors()
          {},
          "Kingsoft Spreadsheets template",
          REFERENCE_URL,
-         ""}
+         ""},
+        {"com.microsoft.ini",
+         {"general.text"},
+         {".ini"},
+         {},
+         "Windows Initialization File",
+         REFERENCE_URL,
+         ""},
+        {"general.json",
+         {"general.script"},
+         {".json"},
+         {"application/json"},
+         "JavaScript Object Notation File",
+         REFERENCE_URL,
+         ""},
+        {"general.yaml",
+         {"general.script"},
+         {".yaml", ".yml"},
+         {"application/yaml"},
+         "YAML Document",
+         REFERENCE_URL,
+         ""},
+        {"general.log",
+         {"general.text"},
+         {".log"},
+         {"text/plain"},
+         "Log File",
+         REFERENCE_URL,
+         ""},
+        {"general.uri",
+         {"general.object"},
+         {},
+         {},
+         "Universal Resource Identifier",
+         REFERENCE_URL,
+         ""},
+        {"general.file-uri",
+         {"general.uri"},
+         {},
+         {},
+         "File URI",
+         REFERENCE_URL,
+         ""},
+        {"general.text-lst",
+         {"general.plain-text"},
+         {".lst"},
+         {},
+         "Data List",
+         REFERENCE_URL,
+         ""},
+        {"com.android.apk",
+         {"general.archive"},
+         {".apk", ".apks", ".aab", ".xapk", ".apkm", ".akp"},
+         {"application/vnd.android.package-archive"},
+         "Android Package File",
+         REFERENCE_URL,
+         ""},
+         {"com.adobe.postscript-pfb-font",
+         {"com.adobe.postscript-font"},
+         {".pfb"},
+         {"application/x-font"},
+         "Printer Font Binary, PostScript Type 1 outline font.",
+         REFERENCE_URL,
+         ""},
+        {"com.adobe.postscript-pfa-font",
+         {"com.adobe.postscript-font"},
+         {".pfa"},
+         {"application/x-font"},
+         "Printer Pont ASCII file, PostScript Type 1 outline font.",
+         REFERENCE_URL,
+         ""},
+        {"general.bz-archive",
+         {"general.archive"},
+         {".bz"},
+         {"application/x-bzip"},
+         "Bzip Compressed File",
+         REFERENCE_URL,
+         ""},
+        {"general.tar-bzip-archive",
+         {"general.bz-archive"},
+         {".tbz"},
+         {"application/x-bzip-compressed-tar"},
+         "Bzip Compressed Tar Archive",
+         REFERENCE_URL,
+         ""},
+        {"general.tar-bzip2-archive",
+         {"general.bz2-archive"},
+         {".tbz2"},
+         {"application/x-bzip2-compressed-tar"},
+         "Bzip2-Compressed TAR File",
+         REFERENCE_URL,
+         ""},
+        {"org.tukaani.xz-archive",
+         {"general.archive"},
+         {".xz"},
+         {"application/x-xz"},
+         "XZ Compressed Archive",
+         REFERENCE_URL,
+         ""},
+        {"org.tukaani.tar-xz-archive",
+         {"org.tukaani.xz-archive"},
+         {".txz"},
+         {"application/x-xz-compressed-tar"},
+         "XZ Compressed Tar Archive",
+         REFERENCE_URL,
+         ""},
+        {"general.xar-archive",
+         {"general.archive"},
+         {".xar"},
+         {"application/x-xar"},
+         "Extensible Archive Fromat",
+         REFERENCE_URL,
+         ""},
+        {"com.microsoft.cab-archive",
+         {"general.archive"},
+         {".cab"},
+         {"application/vnd.ms-cab-compressed"},
+         "Windows Cabinet File",
+         REFERENCE_URL,
+         ""},
+        {"redhat.rpm-archive",
+         {"general.archive"},
+         {".rpm"},
+         {"application/x-rpm"},
+         "RedHat Package Manager File",
+         REFERENCE_URL,
+         ""},
+        {"org.godotengine.tpz-archive",
+         {"general.archive"},
+         {".tpz"},
+         {},
+         "Godot Engine Export Template Archive",
+         REFERENCE_URL,
+         ""},
+        {"general.lza-archive",
+         {"general.archive"},
+         {".lza"},
+         {"application/x-lzh-compressed"},
+         "LZA Compressed Archive",
+         REFERENCE_URL,
+         ""},
+        {"general.arj-archive",
+         {"general.archive"},
+         {".arj"},
+         {"application/x-arj"},
+         "ARJ Compressed File Archive",
+         REFERENCE_URL,
+         ""},
+        {"com.winzip.zipx",
+         {"general.archive"},
+         {".zipx"},
+         {},
+         "Extended Zip Archive",
+         REFERENCE_URL,
+         ""},
+        {"general.lzma-archive",
+         {"general.archive"},
+         {".lzma"},
+         {"application/x-lzma"},
+         "LZMA Compressed File",
+         REFERENCE_URL,
+         ""},
+        {"general.lzma86-archive",
+         {"general.archive"},
+         {".lzma86"},
+         {},
+         "LZMA86 Compressed File",
+         REFERENCE_URL,
+         ""},
+        {"org.mozilla.xpinstall",
+         {"general.archive"},
+         {".xpi"},
+         {"application/x-xpinstall"},
+         "Cross-platform Installer Package",
+         REFERENCE_URL,
+         ""},
+        {"general.hfs-disk-image",
+         {"general.disk-image"},
+         {".hfs"},
+         {},
+         "HFS Disk Image File",
+         REFERENCE_URL,
+         ""},
+        {"general.img-disk-image",
+         {"general.disk-image"},
+         {".img"},
+         {"application/x-raw-disk-image"},
+         "Disc Image Data File",
+         REFERENCE_URL,
+         ""},
+        {"com.ezbsystems.zipped-iso",
+         {"general.disk-image"},
+         {".isz"},
+         {},
+         "Zipped ISO Disk Image",
+         REFERENCE_URL,
+         ""},
+        {"com.microsoft.wim",
+         {"general.disk-image"},
+         {".wim"},
+         {"application/x-ms-wim"},
+         "Windows Imaging Format File",
+         REFERENCE_URL,
+         ""},
+        {"com.microsoft.swm",
+         {"general.disk-image"},
+         {".swm"},
+         {"application/x-ms-wim"},
+         "Split Windows Imaging Format",
+         REFERENCE_URL,
+         ""},
+        {"com.kingsoft.office.spreadsheets.etx",
+         {"com.kingsoft.office", "general.composite-object"},
+         {".etx"},
+         {},
+         "Kingsoft Spreadsheets File",
+         REFERENCE_URL,
+         ""},
+        {"com.kingsoft.office.spreadsheets.ettx",
+         {"com.kingsoft.office", "general.composite-object"},
+         {".ettx"},
+         {},
+         "Kingsoft Spreadsheets Template",
+         REFERENCE_URL,
+         ""},
+        {"com.microsoft.excel.dif",
+         {"general.composite-object"},
+         {".dif"},
+         {},
+         "Data interchange format",
+         REFERENCE_URL,
+         ""},
+        {"openharmony.app",
+         {"openharmony.package"},
+         {".app"},
+         {},
+         "OpenHarmony system defined application package",
+         REFERENCE_URL,
+         ""},
+        {"com.huawei.hmos.settings.wifi",
+         {"general.text"},
+         {".hmoswifi"},
+         {},
+         "HarmonyOS WIFI sharing setting",
+         REFERENCE_URL,
+         ""},
+        {"general.tel",
+         {"general.text"},
+         {".tel"},
+         {},
+         "TEL schematic diagram file format",
+         REFERENCE_URL,
+         ""},
     };
 }
 } // namespace UDMF
diff --git a/udmf/framework/innerkitsimpl/data/system_defined_appitem.cpp b/udmf/framework/innerkitsimpl/data/system_defined_appitem.cpp
index db21330659ada0e4a75dda998bb3a55dbc4f212e..39d67a9fd80acd43b2377c3c910df59595399ffe 100644
--- a/udmf/framework/innerkitsimpl/data/system_defined_appitem.cpp
+++ b/udmf/framework/innerkitsimpl/data/system_defined_appitem.cpp
@@ -19,11 +19,27 @@ namespace OHOS {
 namespace UDMF {
 SystemDefinedAppItem::SystemDefinedAppItem()
 {
-    this->dataType_ = SYSTEM_DEFINED_APP_ITEM;
+    SetType(SYSTEM_DEFINED_APP_ITEM);
+}
+
+SystemDefinedAppItem::SystemDefinedAppItem(UDType type, ValueType value) : SystemDefinedRecord(type, value)
+{
+    SetType(SYSTEM_DEFINED_APP_ITEM);
+    if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        auto object = std::get<std::shared_ptr<Object>>(value);
+        object->GetValue(APPID, appId_);
+        object->GetValue(APPNAME, appName_);
+        object->GetValue(APPICONID, appIconId_);
+        object->GetValue(APPLABELID, appLabelId_);
+        object->GetValue(BUNDLENAME, bundleName_);
+        object->GetValue(ABILITYNAME, abilityName_);
+        std::shared_ptr<Object> detailObj = nullptr;
+        if (object->GetValue(DETAILS, detailObj)) {
+            details_ = ObjectUtils::ConvertToUDDetails(detailObj);
+        }
+    }
 }
 
-SystemDefinedAppItem::SystemDefinedAppItem(UDType type, ValueType value) : SystemDefinedRecord(type, value) {}
-
 int64_t SystemDefinedAppItem::GetSize()
 {
     return UnifiedDataUtils::GetDetailsSize(this->details_) + this->appId_.size() + this->appName_.size()
@@ -38,6 +54,7 @@ std::string SystemDefinedAppItem::GetAppId() const
 void SystemDefinedAppItem::SetAppId(const std::string &appId)
 {
     this->appId_ = appId;
+    InitObject();
 }
 
 std::string SystemDefinedAppItem::GetAppName() const
@@ -48,6 +65,7 @@ std::string SystemDefinedAppItem::GetAppName() const
 void SystemDefinedAppItem::SetAppName(const std::string &appName)
 {
     this->appName_ = appName;
+    InitObject();
 }
 
 std::string SystemDefinedAppItem::GetAppIconId() const
@@ -58,6 +76,7 @@ std::string SystemDefinedAppItem::GetAppIconId() const
 void SystemDefinedAppItem::SetAppIconId(const std::string &appIconId)
 {
     this->appIconId_ = appIconId;
+    InitObject();
 }
 
 std::string SystemDefinedAppItem::GetAppLabelId() const
@@ -68,6 +87,7 @@ std::string SystemDefinedAppItem::GetAppLabelId() const
 void SystemDefinedAppItem::SetAppLabelId(const std::string &appLabelId)
 {
     this->appLabelId_ = appLabelId;
+    InitObject();
 }
 
 std::string SystemDefinedAppItem::GetBundleName() const
@@ -78,6 +98,7 @@ std::string SystemDefinedAppItem::GetBundleName() const
 void SystemDefinedAppItem::SetBundleName(const std::string &bundleName)
 {
     this->bundleName_ = bundleName;
+    InitObject();
 }
 
 std::string SystemDefinedAppItem::GetAbilityName() const
@@ -88,6 +109,7 @@ std::string SystemDefinedAppItem::GetAbilityName() const
 void SystemDefinedAppItem::SetAbilityName(const std::string &abilityName)
 {
     this->abilityName_ = abilityName;
+    InitObject();
 }
 
 void SystemDefinedAppItem::SetItems(UDDetails &details)
@@ -116,6 +138,7 @@ void SystemDefinedAppItem::SetItems(UDDetails &details)
             SetAbilityName(*value);
         }
     }
+    InitObject();
 }
 
 UDDetails SystemDefinedAppItem::GetItems()
@@ -129,5 +152,29 @@ UDDetails SystemDefinedAppItem::GetItems()
     items[ABILITYNAME] = GetAbilityName();
     return items;
 }
+
+ValueType SystemDefinedAppItem::GetValue()
+{
+    if (std::holds_alternative<std::monostate>(value_)) {
+        value_ = std::make_shared<Object>();
+    }
+    InitObject();
+    return value_;
+}
+
+void SystemDefinedAppItem::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[UNIFORM_DATA_TYPE] = UtdUtils::GetUtdIdFromUtdEnum(dataType_);
+        object->value_[APPID] = appId_;
+        object->value_[APPNAME] = appName_;
+        object->value_[APPICONID] = appIconId_;
+        object->value_[APPLABELID] = appLabelId_;
+        object->value_[BUNDLENAME] = bundleName_;
+        object->value_[ABILITYNAME] = abilityName_;
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/system_defined_form.cpp b/udmf/framework/innerkitsimpl/data/system_defined_form.cpp
index 295937661c17f3e264f9101a64bd2390bcfc0ae4..64d52d0f13b747e193b66936d6297c8eff22713a 100644
--- a/udmf/framework/innerkitsimpl/data/system_defined_form.cpp
+++ b/udmf/framework/innerkitsimpl/data/system_defined_form.cpp
@@ -22,7 +22,10 @@ SystemDefinedForm::SystemDefinedForm()
     this->dataType_ = SYSTEM_DEFINED_FORM;
 }
 
-SystemDefinedForm::SystemDefinedForm(UDType type, ValueType value) : SystemDefinedRecord(type, value) {}
+SystemDefinedForm::SystemDefinedForm(UDType type, ValueType value) : SystemDefinedRecord(type, value)
+{
+    this->dataType_ = SYSTEM_DEFINED_FORM;
+}
 
 int64_t SystemDefinedForm::GetSize()
 {
diff --git a/udmf/framework/innerkitsimpl/data/system_defined_pixelmap.cpp b/udmf/framework/innerkitsimpl/data/system_defined_pixelmap.cpp
index c14b95ec2de722d0e5d996286b0a946b77983be7..f07664a4ada191a8b745cb290b53ec2f514d855d 100644
--- a/udmf/framework/innerkitsimpl/data/system_defined_pixelmap.cpp
+++ b/udmf/framework/innerkitsimpl/data/system_defined_pixelmap.cpp
@@ -12,26 +12,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#define LOG_TAG "SystemDefinedPixelMap"
 
 #include "system_defined_pixelmap.h"
+#include "logger.h"
 
 namespace OHOS {
 namespace UDMF {
+
 SystemDefinedPixelMap::SystemDefinedPixelMap()
 {
-    this->dataType_ = SYSTEM_DEFINED_PIXEL_MAP;
+    SetType(SYSTEM_DEFINED_PIXEL_MAP);
 }
 
 SystemDefinedPixelMap::SystemDefinedPixelMap(std::vector<uint8_t> &data)
 {
-    this->dataType_ = SYSTEM_DEFINED_PIXEL_MAP;
+    SetType(SYSTEM_DEFINED_PIXEL_MAP);
     this->rawData_ = std::move(data);
 }
 
 SystemDefinedPixelMap::SystemDefinedPixelMap(UDType type, ValueType value) : SystemDefinedRecord(type, value)
 {
+    SetType(SYSTEM_DEFINED_PIXEL_MAP);
     if (std::holds_alternative<std::vector<uint8_t>>(value)) {
         rawData_ = std::get<std::vector<uint8_t>>(value);
+        return;
+    }
+    if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        auto object = std::get<std::shared_ptr<Object>>(value);
+        auto it = object->value_.find(PIXEL_MAP);
+        if (it != object->value_.end() && std::holds_alternative<std::shared_ptr<OHOS::Media::PixelMap>>(it->second)) {
+            auto pixelMap = std::get<std::shared_ptr<OHOS::Media::PixelMap>>(it->second);
+            if (!pixelMap->EncodeTlv(rawData_)) {
+                LOG_ERROR(UDMF_KITS_INNER, "pixelMap encode fail!");
+            }
+        }
     }
 }
 
@@ -48,6 +63,32 @@ std::vector<uint8_t> SystemDefinedPixelMap::GetRawData() const
 void SystemDefinedPixelMap::SetRawData(const std::vector<uint8_t> &rawData)
 {
     this->rawData_ = rawData;
+    this->updateObjectFlag_ = true;
+}
+
+ValueType SystemDefinedPixelMap::GetValue()
+{
+    if (std::holds_alternative<std::monostate>(value_)) {
+        value_ = std::make_shared<Object>();
+    }
+    if (this->updateObjectFlag_) {
+        InitObject();
+        this->updateObjectFlag_ = false;
+    }
+    return value_;
+}
+
+void SystemDefinedPixelMap::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        auto pixelMap = std::shared_ptr<OHOS::Media::PixelMap>(OHOS::Media::PixelMap::DecodeTlv(rawData_));
+        if (pixelMap == nullptr) {
+            LOG_ERROR(UDMF_KITS_INNER, "pixelMap encode fail!");
+        }
+        object->value_[PIXEL_MAP] = pixelMap;
+    }
 }
+
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/system_defined_record.cpp b/udmf/framework/innerkitsimpl/data/system_defined_record.cpp
index cf7386126fb433dfb2ec1bfb983ebd3347d9188e..017a792d64326c28ed37a8a8a08b0d94f50f6283 100644
--- a/udmf/framework/innerkitsimpl/data/system_defined_record.cpp
+++ b/udmf/framework/innerkitsimpl/data/system_defined_record.cpp
@@ -26,7 +26,10 @@ int64_t SystemDefinedRecord::GetSize()
     return UnifiedDataUtils::GetDetailsSize(this->details_);
 }
 
-SystemDefinedRecord::SystemDefinedRecord(UDType type, ValueType value) : UnifiedRecord(type, value) {}
+SystemDefinedRecord::SystemDefinedRecord(UDType type, ValueType value) : UnifiedRecord(type, value)
+{
+    this->dataType_ = SYSTEM_DEFINED_RECORD;
+}
 
 void SystemDefinedRecord::AddProperty(const std::string &property, UDVariant &value)
 {
@@ -36,6 +39,7 @@ void SystemDefinedRecord::AddProperty(const std::string &property, UDVariant &va
     } else {
         details_[property] = value;
     }
+    InitObject();
 }
 
 UDVariant SystemDefinedRecord::GetPropertyByName(const std::string &property) const
@@ -50,11 +54,20 @@ UDVariant SystemDefinedRecord::GetPropertyByName(const std::string &property) co
 void SystemDefinedRecord::SetDetails(UDDetails &details)
 {
     this->details_ = details;
+    InitObject();
 }
 
 UDDetails SystemDefinedRecord::GetDetails() const
 {
     return this->details_;
 }
+
+void SystemDefinedRecord::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/text.cpp b/udmf/framework/innerkitsimpl/data/text.cpp
index 0a0871cce0b0eb14e9ed377bad21163b674db8f4..aa298119cdfbd0f8ed89c4e3c1fa08aa48feb1c0 100644
--- a/udmf/framework/innerkitsimpl/data/text.cpp
+++ b/udmf/framework/innerkitsimpl/data/text.cpp
@@ -26,7 +26,10 @@ Text::Text(UDDetails &variantMap) : UnifiedRecord(TEXT)
     this->details_ = variantMap;
 }
 
-Text::Text(UDType type, ValueType value) : UnifiedRecord(type, value) {}
+Text::Text(UDType type, ValueType value) : UnifiedRecord(type, value)
+{
+    SetType(TEXT);
+}
 
 int64_t Text::GetSize()
 {
@@ -36,11 +39,20 @@ int64_t Text::GetSize()
 void Text::SetDetails(UDDetails &variantMap)
 {
     this->details_ = variantMap;
+    InitObject();
 }
 
 UDDetails Text::GetDetails() const
 {
     return this->details_;
 }
+
+void Text::InitObject()
+{
+    if (std::holds_alternative<std::shared_ptr<Object>>(value_)) {
+        auto object = std::get<std::shared_ptr<Object>>(value_);
+        object->value_[DETAILS] = ObjectUtils::ConvertToObject(details_);
+    }
+}
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/framework/innerkitsimpl/data/unified_data.cpp b/udmf/framework/innerkitsimpl/data/unified_data.cpp
index 1d31e2185fd4be8b2713325dc66bdb600c199319..7872cc8fba7bf139ef8738079660d355d77f9d60 100644
--- a/udmf/framework/innerkitsimpl/data/unified_data.cpp
+++ b/udmf/framework/innerkitsimpl/data/unified_data.cpp
@@ -63,6 +63,7 @@ void UnifiedData::AddRecord(const std::shared_ptr<UnifiedRecord> &record)
     if (record == nullptr) {
         return;
     }
+    record->SetRecordId(++recordId_);
     this->records_.push_back(record);
 }
 
@@ -72,6 +73,7 @@ void UnifiedData::AddRecords(const std::vector<std::shared_ptr<UnifiedRecord>> &
         if (record == nullptr) {
             return;
         }
+        record->SetRecordId(++recordId_);
         this->records_.push_back(record);
     }
 }
@@ -94,20 +96,13 @@ std::vector<std::shared_ptr<UnifiedRecord>> UnifiedData::GetRecords() const
     return this->records_;
 }
 
-std::vector<UDType> UnifiedData::GetUDTypes() const
-{
-    std::vector<UDType> typeSet;
-    for (const std::shared_ptr<UnifiedRecord> &record : records_) {
-        typeSet.push_back(record->GetType());
-    }
-    return typeSet;
-}
-
 std::string UnifiedData::GetTypes()
 {
     std::string types;
-    for (const std::shared_ptr<UnifiedRecord> &record : records_) {
-        types.append("-").append(UtdUtils::GetUtdIdFromUtdEnum(record->GetType()));
+    for (const auto &record : records_) {
+        for (const auto &type : record->GetUtdIds()) {
+            types.append("-").append(type);
+        }
     }
     return types;
 }
@@ -131,6 +126,27 @@ bool UnifiedData::HasType(const std::string &type) const
     return false;
 }
 
+std::vector<std::string> UnifiedData::GetEntriesTypes() const
+{
+    std::set<std::string> labels;
+    for (const auto &record : records_) {
+        auto types = record->GetUtdIds();
+        labels.insert(types.begin(), types.end());
+    }
+    return std::vector<std::string>(labels.begin(), labels.end());
+}
+
+bool UnifiedData::HasTypeInEntries(const std::string &type) const
+{
+    for (const auto &record : records_) {
+        auto types = record->GetUtdIds();
+        if (types.find(type) != types.end()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 bool UnifiedData::IsEmpty() const
 {
     return records_.empty();
@@ -166,6 +182,10 @@ bool UnifiedData::IsComplete()
 
 void UnifiedData::SetProperties(std::shared_ptr<UnifiedDataProperties> properties)
 {
+    if (!properties) {
+        LOG_ERROR(UDMF_FRAMEWORK, "properties is null!");
+        return;
+    }
     properties->timestamp = properties_->timestamp;
     properties_ = properties;
 }
@@ -174,5 +194,20 @@ std::shared_ptr<UnifiedDataProperties> UnifiedData::GetProperties() const
 {
     return properties_;
 }
+
+void UnifiedData::SetDataId(uint32_t dataId)
+{
+    dataId_ = dataId;
+}
+
+uint32_t UnifiedData::GetDataId() const
+{
+    return dataId_;
+}
+
+void UnifiedData::SetChannelName(const std::string &name)
+{
+    channelName_ = std::move(name);
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/unified_data_helper.cpp b/udmf/framework/innerkitsimpl/data/unified_data_helper.cpp
index 80e34e3539558d38bbdc84ba2ed7672a238afe6c..18b60dd113ed0bbf0c87925feac317b10762eae9 100644
--- a/udmf/framework/innerkitsimpl/data/unified_data_helper.cpp
+++ b/udmf/framework/innerkitsimpl/data/unified_data_helper.cpp
@@ -15,30 +15,24 @@
 #define LOG_TAG "UnifiedDataHelper"
 #include "unified_data_helper.h"
 
-#include <cstdio>
 #include <string>
-#include <sys/stat.h>
-#include <cinttypes>
 #include <chrono>
 #include "common_func.h"
 #include "directory_ex.h"
 #include "file_ex.h"
 #include "file_uri.h"
-#include "file.h"
 #include "logger.h"
-#include "tlv_object.h"
 #include "tlv_util.h"
-#include "unified_meta.h"
 
 namespace OHOS {
 namespace UDMF {
-const mode_t MODE = 0700;
+constexpr mode_t MODE = 0700;
 static constexpr int64_t MAX_KV_RECORD_SIZE = 2 * 1024 * 1024;
 static constexpr int64_t MAX_KV_DATA_SIZE = 4 * 1024 * 1024;
 
-const std::string TEMP_UNIFIED_DATA_ROOT_PATH = "data/storage/el2/base/temp/udata";
-const std::string TEMP_UNIFIED_DATA_SUFFIX = ".ud";
-const std::string TEMP_UNIFIED_DATA_FLAG = "temp_udmf_file_flag";
+constexpr const char *TEMP_UNIFIED_DATA_ROOT_PATH = "data/storage/el2/base/temp/udata";
+constexpr const char *TEMP_UNIFIED_DATA_SUFFIX = ".ud";
+constexpr const char *TEMP_UNIFIED_DATA_FLAG = "temp_udmf_file_flag";
 
 std::string UnifiedDataHelper::rootPath_ = "";
 
@@ -173,7 +167,7 @@ bool UnifiedDataHelper::SaveUDataToFile(const std::string &dataFile, UnifiedData
 
     std::FILE *file = fopen(dataFile.c_str(), "w+");
     if (file == nullptr) {
-        LOG_ERROR(UDMF_FRAMEWORK, "failed to open file");
+        LOG_ERROR(UDMF_FRAMEWORK, "failed to open file: %{public}s, errno is %{public}d", dataFile.c_str(), errno);
         return false;
     }
     recordTlv.SetFile(file);
diff --git a/udmf/framework/innerkitsimpl/data/unified_record.cpp b/udmf/framework/innerkitsimpl/data/unified_record.cpp
index 0cb24b01654d75fc805d3e48ab07f2147856197a..f90544f49615cca5a9d62c9d2754f67397952b82 100644
--- a/udmf/framework/innerkitsimpl/data/unified_record.cpp
+++ b/udmf/framework/innerkitsimpl/data/unified_record.cpp
@@ -12,9 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+#define LOG_TAG "UnifiedRecord"
 #include "unified_record.h"
 
+#include "getter_system.h"
+
 namespace OHOS {
 namespace UDMF {
 UnifiedRecord::UnifiedRecord()
@@ -24,18 +26,14 @@ UnifiedRecord::UnifiedRecord()
 
 UnifiedRecord::UnifiedRecord(UDType type)
 {
-    if (type < ENTITY || type > UD_BUTT) {
-        dataType_ = UD_BUTT;
-    }
     dataType_ = type;
+    utdId_ = UtdUtils::GetUtdIdFromUtdEnum(type);
 }
 
 UnifiedRecord::UnifiedRecord(UDType type, ValueType value)
 {
-    if (type < ENTITY || type > UD_BUTT) {
-        dataType_ = UD_BUTT;
-    }
     dataType_ = type;
+    utdId_ = UtdUtils::GetUtdIdFromUtdEnum(type);
     value_ = value;
 }
 
@@ -46,7 +44,8 @@ UDType UnifiedRecord::GetType() const
 
 void UnifiedRecord::SetType(const UDType &type)
 {
-    this->dataType_ = type;
+    dataType_ = type;
+    utdId_ = UtdUtils::GetUtdIdFromUtdEnum(type);
 }
 
 int64_t UnifiedRecord::GetSize()
@@ -68,5 +67,126 @@ ValueType UnifiedRecord::GetValue()
 {
     return value_;
 }
+
+void UnifiedRecord::SetValue(const ValueType &value)
+{
+    value_ = value;
+}
+
+ValueType UnifiedRecord::GetOriginValue()
+{
+    return value_;
+}
+
+bool UnifiedRecord::HasType(const std::string &utdId) const
+{
+    if (entries_->find(utdId) != entries_->end()) {
+        return true;
+    }
+    return utdId == utdId_;
+}
+
+void UnifiedRecord::AddEntry(const std::string &utdId, ValueType &&value)
+{
+    if (utdId == utdId_ || utdId_.empty()) {
+        utdId_ = utdId;
+        value_ = std::move(value);
+        auto udType = static_cast<UDType>(UtdUtils::GetUtdEnumFromUtdId(utdId_));
+        if (udType != UD_BUTT) {
+            dataType_ = udType;
+        } else {
+            dataType_ = APPLICATION_DEFINED_RECORD;
+        }
+    } else {
+        entries_->insert_or_assign(utdId, std::move(value));
+    }
+}
+
+ValueType UnifiedRecord::GetEntry(const std::string &utdId)
+{
+    if (utdId_ == utdId && !(std::holds_alternative<std::monostate>(value_))) {
+        return value_;
+    }
+    auto it = entries_->find(utdId);
+    if (it != entries_->end() && !(std::holds_alternative<std::monostate>(it->second))) {
+        return it->second;
+    }
+    auto getter = GetterSystem::GetInstance().GetGetter(channelName_);
+    if (getter != nullptr && (utdId_ == utdId || it != entries_->end())) {
+        auto value = getter->GetValueByType(dataId_, recordId_, utdId);
+        AddEntry(utdId, ValueType(value));
+        return value;
+    }
+    return std::monostate();
+}
+
+std::shared_ptr<std::map<std::string, ValueType>> UnifiedRecord::GetEntries() const
+{
+    auto res = std::make_shared<std::map<std::string, ValueType>>(*entries_);
+    if (!utdId_.empty()) {
+        res->insert_or_assign(utdId_, value_);
+    }
+    return res;
+}
+
+std::set<std::string> UnifiedRecord::GetUtdIds() const
+{
+    std::set<std::string> utdIds;
+    if (!utdId_.empty()) {
+        utdIds.emplace(utdId_);
+    }
+    for (const auto& [key, value] : *entries_) {
+        utdIds.emplace(key);
+    }
+    return utdIds;
+}
+
+void UnifiedRecord::SetUtdId(const std::string& utdId)
+{
+    utdId_ = utdId;
+}
+
+std::string UnifiedRecord::GetUtdId() const
+{
+    return utdId_;
+}
+
+void UnifiedRecord::SetDataId(uint32_t dataId)
+{
+    dataId_ = dataId;
+}
+
+uint32_t UnifiedRecord::GetDataId() const
+{
+    return dataId_;
+}
+
+void UnifiedRecord::SetRecordId(uint32_t recordId)
+{
+    recordId_ = recordId;
+}
+
+uint32_t UnifiedRecord::GetRecordId() const
+{
+    return recordId_;
+}
+
+void UnifiedRecord::SetEntryGetter(const std::set<std::string> &utdIds, const std::shared_ptr<EntryGetter> entryGetter)
+{
+    for (auto utdId : utdIds) {
+        AddEntry(utdId, ValueType());
+    }
+    entryGetter_ = std::move(entryGetter);
+}
+
+std::shared_ptr<EntryGetter> UnifiedRecord::GetEntryGetter()
+{
+    return entryGetter_;
+}
+
+void UnifiedRecord::SetChannelName(const std::string &channelName)
+{
+    channelName_ = channelName;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/data/video.cpp b/udmf/framework/innerkitsimpl/data/video.cpp
index 92b04e93b8d97656ab9a990be24e85e017db0ba6..eb186c5c0e8413f93ccd81f315fb39fe19460a7f 100644
--- a/udmf/framework/innerkitsimpl/data/video.cpp
+++ b/udmf/framework/innerkitsimpl/data/video.cpp
@@ -26,6 +26,9 @@ Video::Video(const std::string &uri) : File(uri)
     this->dataType_ = VIDEO;
 }
 
-Video::Video(UDType type, ValueType value) : File(type, value) {}
+Video::Video(UDType type, ValueType value) : File(type, value)
+{
+    this->dataType_ = VIDEO;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/service/distributeddata_udmf_ipc_interface_code.h b/udmf/framework/innerkitsimpl/service/distributeddata_udmf_ipc_interface_code.h
index 5ea9fbee39009a4558163e2f312034171c4ea9fb..4ead14c0bf01dff9274e706e49ef393a3ce408da 100644
--- a/udmf/framework/innerkitsimpl/service/distributeddata_udmf_ipc_interface_code.h
+++ b/udmf/framework/innerkitsimpl/service/distributeddata_udmf_ipc_interface_code.h
@@ -32,6 +32,8 @@ enum class UdmfServiceInterfaceCode : uint32_t {
     SET_APP_SHARE_OPTION,
     GET_APP_SHARE_OPTION,
     REMOVE_APP_SHARE_OPTION,
+    OBTAIN_ASYN_PROCESS,
+    CLEAR_ASYN_PROCESS,
     CODE_BUTT
 };
 } // namespace OHOS::UDMF
diff --git a/udmf/framework/innerkitsimpl/service/udmf_service.h b/udmf/framework/innerkitsimpl/service/udmf_service.h
index 22c367a1261aa8930c790594829f26cd46aeea43..b57208628b5af1618d991b8694792911b877c3c6 100644
--- a/udmf/framework/innerkitsimpl/service/udmf_service.h
+++ b/udmf/framework/innerkitsimpl/service/udmf_service.h
@@ -49,6 +49,8 @@ public:
     virtual int32_t SetAppShareOption(const std::string &intention, int32_t shareOption) = 0;
     virtual int32_t GetAppShareOption(const std::string &intention, int32_t &shareOption) = 0;
     virtual int32_t RemoveAppShareOption(const std::string &intention) = 0;
+    virtual int32_t ObtainAsynProcess(AsyncProcessInfo &processInfo) = 0;
+    virtual int32_t ClearAsynProcess() = 0;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/framework/innerkitsimpl/service/udmf_service_client.cpp b/udmf/framework/innerkitsimpl/service/udmf_service_client.cpp
index 395763d3b27c94df10581b6df7214b0ddb27fb28..43fc593c3906249c8adcd3202054f852fdaa5e63 100644
--- a/udmf/framework/innerkitsimpl/service/udmf_service_client.cpp
+++ b/udmf/framework/innerkitsimpl/service/udmf_service_client.cpp
@@ -279,5 +279,15 @@ int32_t UdmfServiceClient::RemoveAppShareOption(const std::string &intention)
     }
     return udmfProxy_->RemoveAppShareOption(intention);
 }
+
+int32_t UdmfServiceClient::ObtainAsynProcess(AsyncProcessInfo& processInfo)
+{
+    return udmfProxy_->ObtainAsynProcess(processInfo);
+}
+
+int32_t UdmfServiceClient::ClearAsynProcess()
+{
+    return udmfProxy_->ClearAsynProcess();
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/service/udmf_service_client.h b/udmf/framework/innerkitsimpl/service/udmf_service_client.h
index c16f1bca10b6a365f01e0efc7fd2fedc9e224820..54c594951025866c0b222f9406fdf887cbc5200a 100644
--- a/udmf/framework/innerkitsimpl/service/udmf_service_client.h
+++ b/udmf/framework/innerkitsimpl/service/udmf_service_client.h
@@ -44,6 +44,8 @@ public:
     int32_t SetAppShareOption(const std::string &intention, int32_t shareOption) override;
     int32_t GetAppShareOption(const std::string &intention, int32_t &shareOption) override;
     int32_t RemoveAppShareOption(const std::string &intention) override;
+    int32_t ObtainAsynProcess(AsyncProcessInfo& processInfo) override;
+    int32_t ClearAsynProcess() override;
 
 private:
     class ServiceDeathRecipient : public IRemoteObject::DeathRecipient {
diff --git a/udmf/framework/innerkitsimpl/service/udmf_service_proxy.cpp b/udmf/framework/innerkitsimpl/service/udmf_service_proxy.cpp
index f75db09da8859702d734e334eacb4b14601eb0b1..e4acc7a121284d1c9ca49c35d573019774bafe6a 100644
--- a/udmf/framework/innerkitsimpl/service/udmf_service_proxy.cpp
+++ b/udmf/framework/innerkitsimpl/service/udmf_service_proxy.cpp
@@ -15,10 +15,7 @@
 #define LOG_TAG "UdmfServiceProxy"
 #include "udmf_service_proxy.h"
 
-#include "ipc_types.h"
-
 #include "logger.h"
-#include "tlv_util.h"
 #include "udmf_types_util.h"
 
 namespace OHOS {
@@ -115,8 +112,8 @@ int32_t UdmfServiceProxy::DeleteData(const QueryOption &query, std::vector<Unifi
     MessageParcel reply;
     int32_t status = IPC_SEND(UdmfServiceInterfaceCode::DELETE_DATA, reply, query);
     if (status != E_OK) {
-        LOG_ERROR(UDMF_SERVICE, "status:0x%{public}x,key: %{public}s, intention:%{public}s", status, query.key.c_str(),
-                  UD_INTENTION_MAP.at(query.intention).c_str());
+        LOG_ERROR(UDMF_SERVICE, "status:0x%{public}x,key: %{public}s, intention:%{public}d", status, query.key.c_str(),
+                  query.intention);
         return status;
     }
     if (!ITypesUtil::Unmarshal(reply, unifiedDataSet)) {
@@ -232,5 +229,32 @@ int32_t UdmfServiceProxy::SendRequest(UdmfServiceInterfaceCode code, MessageParc
     LOG_DEBUG(UDMF_SERVICE, "err: %{public}d", err);
     return err;
 }
+
+int32_t UdmfServiceProxy::ObtainAsynProcess(AsyncProcessInfo &processInfo)
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(UdmfServiceInterfaceCode::OBTAIN_ASYN_PROCESS, reply);
+    if (status != E_OK) {
+        LOG_ERROR(UDMF_SERVICE, "status:0x%{public}x", status);
+        return status;
+    }
+    if (!ITypesUtil::Unmarshal(reply, processInfo)) {
+        LOG_ERROR(UDMF_SERVICE, "Unmarshal AsyncProcessInfo failed!");
+        return E_READ_PARCEL_ERROR;
+    }
+    return E_OK;
+}
+
+int32_t UdmfServiceProxy::ClearAsynProcess()
+{
+    MessageParcel reply;
+    int32_t status = IPC_SEND(UdmfServiceInterfaceCode::CLEAR_ASYN_PROCESS, reply);
+    if (status != E_OK) {
+        LOG_ERROR(UDMF_SERVICE, "status:0x%{public}x", status);
+        return status;
+    }
+    return E_OK;
+}
+
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/service/udmf_service_proxy.h b/udmf/framework/innerkitsimpl/service/udmf_service_proxy.h
index 7f86f0ce878c02c51881a1cf6863adbdf0bbf532..ca576b0bd739262853728e6353f455c3c7674177 100644
--- a/udmf/framework/innerkitsimpl/service/udmf_service_proxy.h
+++ b/udmf/framework/innerkitsimpl/service/udmf_service_proxy.h
@@ -47,6 +47,8 @@ public:
     int32_t SetAppShareOption(const std::string &intention, int32_t shareOption) override;
     int32_t GetAppShareOption(const std::string &intention, int32_t &shareOption) override;
     int32_t RemoveAppShareOption(const std::string &intention) override;
+    int32_t ObtainAsynProcess(AsyncProcessInfo &processInfo) override;
+    int32_t ClearAsynProcess() override;
 private:
     static inline BrokerDelegator<UdmfServiceProxy> delegator_;
     int32_t SendRequest(UdmfServiceInterfaceCode code, MessageParcel &data,
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/BUILD.gn b/udmf/framework/innerkitsimpl/test/fuzztest/BUILD.gn
index f0423470665d7a64c778aac4bf56d5f3512a79aa..0788d0cce4611bed8beb170e9834c5fa4c7b2a70 100644
--- a/udmf/framework/innerkitsimpl/test/fuzztest/BUILD.gn
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/BUILD.gn
@@ -17,5 +17,8 @@ import("//build/ohos.gni")
 group("fuzztest") {
   testonly = true
 
-  deps = [ "udmfclient_fuzzer:fuzztest" ]
+  deps = [
+    "udmfclient_fuzzer:fuzztest",
+    "utdclient_fuzzer:fuzztest",
+  ]
 }
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/udmfclient_fuzzer/udmf_client_fuzzer.cpp b/udmf/framework/innerkitsimpl/test/fuzztest/udmfclient_fuzzer/udmf_client_fuzzer.cpp
index 179454fd1b0119402a5556b4c9968b6ea2bf2a0e..c84c0de75947fd1d76e55b9056ad713e35bf3fd7 100644
--- a/udmf/framework/innerkitsimpl/test/fuzztest/udmfclient_fuzzer/udmf_client_fuzzer.cpp
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/udmfclient_fuzzer/udmf_client_fuzzer.cpp
@@ -629,6 +629,45 @@ void UpdateDataFuzz(const uint8_t *data, size_t size)
     QueryOption option3 = { .key = skey };
     UdmfClient::GetInstance().UpdateData(option3, data3);
 }
+
+void GetDataAsyncByKeyFuzz(const uint8_t *data, size_t size)
+{
+    std::string skey(data, data + size);
+    CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
+    UnifiedData data1;
+    std::string key;
+    PlainText plainText(skey, skey);
+    std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
+    data1.AddRecord(record1);
+    UdmfClient::GetInstance().SetData(option1, data1, key);
+
+    SetHapToken();
+    QueryOption option2 = { .key = skey };
+    auto callback = [](ProgressInfo progress, UnifiedData &outputData) {
+    };
+    UdmfClient::GetInstance().GetDataAsync(option2, callback);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+
+void GetDataAsyncByIntentionFuzz(const uint8_t *data, size_t size)
+{
+    std::string skey(data, data + size);
+    CustomOption option1 = { .intention = UD_INTENTION_DATA_HUB };
+    UnifiedData data1;
+    std::string key;
+    PlainText plainText(skey, skey);
+    std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(plainText);
+    data1.AddRecord(record1);
+    UdmfClient::GetInstance().SetData(option1, data1, key);
+
+    SetHapToken();
+    Intention intention = UnifiedDataUtils::GetIntentionByString(skey);
+    QueryOption option2 = { .intention = intention };
+    auto callback = [](ProgressInfo progress, UnifiedData &outputData) {
+    };
+    UdmfClient::GetInstance().GetDataAsync(option2, callback);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
 }
 
 /* Fuzzer entry point */
@@ -654,5 +693,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
     OHOS::DeleteDataByIntentionFuzz(data, size);
     OHOS::UpdateDataFuzz(data, size);
     OHOS::TearDown();
+    OHOS::GetDataAsyncByKeyFuzz(data, size);
+    OHOS::GetDataAsyncByIntentionFuzz(data, size);
     return 0;
 }
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/BUILD.gn b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..fffef2878ff29ea402b0f85ec4d45c1232bef6f8
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/BUILD.gn
@@ -0,0 +1,51 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/config/features.gni")
+
+#####################hydra-fuzz###################
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/udmf/udmf.gni")
+
+##############################fuzztest##########################################
+ohos_fuzztest("UtdClientFuzzTest") {
+  module_out_path = "udmf/udmf"
+
+  include_dirs = [ "${udmf_interfaces_path}/innerkits/client" ]
+
+  fuzz_config_file =
+      "${udmf_framework_path}/innerkitsimpl/test/fuzztest/utdclient_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+
+  sources = [ "utd_client_fuzzer.cpp" ]
+
+  deps = [ "${udmf_interfaces_path}/innerkits:utd_client" ]
+
+  external_deps = []
+}
+
+###############################################################################
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [
+    # deps file
+    ":UtdClientFuzzTest",
+  ]
+}
+###############################################################################
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/corpus/init b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/corpus/init
new file mode 100644
index 0000000000000000000000000000000000000000..6198079a28e860189d4294f6598f8ac6804c0dff
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/corpus/init
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+FUZZ
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/project.xml b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7133b2b92440904a5ed04b838733acea0f97486a
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/project.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2024 Huawei Device Co., Ltd.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.cpp b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e98e30bc82a3881de1184fe6e73a47d91703716
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "utd_client_fuzzer.h"
+#include "utd_client.h"
+
+using namespace OHOS;
+using namespace OHOS::UDMF;
+
+namespace OHOS {
+void SetUpTestCase()
+{
+}
+
+void TearDown()
+{
+}
+
+void GetTypeDescriptorFuzz(const uint8_t *data, size_t size)
+{
+    std::string typeId(data, data + size);
+    std::shared_ptr<TypeDescriptor> typeDescriptor;
+    UtdClient::GetInstance().GetTypeDescriptor(typeId, typeDescriptor);
+}
+
+void GetUniformDataTypeByFilenameExtensionDefaultBelongsFuzz(const uint8_t *data, size_t size)
+{
+    std::string fileExtension(data, data + size);
+    std::string typeId;
+    UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(fileExtension, typeId);
+}
+
+void GetUniformDataTypeByFilenameExtensionFuzz(const uint8_t *data, size_t size)
+{
+    std::string fileExtension(data, data + size);
+    std::string typeId;
+    std::string belongsTo(data, data + size);
+    UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(fileExtension, typeId, belongsTo);
+}
+
+void GetUniformDataTypesByFilenameExtensionDefaultBelongsFuzz(const uint8_t *data, size_t size)
+{
+    std::string fileExtension(data, data + size);
+    std::vector<std::string> typeIds;
+    UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(fileExtension, typeIds);
+}
+
+void GetUniformDataTypesByFilenameExtensionFuzz(const uint8_t *data, size_t size)
+{
+    std::string fileExtension(data, data + size);
+    std::vector<std::string> typeIds;
+    std::string belongsTo(data, data + size);
+    UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(fileExtension, typeIds, belongsTo);
+}
+
+void GetUniformDataTypeByMIMETypeDefaultBelongsFuzz(const uint8_t *data, size_t size)
+{
+    std::string mimeType(data, data + size);
+    std::string typeId;
+    UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, typeId);
+}
+
+void GetUniformDataTypeByMIMETypeFuzz(const uint8_t *data, size_t size)
+{
+    std::string mimeType(data, data + size);
+    std::string typeId;
+    std::string belongsTo(data, data + size);
+    UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, typeId, belongsTo);
+}
+
+void GetUniformDataTypesByMIMETypeDefaultBelongsFuzz(const uint8_t *data, size_t size)
+{
+    std::string mimeType(data, data + size);
+    std::vector<std::string> typeIds;
+    UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, typeIds);
+}
+
+void GetUniformDataTypesByMIMETypeFuzz(const uint8_t *data, size_t size)
+{
+    std::string mimeType(data, data + size);
+    std::vector<std::string> typeIds;
+    std::string belongsTo(data, data + size);
+    UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, typeIds, belongsTo);
+}
+
+void IsUtdFuzz(const uint8_t *data, size_t size)
+{
+    std::string typeId(data, data + size);
+    bool result;
+    UtdClient::GetInstance().IsUtd(typeId, result);
+}
+
+}
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    /* Run your code on data */
+    OHOS::SetUpTestCase();
+    OHOS::GetTypeDescriptorFuzz(data, size);
+    OHOS::GetUniformDataTypeByFilenameExtensionDefaultBelongsFuzz(data, size);
+    OHOS::GetUniformDataTypeByFilenameExtensionFuzz(data, size);
+    OHOS::GetUniformDataTypesByFilenameExtensionDefaultBelongsFuzz(data, size);
+    OHOS::GetUniformDataTypesByFilenameExtensionFuzz(data, size);
+    OHOS::GetUniformDataTypeByMIMETypeDefaultBelongsFuzz(data, size);
+    OHOS::GetUniformDataTypeByMIMETypeFuzz(data, size);
+    OHOS::GetUniformDataTypesByMIMETypeDefaultBelongsFuzz(data, size);
+    OHOS::GetUniformDataTypesByMIMETypeFuzz(data, size);
+    OHOS::IsUtdFuzz(data, size);
+    return 0;
+}
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.h b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.h
new file mode 100644
index 0000000000000000000000000000000000000000..622aab84f175ed7b84ff1690f9fbba02dee332e5
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/fuzztest/utdclient_fuzzer/utd_client_fuzzer.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_UTD_CLIENT_FUZZER_H
+#define UDMF_UTD_CLIENT_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "utdclient_fuzzer"
+
+#endif // UDMF_UDMF_CLIENT_FUZZER_H
diff --git a/udmf/framework/innerkitsimpl/test/unittest/BUILD.gn b/udmf/framework/innerkitsimpl/test/unittest/BUILD.gn
index 68bf79b5f78acc3ef8b61adb93a9ba219f72fdee..87df9da2c387fe70247438a33dd26bd063d7ad5b 100644
--- a/udmf/framework/innerkitsimpl/test/unittest/BUILD.gn
+++ b/udmf/framework/innerkitsimpl/test/unittest/BUILD.gn
@@ -21,12 +21,21 @@ config("module_private_config") {
     "${udmf_interfaces_path}/innerkits/client",
     "${udmf_interfaces_path}/innerkits/common",
     "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_interfaces_path}/ndk/data",
     "${udmf_framework_path}/common",
     "${udmf_framework_path}/innerkits/service",
+    "${udmf_framework_path}/innerkits/convert",
+    "${udmf_framework_path}/innerkitsimpl/client/",
+    "${udmf_framework_path}/innerkitsimpl/test/unittest/mock/include",
+    "${udmf_framework_path}/ndkimpl/data",
+    "${kv_store_path}/frameworks/common",
   ]
 }
 
-common_deps = [ "${udmf_interfaces_path}/innerkits:udmf_client" ]
+common_deps = [
+  "${udmf_interfaces_path}/innerkits:udmf_client",
+  "${udmf_interfaces_path}/innerkits:utd_client",
+]
 
 common_external_deps = [
   "ability_base:want",
@@ -35,10 +44,16 @@ common_external_deps = [
   "access_token:libtoken_setproc",
   "bundle_framework:appexecfwk_core",
   "c_utils:utils",
+  "ffmpeg:libohosffmpeg",
   "hilog:libhilog",
+  "hisysevent:libhisysevent",
+  "hitrace:hitrace_meter",
+  "hitrace:libhitracechain",
   "image_framework:image",
   "ipc:ipc_core",
   "kv_store:distributeddata_inner",
+  "kv_store:distributeddata_mgr",
+  "libexif:libexif",
   "samgr:samgr_proxy",
 ]
 
@@ -47,6 +62,8 @@ ohos_unittest("UdmfClientTest") {
 
   sources = [
     "${udmf_framework_path}/common/graph.cpp",
+    "${udmf_framework_path}/innerkitsimpl/client/async_obtain_data.cpp",
+    "${udmf_framework_path}/innerkitsimpl/service/udmf_service_proxy.cpp",
     "udmf_client_test.cpp",
   ]
 
@@ -55,6 +72,11 @@ ohos_unittest("UdmfClientTest") {
   deps = common_deps
 
   external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
 }
 
 ohos_unittest("UdmfClientSystemHapTest") {
@@ -74,6 +96,7 @@ ohos_unittest("UtdClientTest") {
 
   sources = [
     "${udmf_framework_path}/common/graph.cpp",
+    "${udmf_framework_path}/common/utd_graph.cpp",
     "custom_utd_json_parser_test.cpp",
     "custom_utd_store_test.cpp",
     "graph_test.cpp",
@@ -85,6 +108,365 @@ ohos_unittest("UtdClientTest") {
   deps = [ "${udmf_interfaces_path}/innerkits:utd_client" ]
 
   external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("NdkDataConversionTest") {
+  module_out_path = module_output_path
+
+  sources = [
+    "${udmf_framework_path}/ndkimpl/data/udmf.cpp",
+    "${udmf_framework_path}/ndkimpl/data/uds.cpp",
+    "ndk_data_conversion_test.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+}
+
+ohos_unittest("ApplicationDefineRecordTest") {
+  module_out_path = module_output_path
+
+  sources = [ "application_defined_record_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("AudioTest") {
+  module_out_path = module_output_path
+
+  sources = [ "audio_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("FileDataTest") {
+  module_out_path = module_output_path
+
+  sources = [ "file_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("FlexibleTypeTest") {
+  module_out_path = module_output_path
+
+  sources = [ "flexible_type_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("FolderTest") {
+  module_out_path = module_output_path
+
+  sources = [ "folder_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("HtmlTest") {
+  module_out_path = module_output_path
+
+  sources = [ "html_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("ImageTest") {
+  module_out_path = module_output_path
+
+  sources = [ "image_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("LinkTest") {
+  module_out_path = module_output_path
+
+  sources = [ "link_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("PlainTextTest") {
+  module_out_path = module_output_path
+
+  sources = [ "plain_text_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("SystemDefinedAppitemTest") {
+  module_out_path = module_output_path
+
+  sources = [ "system_defined_appitem_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("SystemDefinedFormTest") {
+  module_out_path = module_output_path
+
+  sources = [ "system_defined_form_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("SystemDefinedPixelMapTest") {
+  module_out_path = module_output_path
+
+  sources = [ "system_defined_pixelmap_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("SystemDefinedRecordTest") {
+  module_out_path = module_output_path
+
+  sources = [ "system_defined_record_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("TextTest") {
+  module_out_path = module_output_path
+
+  sources = [ "text_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("UnifiedDataTest") {
+  module_out_path = module_output_path
+
+  sources = [ "unified_data_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("UnifiedDataHelperTest") {
+  module_out_path = module_output_path
+
+  sources = [ "unified_data_helper_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("UnifiedRecordTest") {
+  module_out_path = module_output_path
+
+  sources = [ "unified_record_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("VideoTest") {
+  module_out_path = module_output_path
+
+  sources = [ "video_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("UnifiedMetaTest") {
+  module_out_path = module_output_path
+
+  sources = [ "unified_meta_test.cpp" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
+}
+
+ohos_unittest("UdmfClientAbnormalTest") {
+  module_out_path = module_output_path
+
+  sources = [
+    "${udmf_framework_path}/common/endian_converter.cpp",
+    "${udmf_framework_path}/common/tlv_util.cpp",
+    "${udmf_framework_path}/common/udmf_radar_reporter.cpp",
+    "${udmf_framework_path}/common/udmf_types_util.cpp",
+    "${udmf_framework_path}/common/udmf_utils.cpp",
+    "${udmf_framework_path}/innerkitsimpl/client/async_obtain_data.cpp",
+    "${udmf_framework_path}/innerkitsimpl/client/udmf_client.cpp",
+    "${udmf_framework_path}/innerkitsimpl/common/unified_key.cpp",
+    "${udmf_framework_path}/innerkitsimpl/common/unified_meta.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/application_defined_record.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/audio.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/file.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/folder.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/html.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/image.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/link.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/plain_text.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/system_defined_appitem.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/system_defined_form.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/system_defined_record.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/text.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/unified_data.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/unified_record.cpp",
+    "${udmf_framework_path}/innerkitsimpl/data/video.cpp",
+    "${udmf_framework_path}/innerkitsimpl/service/udmf_service_proxy.cpp",
+    "${udmf_framework_path}/innerkitsimpl/test/unittest/mock/system_defined_pixelmap_mock.cpp",
+    "${udmf_framework_path}/innerkitsimpl/test/unittest/mock/tlv_object_mock.cpp",
+    "${udmf_framework_path}/innerkitsimpl/test/unittest/mock/udmf_service_client_mock.cpp",
+    "udmf_client_abnormal_test.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = [
+    "${udmf_interfaces_path}/innerkits:utd_client",
+    "//third_party/googletest:gmock_main",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  external_deps = common_external_deps
+
+  defines = [
+    "private=public",
+    "protected=public",
+  ]
 }
 
 ###############################################################################
@@ -92,9 +474,30 @@ group("unittest") {
   testonly = true
 
   deps = [
+    ":ApplicationDefineRecordTest",
+    ":AudioTest",
+    ":FileDataTest",
+    ":FlexibleTypeTest",
+    ":FolderTest",
+    ":HtmlTest",
+    ":ImageTest",
+    ":LinkTest",
+    ":NdkDataConversionTest",
+    ":PlainTextTest",
+    ":SystemDefinedAppitemTest",
+    ":SystemDefinedFormTest",
+    ":SystemDefinedPixelMapTest",
+    ":SystemDefinedRecordTest",
+    ":TextTest",
+    ":UdmfClientAbnormalTest",
     ":UdmfClientSystemHapTest",
     ":UdmfClientTest",
+    ":UnifiedDataHelperTest",
+    ":UnifiedDataTest",
+    ":UnifiedMetaTest",
+    ":UnifiedRecordTest",
     ":UtdClientTest",
+    ":VideoTest",
   ]
 }
 ###############################################################################
diff --git a/udmf/framework/innerkitsimpl/test/unittest/application_defined_record_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/application_defined_record_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dacfe513dc80dec084db5d26f27a1ec92f0ddb8e
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/application_defined_record_test.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "ApplicationUtdJsonParserTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "application_defined_record.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class ApplicationUtdJsonParserTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void ApplicationUtdJsonParserTest::SetUpTestCase()
+{
+}
+
+void ApplicationUtdJsonParserTest::TearDownTestCase()
+{
+}
+
+void ApplicationUtdJsonParserTest::SetUp()
+{
+}
+
+void ApplicationUtdJsonParserTest::TearDown()
+{
+}
+
+/**
+* @tc.name: ApplicationDefinedRecord001
+* @tc.desc: Normal testcase of ApplicationDefinedRecord
+* @tc.type: FUNC
+*/
+HWTEST_F(ApplicationUtdJsonParserTest, ApplicationDefinedRecord001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord001 begin.");
+    string type("record");
+    ApplicationDefinedRecord application(type);
+    EXPECT_EQ(application.applicationDefinedType, "record");
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord001 end.");
+}
+
+/**
+* @tc.name: ApplicationDefinedRecord002
+* @tc.desc: Normal testcase of ApplicationDefinedRecord
+* @tc.type: FUNC
+*/
+HWTEST_F(ApplicationUtdJsonParserTest, ApplicationDefinedRecord002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord002 begin.");
+    string type("record");
+    vector<uint8_t> data = vector<uint8_t>();
+    ApplicationDefinedRecord application(type, data);
+    EXPECT_EQ(application.applicationDefinedType, "record");
+    EXPECT_EQ(application.rawData_, data);
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord002 end.");
+}
+
+/**
+* @tc.name: ApplicationDefinedRecord003
+* @tc.desc: Normal testcase of ApplicationDefinedRecord
+* @tc.type: FUNC
+*/
+HWTEST_F(ApplicationUtdJsonParserTest, ApplicationDefinedRecord003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord003 begin.");
+    UDType type = UDType::ENTITY;
+    vector<uint8_t> vec = {1, 2};
+    ApplicationDefinedRecord application(type, vec);
+    EXPECT_EQ(application.rawData_.size(), vec.size());
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord003 end.");
+}
+
+/**
+* @tc.name: ApplicationDefinedRecord004
+* @tc.desc: Normal testcase of ApplicationDefinedRecord
+* @tc.type: FUNC
+*/
+HWTEST_F(ApplicationUtdJsonParserTest, ApplicationDefinedRecord004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord004 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    ApplicationDefinedRecord application(type, value);
+    EXPECT_EQ(application.rawData_.size(), 0);
+    LOG_INFO(UDMF_TEST, "ApplicationDefinedRecord004 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/audio_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/audio_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef3ce3626893d2b01a78d467eaeb912685ce53f5
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/audio_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "AudioTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "audio.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class AudioTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void AudioTest::SetUpTestCase()
+{
+}
+
+void AudioTest::TearDownTestCase()
+{
+}
+
+void AudioTest::SetUp()
+{
+}
+
+void AudioTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Audio001
+* @tc.desc: Normal testcase of Audio
+* @tc.type: FUNC
+*/
+HWTEST_F(AudioTest, Audio001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Audio001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    Audio audio(type, value);
+    EXPECT_EQ(audio.dataType_, AUDIO);
+    LOG_INFO(UDMF_TEST, "Audio001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/file_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/file_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ecc42a79a5f42843f0f373df6172c1cb296f635a
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/file_test.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "FileTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <cstring>
+
+#include "logger.h"
+#include "file.h"
+#include "unified_meta.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class FileTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void FileTest::SetUpTestCase()
+{
+}
+
+void FileTest::TearDownTestCase()
+{
+}
+
+void FileTest::SetUp()
+{
+}
+
+void FileTest::TearDown()
+{
+}
+
+/**
+* @tc.name: File001
+* @tc.desc: Normal testcase of File
+* @tc.type: FUNC
+*/
+HWTEST_F(FileTest, File001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "File001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = "string";
+    OHOS::UDMF::File file(type, value);
+    EXPECT_EQ(file.dataType_, UDType::FILE);
+    EXPECT_EQ(file.oriUri_.length(), std::get<std::string>(value).length());
+    LOG_INFO(UDMF_TEST, "File001 end.");
+}
+
+/**
+* @tc.name: File002
+* @tc.desc: Normal testcase of File
+* @tc.type: FUNC
+*/
+HWTEST_F(FileTest, File002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "File002 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    OHOS::UDMF::File file(type, value);
+    EXPECT_EQ(file.dataType_, UDType::FILE);
+    EXPECT_EQ(file.oriUri_.length(), 0);
+    LOG_INFO(UDMF_TEST, "File002 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/flexible_type_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/flexible_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce9371f8c7f1c7bf13fc790c423d6394ade1a455
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/flexible_type_test.cpp
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "FlexibleTypeTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "flexible_type.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class FlexibleTypeTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void FlexibleTypeTest::SetUpTestCase()
+{
+}
+
+void FlexibleTypeTest::TearDownTestCase()
+{
+}
+
+void FlexibleTypeTest::SetUp()
+{
+}
+
+void FlexibleTypeTest::TearDown()
+{
+}
+
+/**
+* @tc.name: EscapeStr001
+* @tc.desc: Normal testcase of EscapeStr
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr001 begin.");
+    const std::string chs = "string?";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string\\?");
+    LOG_INFO(UDMF_TEST, "EscapeStr001 end.");
+}
+
+/**
+* @tc.name: EscapeStr002
+* @tc.desc: Normal testcase of EscapeStr
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr002 begin.");
+    const std::string chs = "string:";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string\\:");
+    LOG_INFO(UDMF_TEST, "EscapeStr002 end.");
+}
+
+/**
+* @tc.name: EscapeStr003
+* @tc.desc: Normal testcase of EscapeStr
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr003 begin.");
+    const std::string chs = "string=";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string\\=");
+    LOG_INFO(UDMF_TEST, "EscapeStr003 end.");
+}
+
+/**
+* @tc.name: EscapeStr004
+* @tc.desc: Normal testcase of EscapeStr
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr004 begin.");
+    const std::string chs = "string,";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string\\,");
+    LOG_INFO(UDMF_TEST, "EscapeStr004 end.");
+}
+
+/**
+* @tc.name: EscapeStr005
+* @tc.desc: Normal testcase of EscapeStr
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr005 begin.");
+    const std::string chs = "string\\";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string\\\\");
+    LOG_INFO(UDMF_TEST, "EscapeStr005 end.");
+}
+
+/**
+* @tc.name: EscapeStr006
+* @tc.desc: Abnormal testcase of EscapeStr, because chs doesn't include '?'、 ':'、 '='、',' and '\\'
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, EscapeStr006, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "EscapeStr006 begin.");
+    const std::string chs = "string";
+    string output = FlexibleType::EscapeStr(chs);
+    EXPECT_EQ(output, "string");
+    LOG_INFO(UDMF_TEST, "EscapeStr006 end.");
+}
+
+/**
+* @tc.name: ParseFlexibleUtd001
+* @tc.desc: Abnormal testcase of ParseFlexibleUtd, because typeId and FLEXIBLE_TYPE_FLAG are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, ParseFlexibleUtd001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd001 begin.");
+    const std::string typeId = "flex.z";
+    TypeDescriptorCfg flexibleTypeDescriptorCfg;
+    flexibleTypeDescriptorCfg.typeId = "com.example.utdtest.document";
+    flexibleTypeDescriptorCfg.belongingToTypes = {"com.example.utdtest2.document"};
+    flexibleTypeDescriptorCfg.filenameExtensions = {".mydocument"};
+    flexibleTypeDescriptorCfg.mimeTypes = {"application/my-document"};
+    flexibleTypeDescriptorCfg.description = "My document.";
+    flexibleTypeDescriptorCfg.referenceURL = "http://www.mycompany.com/my-document.html";
+    flexibleTypeDescriptorCfg.iconFile = "resources/my-document.png";
+    flexibleTypeDescriptorCfg.ownerBundle = "com.example.utdtest";
+    flexibleTypeDescriptorCfg.installerBundles = {"com.example.utdtest"};
+    FlexibleType flexibleType;
+    bool ret = flexibleType.ParseFlexibleUtd(typeId, flexibleTypeDescriptorCfg);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd001 end.");
+}
+
+/**
+* @tc.name: ParseFlexibleUtd002
+* @tc.desc: Abnormal testcase of ParseFlexibleUtd, because flexibleUtdDecode[0] != '?'
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, ParseFlexibleUtd002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd002 begin.");
+    const std::string typeId = "com.example.utdtest.document";
+    TypeDescriptorCfg flexibleTypeDescriptorCfg;
+    flexibleTypeDescriptorCfg.typeId = "com.example.utdtest.document";
+    flexibleTypeDescriptorCfg.belongingToTypes = {"com.example.utdtest2.document"};
+    flexibleTypeDescriptorCfg.filenameExtensions = {".mydocument"};
+    flexibleTypeDescriptorCfg.mimeTypes = {"application/my-document"};
+    flexibleTypeDescriptorCfg.description = "My document.";
+    flexibleTypeDescriptorCfg.referenceURL = "http://www.mycompany.com/my-document.html";
+    flexibleTypeDescriptorCfg.iconFile = "resources/my-document.png";
+    flexibleTypeDescriptorCfg.ownerBundle = "com.example.utdtest";
+    flexibleTypeDescriptorCfg.installerBundles = {"com.example.utdtest"};
+    FlexibleType flexibleType;
+    bool ret = flexibleType.ParseFlexibleUtd(typeId, flexibleTypeDescriptorCfg);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd002 end.");
+}
+
+/**
+* @tc.name: ParseFlexibleUtd003
+* @tc.desc: Abnormal testcase of ParseFlexibleUtd, because flexibleUtdDecode contains "="
+* @tc.type: FUNC
+*/
+HWTEST_F(FlexibleTypeTest, ParseFlexibleUtd003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd003 begin.");
+    const std::string typeId = "flex.z=";
+    TypeDescriptorCfg flexibleTypeDescriptorCfg;
+    flexibleTypeDescriptorCfg.typeId = "com.example.utdtest.document";
+    flexibleTypeDescriptorCfg.belongingToTypes = {"com.example.utdtest2.document"};
+    flexibleTypeDescriptorCfg.filenameExtensions = {".mydocument"};
+    flexibleTypeDescriptorCfg.mimeTypes = {"application/my-document"};
+    flexibleTypeDescriptorCfg.description = "My document.";
+    flexibleTypeDescriptorCfg.referenceURL = "http://www.mycompany.com/my-document.html";
+    flexibleTypeDescriptorCfg.iconFile = "resources/my-document.png";
+    flexibleTypeDescriptorCfg.ownerBundle = "com.example.utdtest";
+    flexibleTypeDescriptorCfg.installerBundles = {"com.example.utdtest"};
+    FlexibleType flexibleType;
+    bool ret = flexibleType.ParseFlexibleUtd(typeId, flexibleTypeDescriptorCfg);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "ParseFlexibleUtd003 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/folder_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/folder_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8a1a438e8fdbf20c018e3af9f8b30acc3ff29494
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/folder_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "FolderTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "folder.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class FolderTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void FolderTest::SetUpTestCase()
+{
+}
+
+void FolderTest::TearDownTestCase()
+{
+}
+
+void FolderTest::SetUp()
+{
+}
+
+void FolderTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Folder001
+* @tc.desc: Normal testcase of Folder
+* @tc.type: FUNC
+*/
+HWTEST_F(FolderTest, Folder001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Folder001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    Folder floder(type, value);
+    EXPECT_EQ(floder.dataType_, FOLDER);
+    LOG_INFO(UDMF_TEST, "Folder001 end.");
+}
+} // OHOS::Test
diff --git a/udmf/framework/innerkitsimpl/test/unittest/html_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/html_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83e3507ecd327f065c3431271f402c5bdf34b70a
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/html_test.cpp
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "HtmlTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "html.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class HtmlTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void HtmlTest::SetUpTestCase()
+{
+}
+
+void HtmlTest::TearDownTestCase()
+{
+}
+
+void HtmlTest::SetUp()
+{
+}
+
+void HtmlTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Html001
+* @tc.desc: Abnormal testcase of Html, because htmlContent and plainContent are equal to MAX_TEXT_LEN
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, Html001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Html001 begin.");
+    const std::string htmlContent(MAX_TEXT_LEN, 'a');
+    const std::string plainContent(MAX_TEXT_LEN, 'a');
+    Html html(htmlContent, plainContent);
+    EXPECT_NE(html.dataType_, HTML);
+    EXPECT_TRUE(html.htmlContent_.empty());
+    EXPECT_TRUE(html.plainContent_.empty());
+    LOG_INFO(UDMF_TEST, "Html001 end.");
+}
+
+/**
+* @tc.name: Html002
+* @tc.desc: Abnormal testcase of Html, because plainContent and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, Html002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Html002 begin.");
+    const std::string htmlContent(20, 'a');
+    const std::string plainContent(MAX_TEXT_LEN, 'a');
+    Html html(htmlContent, plainContent);
+    EXPECT_NE(html.dataType_, HTML);
+    EXPECT_TRUE(html.htmlContent_.empty());
+    EXPECT_TRUE(html.plainContent_.empty());
+    LOG_INFO(UDMF_TEST, "Html002 end.");
+}
+
+/**
+* @tc.name: Html003
+* @tc.desc: Abnormal testcase of Html, because htmlContent and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, Html003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Html003 begin.");
+    const std::string htmlContent(20, 'a');
+    const std::string plainContent(MAX_TEXT_LEN, 'a');
+    Html html(htmlContent, plainContent);
+    EXPECT_NE(html.dataType_, HTML);
+    EXPECT_TRUE(html.htmlContent_.empty());
+    EXPECT_TRUE(html.plainContent_.empty());
+    LOG_INFO(UDMF_TEST, "Html003 end.");
+}
+
+/**
+* @tc.name: Html004
+* @tc.desc: Normal testcase of Html
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, Html004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Html004 begin.");
+    const std::string htmlContent(20, 'a');
+    const std::string plainContent(20, 'a');
+    Html html(htmlContent, plainContent);
+    EXPECT_EQ(html.dataType_, HTML);
+    EXPECT_EQ(html.htmlContent_, htmlContent);
+    EXPECT_EQ(html.plainContent_, plainContent);
+    LOG_INFO(UDMF_TEST, "Html004 end.");
+}
+
+/**
+* @tc.name: Html005
+* @tc.desc: Normal testcase of Html
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, Html005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Html005 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = "value";
+    Html html(type, value);
+    EXPECT_EQ(html.htmlContent_, std::get<std::string>(value));
+    LOG_INFO(UDMF_TEST, "Html005 end.");
+}
+
+/**
+* @tc.name: SetHtmlContent001
+* @tc.desc: Abnormal testcase of SetHtmlContent, because htmlContent and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, SetHtmlContent001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetHtmlContent001 begin.");
+    const std::string htmlContent(20 * 1024 * 1024, 'a');
+    Html html;
+    html.SetHtmlContent(htmlContent);
+    EXPECT_NE(html.htmlContent_, htmlContent);
+    LOG_INFO(UDMF_TEST, "SetHtmlContent001 end.");
+}
+
+/**
+* @tc.name: SetPlainContent002
+* @tc.desc: Abnormal testcase of SetPlainContent, because plainContent and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, SetPlainContent002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetPlainContent002 begin.");
+    const std::string plainContent(20 * 1024 * 1024, 'a');
+    Html html;
+    html.SetPlainContent(plainContent);
+    EXPECT_NE(html.plainContent_, plainContent);
+    LOG_INFO(UDMF_TEST, "SetPlainContent002 end.");
+}
+
+/**
+* @tc.name: GetValue001
+* @tc.desc: Normal testcase of GetValue
+* @tc.type: FUNC
+*/
+HWTEST_F(HtmlTest, GetValue001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetValue001 begin.");
+    Html html;
+    html.value_ = std::monostate{};
+    html.htmlContent_ = "htmlContent";
+    html.plainContent_ = "plainContent";
+    html.GetValue();
+    auto object = std::get<std::shared_ptr<Object>>(html.value_);
+    auto details_ = std::get<std::shared_ptr<Object>>(object->value_[Html::DETAILS]);
+    EXPECT_EQ(std::get<std::string>(object->value_[UNIFORM_DATA_TYPE]), "general.html");
+    EXPECT_EQ(std::get<std::string>(object->value_[HTML_CONTENT]), html.htmlContent_);
+    EXPECT_EQ(std::get<std::string>(object->value_[Html::PLAINT_CONTENT]), html.plainContent_);
+    EXPECT_EQ(details_->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "GetValue001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/image_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/image_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..20e65aa1e6488b63bdd6347b18164eccbf1ad196
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/image_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "ApplicationUtdJsonParserTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "image.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class ImageTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void ImageTest::SetUpTestCase()
+{
+}
+
+void ImageTest::TearDownTestCase()
+{
+}
+
+void ImageTest::SetUp()
+{
+}
+
+void ImageTest::TearDown()
+{
+}
+
+/**
+* @tc.name: ImageTest001
+* @tc.desc: Normal testcase of Image
+* @tc.type: FUNC
+*/
+HWTEST_F(ImageTest, ImageTest001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "ImageTest001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = "value";
+    Image image(type, value);
+    EXPECT_EQ(image.dataType_, IMAGE);
+    LOG_INFO(UDMF_TEST, "ImageTest001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/link_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/link_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62956c71547253bed96557e72b9399c9a41a820a
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/link_test.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "ApplicationUtdJsonParserTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "unified_record.h"
+#include "link.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class LinkTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void LinkTest::SetUpTestCase()
+{
+}
+
+void LinkTest::TearDownTestCase()
+{
+}
+
+void LinkTest::SetUp()
+{
+}
+
+void LinkTest::TearDown()
+{
+}
+
+/**
+* @tc.name: LinkTest001
+* @tc.desc: Normal testcase of Link
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, LinkTest001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "LinkTest001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = "value";
+    Link link(type, value);
+    EXPECT_EQ(link.url_, std::get<std::string>(value));
+    LOG_INFO(UDMF_TEST, "LinkTest001 end.");
+}
+
+/**
+* @tc.name: LinkTest002
+* @tc.desc: Abnormal testcase of Link,because url and description are equal to MAX_TEXT_LEN
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, LinkTest002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "LinkTest002 begin.");
+    const std::string url(MAX_TEXT_LEN, 'a');
+    const std::string description(MAX_TEXT_LEN, 'a');
+    Link link(url, description);
+    EXPECT_NE(link.dataType_, HYPERLINK);
+    EXPECT_NE(link.url_, url);
+    EXPECT_NE(link.description_, description);
+    LOG_INFO(UDMF_TEST, "LinkTest002 end.");
+}
+
+/**
+* @tc.name: LinkTest003
+* @tc.desc: Abnormal testcase of Link,because url and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, LinkTest003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "LinkTest003 begin.");
+    const std::string url(MAX_TEXT_LEN, 'a');
+    const std::string description(20, 'a');
+    Link link(url, description);
+    EXPECT_NE(link.dataType_, HYPERLINK);
+    EXPECT_NE(link.url_, url);
+    EXPECT_NE(link.description_, description);
+    LOG_INFO(UDMF_TEST, "LinkTest003 end.");
+}
+
+/**
+* @tc.name: LinkTest004
+* @tc.desc: Abnormal testcase of Link,because description and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, LinkTest004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "LinkTest004 begin.");
+    const std::string url(20, 'a');
+    const std::string description(MAX_TEXT_LEN, 'a');
+    Link link(url, description);
+    EXPECT_NE(link.dataType_, HYPERLINK);
+    EXPECT_NE(link.url_, url);
+    EXPECT_NE(link.description_, description);
+    LOG_INFO(UDMF_TEST, "LinkTest004 end.");
+}
+
+/**
+* @tc.name: SetUrlTest001
+* @tc.desc: Abnormal testcase of SetUrl,because url and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, SetUrlTest001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetUrlTest001 begin.");
+    const std::string url(MAX_TEXT_LEN, 'a');
+    Link link;
+    link.SetUrl(url);
+    EXPECT_NE(link.url_, url);
+    LOG_INFO(UDMF_TEST, "SetUrlTest001 end.");
+}
+
+/**
+* @tc.name: SetDescription001
+* @tc.desc: Abnormal testcase of SetDescription,because url and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, SetDescription001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetDescription001 begin.");
+    const std::string description(MAX_TEXT_LEN, 'a');
+    Link link;
+    link.SetDescription(description);
+    EXPECT_NE(link.description_, description);
+    LOG_INFO(UDMF_TEST, "SetDescription001 end.");
+}
+
+/**
+* @tc.name: SetDescription002
+* @tc.desc: Abnormal testcase of SetDescription,because description and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, SetDescription002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetDescription002 begin.");
+    const std::string description(MAX_TEXT_LEN, 'a');
+    Link link;
+    link.SetDescription(description);
+    EXPECT_NE(link.description_, description);
+    LOG_INFO(UDMF_TEST, "SetDescription002 end.");
+}
+
+/**
+* @tc.name: GetValue001
+* @tc.desc: Abnormal testcase of GetValue,because description and MAX_TEXT_LEN are equal
+* @tc.type: FUNC
+*/
+HWTEST_F(LinkTest, GetValue001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetValue001 begin.");
+    Link link;
+    link.value_ = std::monostate{};
+    link.url_ = "url_";
+    link.description_ = "description_";
+    link.GetValue();
+    auto object = std::get<std::shared_ptr<Object>>(link.value_);
+    auto details_ = std::get<std::shared_ptr<Object>>(object->value_[Link::DETAILS]);
+    EXPECT_EQ(std::get<std::string>(object->value_[Link::UNIFORM_DATA_TYPE]), "general.hyperlink");
+    EXPECT_EQ(std::get<std::string>(object->value_[Link::URL]), link.url_);
+    EXPECT_EQ(std::get<std::string>(object->value_[Link::DESCRIPTION]), link.description_);
+    EXPECT_EQ(details_->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "GetValue001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/mock/include/udmf_service_client_mock.h b/udmf/framework/innerkitsimpl/test/unittest/mock/include/udmf_service_client_mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a7795f08d7720bd808ada42be654d7260290bfb
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/mock/include/udmf_service_client_mock.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_SERVICE_CLIENT_MOCK_H
+#define UDMF_SERVICE_CLIENT_MOCK_H
+
+#include <gmock/gmock.h>
+
+#include "udmf_service_client.h"
+#include "unified_types.h"
+
+namespace OHOS {
+namespace UDMF {
+class MUdmfServiceClient {
+public:
+    virtual ~MUdmfServiceClient() = default;
+public:
+    virtual std::shared_ptr<UdmfServiceClient> GetInstance() = 0;
+
+    virtual int32_t SetData(CustomOption &, UnifiedData &, std::string &) = 0;
+    virtual int32_t GetData(const QueryOption &, UnifiedData &) = 0;
+    virtual int32_t GetBatchData(const QueryOption &, std::vector<UnifiedData> &) = 0;
+    virtual int32_t UpdateData(const QueryOption &, UnifiedData &) = 0;
+    virtual int32_t DeleteData(const QueryOption &, std::vector<UnifiedData> &) = 0;
+    virtual int32_t GetSummary(const QueryOption &, Summary &) = 0;
+    virtual int32_t AddPrivilege(const QueryOption &, Privilege &) = 0;
+    virtual int32_t Sync(const QueryOption &, const std::vector<std::string> &) = 0;
+    virtual int32_t IsRemoteData(const QueryOption &, bool &) = 0;
+    virtual int32_t SetAppShareOption(const std::string &, int32_t shareOption) = 0;
+    virtual int32_t GetAppShareOption(const std::string &, int32_t &) = 0;
+    virtual int32_t RemoveAppShareOption(const std::string &) = 0;
+    virtual int32_t ObtainAsynProcess(AsyncProcessInfo&) = 0;
+    virtual int32_t ClearAsynProcess() = 0;
+public:
+    static inline std::shared_ptr<MUdmfServiceClient> udmfServiceClient = nullptr;
+};
+
+class UdmfServiceClientMock : public MUdmfServiceClient {
+public:
+    MOCK_METHOD0(GetInstance, std::shared_ptr<UdmfServiceClient>());
+    MOCK_METHOD3(SetData, int32_t(CustomOption &, UnifiedData &, std::string &));
+    MOCK_METHOD2(GetData, int32_t(const QueryOption &, UnifiedData &));
+    MOCK_METHOD2(GetBatchData, int32_t(const QueryOption &, std::vector<UnifiedData> &));
+    MOCK_METHOD2(UpdateData, int32_t(const QueryOption &, UnifiedData &));
+    MOCK_METHOD2(DeleteData, int32_t(const QueryOption &, std::vector<UnifiedData> &));
+    MOCK_METHOD2(GetSummary, int32_t(const QueryOption &, Summary &));
+    MOCK_METHOD2(AddPrivilege, int32_t(const QueryOption &, Privilege &));
+    MOCK_METHOD2(Sync, int32_t(const QueryOption &, const std::vector<std::string> &));
+    MOCK_METHOD2(IsRemoteData, int32_t(const QueryOption &, bool &));
+    MOCK_METHOD2(SetAppShareOption, int32_t(const std::string &, int32_t shareOption));
+    MOCK_METHOD2(GetAppShareOption, int32_t(const std::string &, int32_t &));
+    MOCK_METHOD1(RemoveAppShareOption, int32_t(const std::string &));
+    MOCK_METHOD1(ObtainAsynProcess, int32_t(AsyncProcessInfo&));
+    MOCK_METHOD0(ClearAsynProcess, int32_t());
+};
+} // namespace UDMF
+} // namespace OHOS
+#endif // UDMF_SERVICE_CLIENT_MOCK_H
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/mock/system_defined_pixelmap_mock.cpp b/udmf/framework/innerkitsimpl/test/unittest/mock/system_defined_pixelmap_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5fe52c581eeb609c5ec9be4383fddbfa3605551b
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/mock/system_defined_pixelmap_mock.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "system_defined_pixelmap.h"
+
+namespace OHOS {
+namespace UDMF {
+
+SystemDefinedPixelMap::SystemDefinedPixelMap()
+{
+}
+
+SystemDefinedPixelMap::SystemDefinedPixelMap(std::vector<uint8_t> &data)
+{
+}
+
+SystemDefinedPixelMap::SystemDefinedPixelMap(UDType type, ValueType value) : SystemDefinedRecord(type, value)
+{
+}
+
+int64_t SystemDefinedPixelMap::GetSize()
+{
+    return 0;
+}
+
+std::vector<uint8_t> SystemDefinedPixelMap::GetRawData() const
+{
+    return this->rawData_;
+}
+
+void SystemDefinedPixelMap::SetRawData(const std::vector<uint8_t> &rawData)
+{
+}
+
+ValueType SystemDefinedPixelMap::GetValue()
+{
+    value_ = std::make_shared<Object>();
+    return value_;
+}
+
+void SystemDefinedPixelMap::InitObject()
+{
+}
+
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/mock/tlv_object_mock.cpp b/udmf/framework/innerkitsimpl/test/unittest/mock/tlv_object_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..561bbbede08552af86f2d70faa180597367c66ac
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/mock/tlv_object_mock.cpp
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "tlv_object.h"
+
+namespace OHOS {
+namespace UDMF {
+TLVObject::TLVObject(std::vector<std::uint8_t> &buffer)
+{
+    buffer_ = &buffer;
+}
+
+void TLVObject::SetFile(std::FILE *file)
+{
+}
+
+void TLVObject::UpdateSize()
+{
+}
+
+std::vector<std::uint8_t> TLVObject::GetBuffer()
+{
+    return *buffer_;
+}
+
+void TLVObject::Count(const uint32_t value)
+{
+}
+
+void TLVObject::Count(const uint64_t value)
+{
+}
+
+void TLVObject::Count(const int32_t value)
+{
+}
+
+void TLVObject::Count(const int64_t value)
+{
+}
+
+void TLVObject::Count(const float value)
+{
+}
+
+void TLVObject::Count(const double value)
+{
+}
+
+void TLVObject::Count(const std::string &value)
+{
+}
+
+void TLVObject::Count(const std::vector<uint8_t> &value)
+{
+}
+
+void TLVObject::Count(const UDVariant &value)
+{
+}
+
+void TLVObject::Count(const ValueType &value)
+{
+}
+
+void TLVObject::Count(const UDDetails &value)
+{
+}
+
+void TLVObject::Count(const UnifiedKey &value)
+{
+}
+
+void TLVObject::Count(const Privilege &value)
+{
+}
+
+void TLVObject::Count(const std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+}
+
+void TLVObject::Count(const std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+}
+
+void TLVObject::Count(const std::shared_ptr<Object> &value)
+{
+}
+
+void TLVObject::Count(const std::monostate &value)
+{
+}
+
+void TLVObject::Count(const void *value)
+{
+}
+
+bool TLVObject::WriteString(const std::string &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadString(std::string &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteVector(const std::vector<uint8_t> &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadVector(std::vector<uint8_t> &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteVariantInner(TAG &tag, const UDVariant &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteVariant(const UDVariant &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadVariantInner(uint16_t tag, UDVariant &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadVariant(UDVariant &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteVariantInner(TAG &tag, const ValueType &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteVariant(const ValueType &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadVariantInner(uint16_t tag, ValueType &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadVariant(ValueType &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteMap(const UDDetails &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadMap(UDDetails &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteObject(const std::shared_ptr<Object> &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadObject(std::shared_ptr<Object> &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteWant(const std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadWant(std::shared_ptr<OHOS::AAFwk::Want> &value)
+{
+    return true;
+}
+
+bool TLVObject::WritePixelMap(const std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadPixelMap(std::shared_ptr<OHOS::Media::PixelMap> &value)
+{
+    return false;
+}
+
+bool TLVObject::WriteUndefined(const std::monostate &value)
+{
+    return true;
+}
+
+bool TLVObject::ReadUndefined(std::monostate &value)
+{
+    return true;
+}
+
+bool TLVObject::WriteNull(const void *value)
+{
+    return true;
+}
+
+bool TLVObject::ReadNull(void *value)
+{
+    return true;
+}
+
+bool TLVObject::ReadHead(TLVHead &head)
+{
+    return true;
+}
+
+void TLVObject::WriteHead(uint16_t type, size_t tagCursor, uint32_t len)
+{
+}
+
+bool TLVObject::HasExpectBuffer(const uint32_t expectLen) const
+{
+    return true;
+}
+
+bool TLVObject::PrepareHeader(size_t size, size_t &tagCursor, size_t &valueCursor)
+{
+    return true;
+}
+
+void TLVObject::PrepareBuffer(size_t size)
+{
+}
+
+bool TLVObject::SaveBufferToFile()
+{
+    return true;
+}
+
+bool TLVObject::LoadBufferFormFile(size_t size)
+{
+    return true;
+}
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/mock/udmf_service_client_mock.cpp b/udmf/framework/innerkitsimpl/test/unittest/mock/udmf_service_client_mock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e906556bb7ec9660dd801923e08217a6b21728bd
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/mock/udmf_service_client_mock.cpp
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "udmf_service_client_mock.h"
+
+namespace OHOS::UDMF {
+using namespace std;
+
+std::shared_ptr<UdmfServiceClient> UdmfServiceClient::GetInstance()
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return nullptr;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->GetInstance();
+    }
+}
+
+int32_t UdmfServiceClient::GetAppShareOption(const std::string &intention, int32_t &shareOption)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->GetAppShareOption(intention, shareOption);
+    }
+}
+
+int32_t UdmfServiceClient::SetData(CustomOption &option, UnifiedData &unifiedData, std::string &key)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->SetData(option, unifiedData, key);
+    }
+}
+
+int32_t UdmfServiceClient::GetData(const QueryOption &query, UnifiedData &unifiedData)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->GetData(query, unifiedData);
+    }
+}
+
+int32_t UdmfServiceClient::GetBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->GetBatchData(query, unifiedDataSet);
+    }
+}
+
+int32_t UdmfServiceClient::DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->DeleteData(query, unifiedDataSet);
+    }
+}
+
+int32_t UdmfServiceClient::UpdateData(const QueryOption &query, UnifiedData &unifiedData)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->UpdateData(query, unifiedData);
+    }
+}
+
+int32_t UdmfServiceClient::GetSummary(const QueryOption &query, Summary &summary)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->GetSummary(query, summary);
+    }
+}
+
+int32_t UdmfServiceClient::IsRemoteData(const QueryOption &query, bool &result)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->IsRemoteData(query, result);
+    }
+}
+
+int32_t UdmfServiceClient::Sync(const QueryOption &query, const std::vector<std::string> &devices)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->Sync(query, devices);
+    }
+}
+
+int32_t UdmfServiceClient::ClearAsynProcess()
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->ClearAsynProcess();
+    }
+}
+
+int32_t UdmfServiceClient::SetAppShareOption(const std::string &intention, int32_t shareOption)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->SetAppShareOption(intention, shareOption);
+    }
+}
+
+
+int32_t UdmfServiceClient::RemoveAppShareOption(const std::string &intention)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->RemoveAppShareOption(intention);
+    }
+}
+
+int32_t UdmfServiceClient::AddPrivilege(const QueryOption &query, Privilege &privilege)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->AddPrivilege(query, privilege);
+    }
+}
+
+int32_t UdmfServiceClient::ObtainAsynProcess(AsyncProcessInfo &processInfo)
+{
+    if (MUdmfServiceClient::udmfServiceClient == nullptr) {
+        return -1;
+    } else {
+        return MUdmfServiceClient::udmfServiceClient->ObtainAsynProcess(processInfo);
+    }
+}
+} // namespace OHOS::UDMF
diff --git a/udmf/framework/innerkitsimpl/test/unittest/plain_text_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/plain_text_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a565355e0d275b0b1ae63dc1282b07116eefffe0
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/plain_text_test.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "PlainTextTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "plain_text.h"
+#include "udmf_capi_common.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class PlainTextTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void PlainTextTest::SetUpTestCase()
+{
+}
+
+void PlainTextTest::TearDownTestCase()
+{
+}
+
+void PlainTextTest::SetUp()
+{
+}
+
+void PlainTextTest::TearDown()
+{
+}
+
+/**
+* @tc.name: PlainText001
+* @tc.desc: Abnormal testcase of PlainText, because content is equal to MAX_TEXT_LEN
+* @tc.type: FUNC
+*/
+HWTEST_F(PlainTextTest, PlainText001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "PlainText001 begin.");
+    const std::string content(MAX_TEXT_LEN, 'a');
+    const std::string abstract = "abstract";
+    PlainText plainText(content, abstract);
+    EXPECT_NE(plainText.dataType_, PLAIN_TEXT);
+    EXPECT_NE(plainText.content_, content);
+    EXPECT_NE(plainText.abstract_, abstract);
+    LOG_INFO(UDMF_TEST, "PlainText001 end.");
+}
+
+/**
+* @tc.name: SetContent002
+* @tc.desc: Abnormal testcase of SetContent, because text is equal to MAX_TEXT_LEN
+* @tc.type: FUNC
+*/
+HWTEST_F(PlainTextTest, SetContent002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetContent002 begin.");
+    const std::string text(MAX_TEXT_LEN, 'a');
+    PlainText plainText;
+    plainText.SetContent(text);
+    EXPECT_NE(plainText.content_, text);
+    LOG_INFO(UDMF_TEST, "SetContent002 end.");
+}
+
+/**
+* @tc.name: SetAbstract003
+* @tc.desc: Abnormal testcase of SetAbstract, because abstract is equal to MAX_TEXT_LEN
+* @tc.type: FUNC
+*/
+HWTEST_F(PlainTextTest, SetAbstract003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetAbstract003 begin.");
+    const std::string abstract(MAX_TEXT_LEN, 'a');
+    PlainText plainText;
+    plainText.SetAbstract(abstract);
+    EXPECT_NE(plainText.abstract_, abstract);
+    LOG_INFO(UDMF_TEST, "SetAbstract003 end.");
+}
+
+/**
+* @tc.name: GetValue004
+* @tc.desc: Normal testcase of GetValue
+* @tc.type: FUNC
+*/
+HWTEST_F(PlainTextTest, GetValue004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetValue004 begin.");
+    PlainText plainText;
+    plainText.value_ = std::monostate{};
+    plainText.content_ = "content";
+    plainText.abstract_ = "abstract";
+    plainText.GetValue();
+    auto object = std::get<std::shared_ptr<Object>>(plainText.value_);
+    auto details_ = std::get<std::shared_ptr<Object>>(object->value_[PlainText::DETAILS]);
+    EXPECT_EQ(std::get<std::string>(object->value_[UNIFORM_DATA_TYPE]), "general.plain-text");
+    EXPECT_EQ(std::get<std::string>(object->value_[PlainText::TEXT_CONTENT]), plainText.content_);
+    EXPECT_EQ(std::get<std::string>(object->value_[ABSTRACT]), plainText.abstract_);
+    EXPECT_EQ(details_->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "GetValue004 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/system_defined_appitem_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/system_defined_appitem_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8a0be27ffe5773c85364535e04d0513cf515b95
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/system_defined_appitem_test.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "SystemDefinedAppitemTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "system_defined_appitem.h"
+#include "udmf_capi_common.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class SystemDefinedAppitemTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void SystemDefinedAppitemTest::SetUpTestCase()
+{
+}
+
+void SystemDefinedAppitemTest::TearDownTestCase()
+{
+}
+
+void SystemDefinedAppitemTest::SetUp()
+{
+}
+
+void SystemDefinedAppitemTest::TearDown()
+{
+}
+
+/**
+* @tc.name: SetItems001
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems001 begin.");
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.value_ = std::make_shared<Object>();
+    UDDetails details;
+    details.insert({ "string", "" });
+    systemDefinedAppItem.SetItems(details);
+    auto object = std::get<std::shared_ptr<Object>>(systemDefinedAppItem.value_);
+    EXPECT_EQ(std::get<std::string>(object->value_[UNIFORM_DATA_TYPE]), "openharmony.app-item");
+    LOG_INFO(UDMF_TEST, "SetItems001 end.");
+}
+
+/**
+* @tc.name: SetItems002
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems002 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::APPID, "SetItems002" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.appId_, "SetItems002");
+    LOG_INFO(UDMF_TEST, "SetItems002 end.");
+}
+
+/**
+* @tc.name: SetItems003
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems003 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::APPNAME, "SetItems003" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.appName_, "SetItems003");
+    LOG_INFO(UDMF_TEST, "SetItems003 end.");
+}
+
+/**
+* @tc.name: SetItems004
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems004 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::APPICONID, "SetItems004" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.appIconId_, "SetItems004");
+    LOG_INFO(UDMF_TEST, "SetItems004 end.");
+}
+
+/**
+* @tc.name: SetItems005
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems005 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::APPLABELID, "SetItems005" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.appLabelId_, "SetItems005");
+    LOG_INFO(UDMF_TEST, "SetItems005 end.");
+}
+
+/**
+* @tc.name: SetItems006
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems006, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems006 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::BUNDLENAME, "SetItems006" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.bundleName_, "SetItems006");
+    LOG_INFO(UDMF_TEST, "SetItems006 end.");
+}
+
+/**
+* @tc.name: SetItems007
+* @tc.desc: Normal testcase of SetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, SetItems007, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetItems007 begin.");
+    UDDetails details;
+    details.insert({ SystemDefinedAppItem::ABILITYNAME, "SetItems007" });
+    SystemDefinedAppItem systemDefinedAppItem;
+    systemDefinedAppItem.SetItems(details);
+    EXPECT_EQ(systemDefinedAppItem.abilityName_, "SetItems007");
+    LOG_INFO(UDMF_TEST, "SetItems007 end.");
+}
+
+/**
+* @tc.name: GetItems001
+* @tc.desc: Normal testcase of GetItems
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, GetItems001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetItems001 begin.");
+    SystemDefinedAppItem valueType;
+    valueType.appId_ = "appId";
+    valueType.appName_ = "appName_";
+    valueType.appIconId_ = "appIconId";
+    valueType.appLabelId_ = "appLabelId";
+    valueType.bundleName_ = "bundleName";
+    valueType.abilityName_ = "abilityName";
+    UDDetails items = valueType.GetItems();
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::APPID]), valueType.appId_);
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::APPNAME]), valueType.appName_);
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::APPICONID]), valueType.appIconId_);
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::APPLABELID]), valueType.appLabelId_);
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::BUNDLENAME]), valueType.bundleName_);
+    EXPECT_EQ(std::get<std::string>(items[SystemDefinedAppItem::ABILITYNAME]), valueType.abilityName_);
+    LOG_INFO(UDMF_TEST, "GetItems001 end.");
+}
+
+/**
+* @tc.name: GetValue001
+* @tc.desc: Normal testcase of GetValue
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedAppitemTest, GetValue001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetValue001 begin.");
+    SystemDefinedAppItem valueType;
+    valueType.value_ = std::monostate{};
+    valueType.appId_ = "appId";
+    valueType.appName_ = "appName_";
+    valueType.appIconId_ = "appIconId";
+    valueType.appLabelId_ = "appLabelId";
+    valueType.bundleName_ = "bundleName";
+    valueType.abilityName_ = "abilityName";
+    valueType.GetValue();
+    auto object = std::get<std::shared_ptr<Object>>(valueType.value_);
+    auto details = std::get<std::shared_ptr<Object>>(object->value_[SystemDefinedAppItem::DETAILS]);
+    EXPECT_EQ(std::get<std::string>(object->value_[UNIFORM_DATA_TYPE]), "openharmony.app-item");
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::APPID]), valueType.appId_);
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::APPNAME]), valueType.appName_);
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::APPICONID]), valueType.appIconId_);
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::APPLABELID]), valueType.appLabelId_);
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::BUNDLENAME]), valueType.bundleName_);
+    EXPECT_EQ(std::get<std::string>(object->value_[SystemDefinedAppItem::ABILITYNAME]), valueType.abilityName_);
+    EXPECT_EQ(details->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "GetValue001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/system_defined_form_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/system_defined_form_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8ffed727adeae19a4765d5c058dce12439c291f
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/system_defined_form_test.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "SystemDefinedFormTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "system_defined_form.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class SystemDefinedFormTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void SystemDefinedFormTest::SetUpTestCase()
+{
+}
+
+void SystemDefinedFormTest::TearDownTestCase()
+{
+}
+
+void SystemDefinedFormTest::SetUp()
+{
+}
+
+void SystemDefinedFormTest::TearDown()
+{
+}
+
+/**
+* @tc.name: SystemDefinedForm001
+* @tc.desc: Normal testcase of SystemDefinedForm
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedFormTest, SystemDefinedForm001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SystemDefinedForm001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    SystemDefinedForm systemDefinedForm(type, value);
+    EXPECT_EQ(systemDefinedForm.dataType_, SYSTEM_DEFINED_FORM);
+    LOG_INFO(UDMF_TEST, "SystemDefinedForm001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/system_defined_pixelmap_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/system_defined_pixelmap_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b881c8cf0581296be61300e0539acef4a875621
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/system_defined_pixelmap_test.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "SystemDefinedPixelMapTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "system_defined_pixelmap.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class SystemDefinedPixelMapTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void SystemDefinedPixelMapTest::SetUpTestCase()
+{
+}
+
+void SystemDefinedPixelMapTest::TearDownTestCase()
+{
+}
+
+void SystemDefinedPixelMapTest::SetUp()
+{
+}
+
+void SystemDefinedPixelMapTest::TearDown()
+{
+}
+
+/**
+* @tc.name: SystemDefinedPixelMap001
+* @tc.desc: Normal testcase of SystemDefinedPixelMap
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedPixelMapTest, SystemDefinedPixelMap001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap001 begin.");
+    std::vector<uint8_t> data = std::vector<uint8_t>();
+    SystemDefinedPixelMap systemDefinedPixelMap(data);
+    EXPECT_EQ(systemDefinedPixelMap.dataType_, SYSTEM_DEFINED_PIXEL_MAP);
+    EXPECT_EQ(systemDefinedPixelMap.rawData_, data);
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap001 end.");
+}
+
+/**
+* @tc.name: SystemDefinedPixelMap002
+* @tc.desc: Normal testcase of SystemDefinedPixelMap
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedPixelMapTest, SystemDefinedPixelMap002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap002 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = std::vector<uint8_t>();
+    SystemDefinedPixelMap systemDefinedPixelMap(type, value);
+    EXPECT_EQ(systemDefinedPixelMap.dataType_, SYSTEM_DEFINED_PIXEL_MAP);
+    EXPECT_EQ(systemDefinedPixelMap.rawData_, std::get<std::vector<uint8_t>>(value));
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap002 end.");
+}
+
+/**
+* @tc.name: SystemDefinedPixelMap003
+* @tc.desc: Abnormal testcase of SystemDefinedPixelMap, because value is not of type std::vector<uint8_t>
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedPixelMapTest, SystemDefinedPixelMap003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap003 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    SystemDefinedPixelMap systemDefinedPixelMap(type, value);
+    EXPECT_EQ(systemDefinedPixelMap.dataType_, SYSTEM_DEFINED_PIXEL_MAP);
+    EXPECT_EQ(systemDefinedPixelMap.rawData_.size(), 0);
+    LOG_INFO(UDMF_TEST, "SystemDefinedPixelMap003 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/system_defined_record_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/system_defined_record_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ff3f3d4ee5abb645d17b3411e1d761b30c761a89
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/system_defined_record_test.cpp
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "SystemDefinedRecordTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "system_defined_record.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class SystemDefinedRecordTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void SystemDefinedRecordTest::SetUpTestCase()
+{
+}
+
+void SystemDefinedRecordTest::TearDownTestCase()
+{
+}
+
+void SystemDefinedRecordTest::SetUp()
+{
+}
+
+void SystemDefinedRecordTest::TearDown()
+{
+}
+
+/**
+* @tc.name: AddProperty001
+* @tc.desc: Normal testcase of AddProperty
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedRecordTest, AddProperty001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "AddProperty001 begin.");
+    const std::string property = "first";
+    UDVariant value = 0;
+    SystemDefinedRecord systemDefinedRecord;
+    systemDefinedRecord.value_ = std::make_shared<Object>();
+    systemDefinedRecord.AddProperty(property, value);
+    auto object = std::get<std::shared_ptr<Object>>(systemDefinedRecord.value_);
+    auto details = std::get<std::shared_ptr<Object>>(object->value_[SystemDefinedRecord::DETAILS]);
+    EXPECT_EQ(systemDefinedRecord.details_.size(), 1);
+    EXPECT_NE(details->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "AddProperty001 end.");
+}
+
+/**
+* @tc.name: AddProperty002
+* @tc.desc: Normal testcase of AddProperty
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedRecordTest, AddProperty002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "AddProperty002 begin.");
+    UDVariant value = 0;
+    SystemDefinedRecord systemDefinedRecord;
+    systemDefinedRecord.details_.insert({ "first", "second" });
+    const std::string property = "first";
+    systemDefinedRecord.value_ = std::make_shared<Object>();
+    systemDefinedRecord.AddProperty(property, value);
+    auto object = std::get<std::shared_ptr<Object>>(systemDefinedRecord.value_);
+    auto details = std::get<std::shared_ptr<Object>>(object->value_[SystemDefinedRecord::DETAILS]);
+    EXPECT_EQ(systemDefinedRecord.details_[property], value);
+    EXPECT_NE(details->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "AddProperty002 end.");
+}
+
+/**
+* @tc.name: GetPropertyByName001
+* @tc.desc: Normal testcase of GetPropertyByName
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedRecordTest, GetPropertyByName001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetPropertyByName001 begin.");
+    const std::string property = "first";
+    SystemDefinedRecord systemDefinedRecord;
+    systemDefinedRecord.details_.insert({ "first", "second" });
+    const UDVariant ret = systemDefinedRecord.GetPropertyByName(property);
+    EXPECT_EQ(std::get<std::string>(ret), "second");
+    LOG_INFO(UDMF_TEST, "GetPropertyByName001 end.");
+}
+
+/**
+* @tc.name: InitObject001
+* @tc.desc: Normal testcase of InitObject
+* @tc.type: FUNC
+*/
+HWTEST_F(SystemDefinedRecordTest, InitObject001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "InitObject001 begin.");
+    SystemDefinedRecord systemDefinedRecord;
+    systemDefinedRecord.details_.insert({ "first", "second" });
+    systemDefinedRecord.value_ = std::make_shared<Object>();
+    systemDefinedRecord.InitObject();
+    auto object = std::get<std::shared_ptr<Object>>(systemDefinedRecord.value_);
+    auto details = std::get<std::shared_ptr<Object>>(object->value_[SystemDefinedRecord::DETAILS]);
+    EXPECT_NE(details->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "InitObject001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/text_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/text_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..75dceb9fd7213afb5e209b246014b3fc50d2a983
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/text_test.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "TextTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "html.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class TextTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void TextTest::SetUpTestCase()
+{
+}
+
+void TextTest::TearDownTestCase()
+{
+}
+
+void TextTest::SetUp()
+{
+}
+
+void TextTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Text001
+* @tc.desc: Normal testcase of Text
+* @tc.type: FUNC
+*/
+HWTEST_F(TextTest, Text001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Text001 begin.");
+    UDDetails variantMap;
+    variantMap.insert({ "details", "details"});
+    Text text(variantMap);
+    EXPECT_EQ(text.details_, variantMap);
+    LOG_INFO(UDMF_TEST, "Text001 end.");
+}
+
+/**
+* @tc.name: InitObject001
+* @tc.desc: Normal testcase of InitObject
+* @tc.type: FUNC
+*/
+HWTEST_F(TextTest, InitObject001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "InitObject001 begin.");
+    Text text;
+    text.value_ = std::make_shared<Object>();
+    text.details_.insert({ "first", "second" });
+    text.InitObject();
+    auto object = std::get<std::shared_ptr<Object>>(text.value_);
+    auto details = std::get<std::shared_ptr<Object>>(object->value_[Text::DETAILS]);
+    EXPECT_NE(details->value_.size(), 0);
+    LOG_INFO(UDMF_TEST, "InitObject001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/udmf_client_abnormal_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/udmf_client_abnormal_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cb6011a4ee15222b37ba94a48f368307798e95aa
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/udmf_client_abnormal_test.cpp
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UdmfClientAbnormalTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+
+#include "logger.h"
+//#include "udmf_capi_common.h"
+#include "udmf_client.h"
+#include "udmf_service_client_mock.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+using namespace testing;
+
+class UdmfClientAbnormalTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+
+    static inline shared_ptr<UdmfServiceClientMock> mock_ = nullptr;
+};
+
+void UdmfClientAbnormalTest::SetUpTestCase()
+{
+}
+
+void UdmfClientAbnormalTest::TearDownTestCase()
+{
+}
+
+void UdmfClientAbnormalTest::SetUp()
+{
+    mock_ = make_shared<UdmfServiceClientMock>();
+    MUdmfServiceClient::udmfServiceClient = mock_;
+}
+
+void UdmfClientAbnormalTest::TearDown()
+{
+    mock_ = nullptr;
+    MUdmfServiceClient::udmfServiceClient = nullptr;
+}
+
+/**
+* @tc.name: SetData001
+* @tc.desc: Abnrmal testcase of SetData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, SetData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    UnifiedData unifiedData;
+    CustomOption option;
+    std::string key = "testKey";
+
+    Status ret = client.SetData(option, unifiedData, key);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "SetData001 end.");
+}
+
+/**
+* @tc.name: GetData001
+* @tc.desc: Abnrmal testcase of GetData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, GetData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    UnifiedData unifiedData;
+
+    Status ret = client.GetData(query, unifiedData);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "GetData001 end.");
+}
+
+/**
+* @tc.name: GetBatchData001
+* @tc.desc: Abnrmal testcase of GetBatchData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, GetBatchData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetBatchData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    std::vector<UnifiedData> unifiedDataSet;
+
+    Status ret = client.GetBatchData(query, unifiedDataSet);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "GetBatchData001 end.");
+}
+
+/**
+* @tc.name: UpdateData001
+* @tc.desc: Abnrmal testcase of UpdateData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, UpdateData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "UpdateData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    UnifiedData unifiedData;
+
+    Status ret = client.UpdateData(query, unifiedData);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "UpdateData001 end.");
+}
+
+/**
+* @tc.name: DeleteData001
+* @tc.desc: Abnrmal testcase of DeleteData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, DeleteData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "DeleteData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    std::vector<UnifiedData> unifiedDataSet;
+
+    Status ret = client.DeleteData(query, unifiedDataSet);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "DeleteData001 end.");
+}
+
+/**
+* @tc.name: AddPrivilege001
+* @tc.desc: Abnrmal testcase of AddPrivilege, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, AddPrivilege001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "AddPrivilege001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    Privilege privilege;
+
+    Status ret = client.AddPrivilege(query, privilege);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "AddPrivilege001 end.");
+}
+
+/**
+* @tc.name: Sync001
+* @tc.desc: Abnrmal testcase of Sync, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, Sync001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Sync001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    const std::vector<std::string> devices;
+
+    Status ret = client.Sync(query, devices);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "Sync001 end.");
+}
+
+/**
+* @tc.name: IsRemoteData001
+* @tc.desc: Abnrmal testcase of IsRemoteData, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, IsRemoteData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsRemoteData001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const QueryOption query;
+    bool result = true;
+
+    Status ret = client.IsRemoteData(query, result);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "IsRemoteData001 end.");
+}
+
+/**
+* @tc.name: SetAppShareOption001
+* @tc.desc: Abnrmal testcase of SetAppShareOption, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, SetAppShareOption001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetAppShareOption001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const std::string intention = "intention";
+    enum ShareOptions shareOption = ShareOptions::IN_APP;
+
+    Status ret = client.SetAppShareOption(intention, shareOption);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "SetAppShareOption001 end.");
+}
+
+/**
+* @tc.name: GetAppShareOption001
+* @tc.desc: Abnrmal testcase of GetAppShareOption, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, GetAppShareOption001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetAppShareOption001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const std::string intention = "intention";
+    enum ShareOptions shareOption = ShareOptions::IN_APP;
+
+    Status ret = client.SetAppShareOption(intention, shareOption);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "GetAppShareOption001 end.");
+}
+
+/**
+* @tc.name: RemoveAppShareOption001
+* @tc.desc: Abnrmal testcase of RemoveAppShareOption, the return value of GetInstance() is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientAbnormalTest, RemoveAppShareOption001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "RemoveAppShareOption001 begin.");
+    EXPECT_CALL(*mock_, GetInstance()).WillOnce(Return(nullptr));
+
+    UdmfClient client;
+    const std::string intention = "intention";
+
+    Status ret = client.RemoveAppShareOption(intention);
+    EXPECT_EQ(ret, Status::E_IPC);
+    LOG_INFO(UDMF_TEST, "RemoveAppShareOption001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/udmf_client_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/udmf_client_test.cpp
index fd7eb24f70b6a78e98fa536505f4d6254db247c7..5e038cf819283ad66303c6500d315a80c3ea6592 100644
--- a/udmf/framework/innerkitsimpl/test/unittest/udmf_client_test.cpp
+++ b/udmf/framework/innerkitsimpl/test/unittest/udmf_client_test.cpp
@@ -90,6 +90,11 @@ void UdmfClientTest::SetUp()
 
 void UdmfClientTest::TearDown()
 {
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    query = { .intention = Intention::UD_INTENTION_DRAG };
+    UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
 }
 
 void UdmfClientTest::SetNativeToken(const std::string &processName)
@@ -1687,6 +1692,10 @@ HWTEST_F(UdmfClientTest, UpdateData002, TestSize.Level1)
     QueryOption queryOption = { .key = key };
     SetHapToken2();
     status = UdmfClient::GetInstance().UpdateData(queryOption, data);
+    ASSERT_EQ(status, E_INVALID_PARAMETERS);
+
+    SetHapToken1();
+    status = UdmfClient::GetInstance().UpdateData(queryOption, data);
     ASSERT_EQ(status, E_OK);
 
     std::vector<UnifiedData> dataSet;
@@ -1862,6 +1871,12 @@ HWTEST_F(UdmfClientTest, DeleteData002, TestSize.Level1)
     std::vector<UnifiedData> unifiedDataSet;
     status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
     ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(0, unifiedDataSet.size());
+
+    SetHapToken1();
+    status = UdmfClient::GetInstance().DeleteData(queryOption, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(1, unifiedDataSet.size());
 
     unifiedDataSet.clear();
     status = UdmfClient::GetInstance().GetBatchData(queryOption, unifiedDataSet);
@@ -2117,4 +2132,431 @@ HWTEST_F(UdmfClientTest, GetTypesLabels001, TestSize.Level1)
     ASSERT_EQ(data.HasType("general.plain-text"), true);
     ASSERT_EQ(data.HasType("general.html"), false);
 }
+
+/**
+* @tc.name: QueryUDSData001
+* @tc.desc: QueryUDSData001
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, QueryUDSData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "QueryUDSData001 begin.");
+
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    unifiedDataSet.clear();
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_TRUE(unifiedDataSet.empty());
+
+    CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    UnifiedData data;
+    std::shared_ptr<UnifiedRecord> record1 = std::make_shared<PlainText>(UDType::PLAIN_TEXT, "plainTextContent");
+    data.AddRecord(record1);
+    std::string key;
+    status = UdmfClient::GetInstance().SetData(customOption, data, key);
+    ASSERT_EQ(status, E_OK);
+
+    query = { .key = key };
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(unifiedDataSet.size(), 1);
+    std::shared_ptr<UnifiedRecord> record2 = unifiedDataSet[0].GetRecordAt(0);
+    ASSERT_NE(record2, nullptr);
+    ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
+    ValueType value = record2->GetValue();
+    ASSERT_NE(std::get_if<std::string>(&value), nullptr);
+    ASSERT_EQ(std::get<std::string>(value), "plainTextContent");
+    LOG_INFO(UDMF_TEST, "QueryUDSData001 end.");
+}
+
+/**
+* @tc.name: QueryUDSData002
+* @tc.desc: QueryUDSData002
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, QueryUDSData002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "QueryUDSData002 begin.");
+
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    unifiedDataSet.clear();
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_TRUE(unifiedDataSet.empty());
+
+    CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    UnifiedData data;
+    auto obj = std::make_shared<Object>();
+    obj->value_["uniformDataType"] = "general.plain-text";
+    obj->value_["textContent"] = "plainTextContent";
+    obj->value_["abstract"] = "plainTextAbstract";
+    auto obj2 = std::make_shared<Object>();
+    obj2->value_["detail1"] = "detail1";
+    obj2->value_["detail2"] = "detail2";
+    obj->value_["details"] = obj2;
+    auto record = std::make_shared<PlainText>(UDType::PLAIN_TEXT, obj);
+    data.AddRecord(record);
+    std::string key;
+    status = UdmfClient::GetInstance().SetData(customOption, data, key);
+    ASSERT_EQ(status, E_OK);
+
+    unifiedDataSet.clear();
+    query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(unifiedDataSet.size(), 1);
+    auto record2 = unifiedDataSet[0].GetRecordAt(0);
+    ASSERT_NE(record2, nullptr);
+    ASSERT_EQ(record2->GetType(), UDType::PLAIN_TEXT);
+    auto value = record2->GetValue();
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
+    obj = std::get<std::shared_ptr<Object>>(value);
+
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.plain-text");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["textContent"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["textContent"]), "plainTextContent");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["abstract"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["abstract"]), "plainTextAbstract");
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
+    obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
+
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
+    LOG_INFO(UDMF_TEST, "QueryUDSData002 end.");
+}
+
+/**
+* @tc.name: QueryUDSData003
+* @tc.desc: QueryUDSData003
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, QueryUDSData003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "QueryUDSData003 begin.");
+
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    unifiedDataSet.clear();
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_TRUE(unifiedDataSet.empty());
+
+    CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    UnifiedData data;
+    auto obj = std::make_shared<Object>();
+    obj->value_["uniformDataType"] = "general.hyperlink";
+    obj->value_["url"] = "www.xxx";
+    obj->value_["description"] = "hyperlinkDescription";
+    auto obj2 = std::make_shared<Object>();
+    obj2->value_["detail1"] = "detail1";
+    obj2->value_["detail2"] = "detail2";
+    obj->value_["details"] = obj2;
+    auto record = std::make_shared<Link>(UDType::HYPERLINK, obj);
+    data.AddRecord(record);
+    std::string key;
+    status = UdmfClient::GetInstance().SetData(customOption, data, key);
+    ASSERT_EQ(status, E_OK);
+
+    unifiedDataSet.clear();
+    query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(unifiedDataSet.size(), 1);
+    auto record2 = unifiedDataSet[0].GetRecordAt(0);
+    ASSERT_NE(record2, nullptr);
+    ASSERT_EQ(record2->GetType(), UDType::HYPERLINK);
+    auto value = record2->GetValue();
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
+    obj = std::get<std::shared_ptr<Object>>(value);
+
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.hyperlink");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["url"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["url"]), "www.xxx");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["description"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["description"]), "hyperlinkDescription");
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
+    obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
+
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
+    LOG_INFO(UDMF_TEST, "QueryUDSData003 end.");
+}
+
+/**
+* @tc.name: QueryUDSData004
+* @tc.desc: QueryUDSData004
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, QueryUDSData004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "QueryUDSData004 begin.");
+
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    unifiedDataSet.clear();
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_TRUE(unifiedDataSet.empty());
+
+    CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    UnifiedData data;
+    auto obj = std::make_shared<Object>();
+    obj->value_["uniformDataType"] = "general.html";
+    obj->value_["htmlContent"] = "www.xxx";
+    obj->value_["plainContent"] = "htmlPlainContent";
+    auto obj2 = std::make_shared<Object>();
+    obj2->value_["detail1"] = "detail1";
+    obj2->value_["detail2"] = "detail2";
+    obj->value_["details"] = obj2;
+    auto record = std::make_shared<Html>(UDType::HTML, obj);
+    data.AddRecord(record);
+    std::string key;
+    status = UdmfClient::GetInstance().SetData(customOption, data, key);
+    ASSERT_EQ(status, E_OK);
+
+    unifiedDataSet.clear();
+    query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(unifiedDataSet.size(), 1);
+    auto record2 = unifiedDataSet[0].GetRecordAt(0);
+    ASSERT_NE(record2, nullptr);
+    ASSERT_EQ(record2->GetType(), UDType::HTML);
+    auto value = record2->GetValue();
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
+    obj = std::get<std::shared_ptr<Object>>(value);
+
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "general.html");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["htmlContent"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["htmlContent"]), "www.xxx");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["plainContent"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["plainContent"]), "htmlPlainContent");
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
+    obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
+
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail2"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail2"]), "detail2");
+    LOG_INFO(UDMF_TEST, "QueryUDSData004 end.");
+}
+
+/**
+* @tc.name: QueryUDSData005
+* @tc.desc: QueryUDSData005
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, QueryUDSData005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "QueryUDSData005 begin.");
+
+    QueryOption query = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    std::vector<UnifiedData> unifiedDataSet;
+    auto status = UdmfClient::GetInstance().DeleteData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    unifiedDataSet.clear();
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_TRUE(unifiedDataSet.empty());
+
+    CustomOption customOption = { .intention = Intention::UD_INTENTION_DATA_HUB };
+    UnifiedData data;
+    auto obj = std::make_shared<Object>();
+    obj->value_["uniformDataType"] = "openharmony.app-item";
+    obj->value_["appId"] = "app-itemAppId";
+    obj->value_["appName"] = "app-itemAppName";
+    obj->value_["appIconId"] = "app-itemAppIconId";
+    obj->value_["appLabelId"] = "app-itemAppLabelId";
+    obj->value_["bundleName"] = "app-itemBundleName";
+    obj->value_["abilityName"] = "app-itemAbilityName";
+    auto obj2 = std::make_shared<Object>();
+    obj2->value_["detail1"] = "detail1";
+    obj2->value_["detail2"] = 1234;
+    obj->value_["details"] = obj2;
+    auto record = std::make_shared<SystemDefinedAppItem>(UDType::SYSTEM_DEFINED_APP_ITEM, obj);
+    data.AddRecord(record);
+    std::string key;
+    status = UdmfClient::GetInstance().SetData(customOption, data, key);
+    ASSERT_EQ(status, E_OK);
+
+    unifiedDataSet.clear();
+    query = { .key = key, .intention = UD_INTENTION_DATA_HUB };
+    status = UdmfClient::GetInstance().GetBatchData(query, unifiedDataSet);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(unifiedDataSet.size(), 1);
+    auto record2 = unifiedDataSet[0].GetRecordAt(0);
+    ASSERT_NE(record2, nullptr);
+    ASSERT_EQ(record2->GetType(), UDType::SYSTEM_DEFINED_APP_ITEM);
+    auto value = record2->GetValue();
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
+    obj = std::get<std::shared_ptr<Object>>(value);
+
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["uniformDataType"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["uniformDataType"]), "openharmony.app-item");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["appId"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["appId"]), "app-itemAppId");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["appName"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["appName"]), "app-itemAppName");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["appIconId"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["appIconId"]), "app-itemAppIconId");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["appLabelId"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["appLabelId"]), "app-itemAppLabelId");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["bundleName"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["bundleName"]), "app-itemBundleName");
+    ASSERT_NE(std::get_if<std::string>(&obj->value_["abilityName"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj->value_["abilityName"]), "app-itemAbilityName");
+
+    ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&obj->value_["details"]), nullptr);
+    obj2 = std::get<std::shared_ptr<Object>>(obj->value_["details"]);
+
+    ASSERT_NE(std::get_if<std::string>(&obj2->value_["detail1"]), nullptr);
+    ASSERT_EQ(std::get<std::string>(obj2->value_["detail1"]), "detail1");
+    ASSERT_NE(std::get_if<int32_t>(&obj2->value_["detail2"]), nullptr);
+    ASSERT_EQ(std::get<int32_t>(obj2->value_["detail2"]), 1234);
+    LOG_INFO(UDMF_TEST, "QueryUDSData005 end.");
+}
+
+/**
+* @tc.name: GetDataAsync01
+* @tc.desc: Set multiple record with valid params and async get data
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, GetDataAsync01, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetDataAsync01 begin.");
+
+    CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
+    std::string key;
+    UnifiedData inputData;
+    std::vector<std::shared_ptr<UnifiedRecord>> inputRecords = {
+        std::make_shared<Text>(),
+        std::make_shared<PlainText>(),
+        std::make_shared<File>(),
+        std::make_shared<Image>(),
+        std::make_shared<SystemDefinedRecord>(),
+        std::make_shared<SystemDefinedForm>(),
+        std::make_shared<ApplicationDefinedRecord>()
+    };
+    inputData.SetRecords(inputRecords);
+    auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
+    ASSERT_EQ(status, E_OK);
+
+
+    auto callback = [this, inputRecords](ProgressInfo progress, UnifiedData &outputData) {
+        LOG_INFO(UDMF_TEST, "GetDataAsync01 callback begin status=%{public}u, progress=%{public}u, name=%{public}s.",
+            progress.status, progress.progress, progress.srcDevName.c_str());
+        if (progress.status == ASYNC_IDLE || progress.status == ASYNC_RUNNING) {
+            return;
+        }
+        ASSERT_EQ(progress.status, ASYNC_SUCCESS);
+        ASSERT_EQ(progress.progress, 100);
+        auto outputRecords = outputData.GetRecords();
+        ASSERT_EQ(inputRecords.size(), outputRecords.size());
+        for (size_t i = 0; i < outputRecords.size(); ++i) {
+            ASSERT_EQ(outputRecords[i]->GetType(), inputRecords[i]->GetType());
+        }
+        LOG_INFO(UDMF_TEST, "GetDataAsync01 callback end.");
+    };
+    QueryOption queryOption = { .key = key };
+    status = UdmfClient::GetInstance().GetDataAsync(queryOption, callback);
+    ASSERT_EQ(status, E_OK);
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    LOG_INFO(UDMF_TEST, "GetDataAsync01 end.");
+}
+
+/**
+* @tc.name: GetDataAsync02
+* @tc.desc: Set multiple record with invalid params and async get data
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, GetDataAsync02, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetDataAsync02 begin.");
+    QueryOption queryOption;
+    auto status = UdmfClient::GetInstance().GetDataAsync(queryOption, nullptr);
+    ASSERT_NE(status, E_OK);
+    LOG_INFO(UDMF_TEST, "GetDataAsync02 end.");
+}
+
+/**
+* @tc.name: GetDataAsync03
+* @tc.desc: Set multiple record with invalid params and async get data
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, GetDataAsync03, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetDataAsync03 begin.");
+
+    CustomOption customOption = {.intention = Intention::UD_INTENTION_DRAG};
+    std::string key;
+    UnifiedData inputData;
+    std::vector<std::shared_ptr<UnifiedRecord>> inputRecords = {
+        std::make_shared<Text>(),
+        std::make_shared<PlainText>(),
+        std::make_shared<File>(),
+        std::make_shared<Image>(),
+        std::make_shared<SystemDefinedRecord>(),
+        std::make_shared<SystemDefinedForm>(),
+        std::make_shared<ApplicationDefinedRecord>()
+    };
+    inputData.SetRecords(inputRecords);
+    auto status = UdmfClient::GetInstance().SetData(customOption, inputData, key);
+    ASSERT_EQ(status, E_OK);
+
+
+    auto callback = [this, inputRecords](ProgressInfo progress, UnifiedData &outputData) {
+        LOG_INFO(UDMF_TEST, "GetDataAsync03 callback begin status=%{public}u, progress=%{public}u, name=%{public}s.",
+            progress.status, progress.progress, progress.srcDevName.c_str());
+        if (progress.status == ASYNC_IDLE || progress.status == ASYNC_RUNNING) {
+            return;
+        }
+        ASSERT_EQ(progress.status, ASYNC_FAILURE);
+        LOG_INFO(UDMF_TEST, "GetDataAsync03 callback end.");
+    };
+    QueryOption queryOption = { .key = "123456" };
+    status = UdmfClient::GetInstance().GetDataAsync(queryOption, callback);
+    ASSERT_EQ(status, E_OK);
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    LOG_INFO(UDMF_TEST, "GetDataAsync03 end.");
+}
+
+/**
+* @tc.name: GetSelfBundleName001
+* @tc.desc: Nrmal testcase of GetSelfBundleName
+* @tc.type: FUNC
+*/
+HWTEST_F(UdmfClientTest, GetSelfBundleName001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetSelfBundleName001 begin.");
+    UdmfClient udmfClient;
+    std::string ret = udmfClient.GetSelfBundleName();
+    EXPECT_NE(ret, "");
+    LOG_INFO(UDMF_TEST, "GetSelfBundleName001 end.");
+}
 } // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/unified_data_helper_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/unified_data_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..018e1b4fab1f3ac95cefc709c3f1615e892a12a4
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/unified_data_helper_test.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UnifiedDataHelperTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "unified_data_helper.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class UnifiedDataHelperTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void UnifiedDataHelperTest::SetUpTestCase()
+{
+}
+
+void UnifiedDataHelperTest::TearDownTestCase()
+{
+}
+
+void UnifiedDataHelperTest::SetUp()
+{
+}
+
+void UnifiedDataHelperTest::TearDown()
+{
+}
+
+constexpr mode_t MODE = 0700;
+constexpr const char *TEMP_UNIFIED_DATA_ROOT_PATH = "data/storage/el2/base/temp/udata";
+
+/**
+* @tc.name: CreateDirIfNotExist001
+* @tc.desc: Normal testcase of CreateDirIfNotExist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, CreateDirIfNotExist001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CreateDirIfNotExist001 begin.");
+    const std::string dirPath = "storage/media/100/local/files/Pictures";
+    const mode_t mode = MODE;
+    UnifiedDataHelper unifiedDataHelper;
+    unifiedDataHelper.CreateDirIfNotExist(dirPath, mode);
+    EXPECT_TRUE(true);
+    LOG_INFO(UDMF_TEST, "CreateDirIfNotExist001 end.");
+}
+
+/**
+* @tc.name: CreateDirIfNotExist002
+* @tc.desc: Abnormal testcase of CreateDirIfNotExist, the storage/el2/base/temp/udata path does not exist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, CreateDirIfNotExist002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "CreateDirIfNotExist002 begin.");
+    const std::string dirPath = "data/storage/el2/base/temp/udata";
+    const mode_t mode = MODE;
+    UnifiedDataHelper unifiedDataHelper;
+    unifiedDataHelper.CreateDirIfNotExist(dirPath, mode);
+    EXPECT_TRUE(true);
+    LOG_INFO(UDMF_TEST, "CreateDirIfNotExist002 end.");
+}
+
+/**
+* @tc.name: Unpack001
+* @tc.desc: Abnormal testcase of Unpack, the records_ length is 0
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, Unpack001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unpack001 begin.");
+    UnifiedData data;
+    UnifiedDataHelper unifiedDataHelper;
+    data.records_ = std::vector<std::shared_ptr<UnifiedRecord>>();
+    bool ret = unifiedDataHelper.Unpack(data);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unpack001 end.");
+}
+
+/**
+* @tc.name: Unpack002
+* @tc.desc: Abnormal testcase of Unpack, the data is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, Unpack002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Unpack002 begin.");
+    UnifiedData data;
+    UnifiedDataHelper unifiedDataHelper;
+    bool ret = unifiedDataHelper.Unpack(data);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "Unpack002 end.");
+}
+
+/**
+* @tc.name: SaveUDataToFile001
+* @tc.desc: Abnormal testcase of SaveUDataToFile, the data is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, SaveUDataToFile001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SaveUDataToFile001 begin.");
+    const std::string dataFile = "data/storage/el2/base/temp/udata";
+    UnifiedData data;
+    UnifiedDataHelper unifiedDataHelper;
+    bool ret = unifiedDataHelper.SaveUDataToFile(dataFile, data);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "SaveUDataToFile001 end.");
+}
+
+/**
+* @tc.name: LoadUDataFromFile001
+* @tc.desc: Abnormal testcase of LoadUDataFromFile, the data is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, LoadUDataFromFile001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "LoadUDataFromFile001 begin.");
+    const std::string dataFile = "data/storage/el2/base/temp/udata";
+    UnifiedData data;
+    UnifiedDataHelper unifiedDataHelper;
+    bool ret = unifiedDataHelper.LoadUDataFromFile(dataFile, data);
+    EXPECT_FALSE(ret);
+    LOG_INFO(UDMF_TEST, "LoadUDataFromFile001 end.");
+}
+
+/**
+* @tc.name: GetRootPath001
+* @tc.desc: Abnormal testcase of GetRootPath, the rootPath_ is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataHelperTest, GetRootPath001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetRootPath001 begin.");
+    UnifiedDataHelper unifiedDataHelper;
+    unifiedDataHelper.rootPath_ = "";
+    std::string ret = unifiedDataHelper.GetRootPath();
+    EXPECT_EQ(ret, TEMP_UNIFIED_DATA_ROOT_PATH);
+    LOG_INFO(UDMF_TEST, "GetRootPath001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/unified_data_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/unified_data_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7fbff42e758e8084fdf23a18c7828e0cdaf2015e
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/unified_data_test.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UnifiedDataTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "unified_data.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class UnifiedDataTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void UnifiedDataTest::SetUpTestCase()
+{
+}
+
+void UnifiedDataTest::TearDownTestCase()
+{
+}
+
+void UnifiedDataTest::SetUp()
+{
+}
+
+void UnifiedDataTest::TearDown()
+{
+}
+
+/**
+* @tc.name: UnifiedData001
+* @tc.desc: Normal testcase of UnifiedData
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, UnifiedData001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "UnifiedData001 begin.");
+    std::shared_ptr<UnifiedDataProperties> properties = std::make_shared<UnifiedDataProperties>();
+    UnifiedData unifiedData(properties);
+    auto duration = std::chrono::system_clock::now().time_since_epoch();
+    EXPECT_EQ(unifiedData.properties_, properties);
+    EXPECT_EQ(unifiedData.properties_->timestamp,
+        std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
+    LOG_INFO(UDMF_TEST, "UnifiedData001 end.");
+}
+
+/**
+* @tc.name: GetGroupId001
+* @tc.desc: Normal testcase of GetGroupId
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, GetGroupId001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetGroupId001 begin.");
+    UnifiedData unifiedData;
+    unifiedData.runtime_ = std::make_shared<Runtime>();
+    std::string ret = unifiedData.GetGroupId();
+    EXPECT_EQ(ret, unifiedData.runtime_->key.groupId);
+    LOG_INFO(UDMF_TEST, "GetGroupId001 end.");
+}
+
+/**
+* @tc.name: GetRuntime001
+* @tc.desc: Normal testcase of GetRuntime
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, GetRuntime001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetRuntime001 begin.");
+    UnifiedData unifiedData;
+    unifiedData.runtime_ = std::make_shared<Runtime>();
+    std::shared_ptr<Runtime> ret = unifiedData.GetRuntime();
+    EXPECT_EQ(ret, unifiedData.runtime_);
+    LOG_INFO(UDMF_TEST, "GetRuntime001 end.");
+}
+
+/**
+* @tc.name: SetRuntime001
+* @tc.desc: Normal testcase of SetRuntime
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, SetRuntime001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SetRuntime001 begin.");
+    UnifiedData unifiedData;
+    Runtime runtime{};
+    unifiedData.SetRuntime(runtime);
+    EXPECT_NE(unifiedData.runtime_, nullptr);
+    LOG_INFO(UDMF_TEST, "SetRuntime001 end.");
+}
+
+/**
+* @tc.name: AddRecord001
+* @tc.desc: Abnormal testcase of AddRecord, because record is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, AddRecord001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "AddRecord001 begin.");
+    const std::shared_ptr<UnifiedRecord> record = nullptr;
+    UnifiedData unifiedData;
+    unifiedData.AddRecord(record);
+    EXPECT_EQ(unifiedData.records_.size(), 0);
+    LOG_INFO(UDMF_TEST, "AddRecord001 end.");
+}
+
+/**
+* @tc.name: AddRecords001
+* @tc.desc: Abnormal testcase of AddRecords, because record is nullptr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, AddRecords001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "AddRecords001 begin.");
+    const std::vector<std::shared_ptr<UnifiedRecord>> record = {nullptr};
+    UnifiedData unifiedData;
+    unifiedData.AddRecords(record);
+    EXPECT_EQ(unifiedData.records_.size(), 0);
+    LOG_INFO(UDMF_TEST, "AddRecords001 end.");
+}
+
+/**
+* @tc.name: GetRecordAt001
+* @tc.desc: Abnormal testcase of GetRecordAt, because the length of records_ is equal to the length of index
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedDataTest, GetRecordAt001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetRecordAt001 begin.");
+    UnifiedData unifiedData;
+    unifiedData.records_ = std::vector<std::shared_ptr<UnifiedRecord>>();
+    std::size_t index = unifiedData.records_.size();
+    std::shared_ptr<UnifiedRecord> ret = unifiedData.GetRecordAt(index);
+    EXPECT_EQ(ret, nullptr);
+    LOG_INFO(UDMF_TEST, "GetRecordAt001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/unified_meta_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/unified_meta_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d569086389fc2b86e0f3c1feaad73aa15af29e5
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/unified_meta_test.cpp
@@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UnifiedMetaTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "unified_meta.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class UnifiedMetaTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+    static constexpr int INT32_SIZE = 4;
+    static constexpr int INT64_SIZE = 8;
+    static constexpr int BOOL_SIZE = 1;
+    static constexpr int DOUBLE_SIZE = 8;
+};
+
+void UnifiedMetaTest::SetUpTestCase()
+{
+}
+
+void UnifiedMetaTest::TearDownTestCase()
+{
+}
+
+void UnifiedMetaTest::SetUp()
+{
+}
+
+void UnifiedMetaTest::TearDown()
+{
+}
+
+/**
+* @tc.name: IsValidType001
+* @tc.desc: Normal testcase of IsValidType
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidType001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsValidType001 begin.");
+    int32_t value = 0;
+    bool ret = UnifiedDataUtils::IsValidType(value);
+    EXPECT_EQ(ret, value >= ENTITY && value < UD_BUTT);
+    LOG_INFO(UDMF_TEST, "IsValidType001 end.");
+}
+
+/**
+* @tc.name: GetEnumNum001
+* @tc.desc: Normal testcase of GetEnumNum
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetEnumNum001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetEnumNum001 begin.");
+    const std::string shareOption = "";
+    int32_t ret = ShareOptionsUtil::GetEnumNum(shareOption);
+    EXPECT_EQ(ret, ShareOptions::SHARE_OPTIONS_BUTT);
+    LOG_INFO(UDMF_TEST, "GetEnumNum001 end.");
+}
+
+/**
+* @tc.name: GetEnumNum002
+* @tc.desc: Abnormal testcase of GetEnumNum, shareOption is APP_SHARE_OPTIONS.enumNum
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetEnumNum002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetEnumNum002 begin.");
+    const std::string shareOption = "CROSS_APP";
+    int32_t ret = ShareOptionsUtil::GetEnumNum(shareOption);
+    EXPECT_EQ(ret, 1);
+    LOG_INFO(UDMF_TEST, "GetEnumNum002 end.");
+}
+
+/**
+* @tc.name: GetEnumStr001
+* @tc.desc: Normal testcase of GetEnumStr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetEnumStr001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetEnumStr001 begin.");
+    int32_t shareOption = 4;
+    std::string ret = ShareOptionsUtil::GetEnumStr(shareOption);
+    EXPECT_EQ(ret, "");
+    LOG_INFO(UDMF_TEST, "GetEnumStr001 end.");
+}
+
+/**
+* @tc.name: GetEnumStr002
+* @tc.desc: Abnormal testcase of GetEnumStr, shareOption is APP_SHARE_OPTIONS.enumStr
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetEnumStr002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetEnumStr002 begin.");
+    int32_t shareOption = 1;
+    std::string ret = ShareOptionsUtil::GetEnumStr(shareOption);
+    EXPECT_NE(ret, "");
+    LOG_INFO(UDMF_TEST, "GetEnumStr002 end.");
+}
+
+/**
+* @tc.name: IsValidUtdId001
+* @tc.desc: Normal testcase of IsValidUtdId
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidUtdId001, TestSize.Level1)
+{
+    std::string utdId = "general.text";
+    bool ret = UtdUtils::IsValidUtdId(utdId);
+    EXPECT_TRUE(ret);
+}
+
+/**
+* @tc.name: IsValidUtdId002
+* @tc.desc: Abnormal testcase of IsValidUtdId
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidUtdId002, TestSize.Level1)
+{
+    std::string utdId = "general.ptp";
+    bool ret = UtdUtils::IsValidUtdId(utdId);
+    EXPECT_FALSE(ret);
+}
+
+/**
+* @tc.name: GetUtdEnumFromUtdId001
+* @tc.desc: Normal testcase of GetUtdEnumFromUtdId
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetUtdEnumFromUtdId001, TestSize.Level1)
+{
+    std::string utdId = "general.text";
+    int32_t ret = UtdUtils::GetUtdEnumFromUtdId(utdId);
+    EXPECT_EQ(ret, UDType::TEXT);
+}
+
+/**
+* @tc.name: GetUtdEnumFromUtdId002
+* @tc.desc: Abnormal testcase of GetUtdEnumFromUtdId
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetUtdEnumFromUtdId002, TestSize.Level1)
+{
+    std::string utdId = "general.ptp";
+    int32_t ret = UtdUtils::GetUtdEnumFromUtdId(utdId);
+    EXPECT_EQ(ret, UDType::UD_BUTT);
+}
+
+/**
+* @tc.name: GetUtdIdFromUtdEnum001
+* @tc.desc: Normal testcase of GetUtdIdFromUtdEnum
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetUtdIdFromUtdEnum001, TestSize.Level1)
+{
+    std::string ret = UtdUtils::GetUtdIdFromUtdEnum(UDType::TEXT);
+    EXPECT_EQ(ret, "general.text");
+}
+
+/**
+* @tc.name: GetUtdIdFromUtdEnum002
+* @tc.desc: Abnormal testcase of GetUtdIdFromUtdEnum
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetUtdIdFromUtdEnum002, TestSize.Level1)
+{
+    std::string ret = UtdUtils::GetUtdIdFromUtdEnum(UDType::UD_BUTT);
+    EXPECT_TRUE(ret.empty());
+
+    std::string ret1 = UtdUtils::GetUtdIdFromUtdEnum(UDType::UD_BUTT + 1);
+    EXPECT_TRUE(ret1.empty());
+}
+
+/**
+* @tc.name: GetUtdTypes001
+* @tc.desc: Normal testcase of GetUtdTypes
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetUtdTypes001, TestSize.Level1)
+{
+    std::vector<UtdType> ret = UtdUtils::GetUtdTypes();
+    EXPECT_TRUE(ret.size() > 0);
+}
+
+/**
+* @tc.name: UnifiedDataUtilsIsValidType001
+* @tc.desc: Abnormal testcase of IsValidType
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, UnifiedDataUtilsIsValidType001, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsValidType(UDType::UD_BUTT);
+    EXPECT_FALSE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsValidType(UDType::ENTITY - 1);
+    EXPECT_FALSE(ret1);
+
+    bool ret2 = UnifiedDataUtils::IsValidType(UDType::UD_BUTT + 1);
+    EXPECT_FALSE(ret2);
+}
+
+/**
+* @tc.name: UnifiedDataUtilsIsValidType002
+* @tc.desc: Normal testcase of IsValidType
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, UnifiedDataUtilsIsValidType002, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsValidType(UDType::TEXT);
+    EXPECT_TRUE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsValidType(UDType::ENTITY);
+    EXPECT_TRUE(ret1);
+}
+
+/**
+* @tc.name: IsValidIntention001
+* @tc.desc: Normal testcase of IsValidIntention
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidIntention001, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_DRAG);
+    EXPECT_TRUE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_DATA_HUB);
+    EXPECT_TRUE(ret1);
+}
+
+/**
+* @tc.name: IsValidIntention002
+* @tc.desc: Abnormal testcase of IsValidIntention
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidIntention002, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BASE);
+    EXPECT_FALSE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BUTT);
+    EXPECT_FALSE(ret1);
+
+    bool ret2 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BASE - 1);
+    EXPECT_FALSE(ret2);
+
+    bool ret3 = UnifiedDataUtils::IsValidIntention(Intention::UD_INTENTION_BUTT + 1);
+    EXPECT_FALSE(ret3);
+}
+
+/**
+* @tc.name: ShareOptionsUtilIsValid001
+* @tc.desc: Normal testcase of IsValid
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, ShareOptionsUtilIsValid001, TestSize.Level1)
+{
+    bool ret = ShareOptionsUtil::IsValid(ShareOptions::IN_APP);
+    EXPECT_TRUE(ret);
+
+    bool ret1 = ShareOptionsUtil::IsValid(ShareOptions::CROSS_APP);
+    EXPECT_TRUE(ret1);
+}
+
+/**
+* @tc.name: ShareOptionsUtilIsValid002
+* @tc.desc: Abnormal testcase of IsValid
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, ShareOptionsUtilIsValid002, TestSize.Level1)
+{
+    bool ret = ShareOptionsUtil::IsValid(ShareOptions::IN_APP - 1);
+    EXPECT_FALSE(ret);
+
+    bool ret1 = ShareOptionsUtil::IsValid(ShareOptions::SHARE_OPTIONS_BUTT);
+    EXPECT_FALSE(ret1);
+
+    bool ret2 = ShareOptionsUtil::IsValid(ShareOptions::SHARE_OPTIONS_BUTT + 1);
+    EXPECT_FALSE(ret2);
+}
+
+/**
+* @tc.name: GetVariantSize001
+* @tc.desc: Normal testcase of GetVariantSize
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetVariantSize001, TestSize.Level1)
+{
+    UDVariant variant;
+    // case int32_t
+    variant = (int32_t)100;
+    size_t int32tSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(int32tSize, INT32_SIZE);
+
+    variant = (int64_t)100;
+    size_t int64tSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(int64tSize, INT64_SIZE);
+
+    variant = true;
+    size_t boolSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(boolSize, BOOL_SIZE);
+
+    variant = 100.0001;
+    size_t doubleSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(doubleSize, DOUBLE_SIZE);
+
+    std::string str = "string size";
+    variant = str;
+    size_t strSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(strSize, str.size());
+
+    std::vector<uint8_t> uVecEmpty;
+    variant = uVecEmpty;
+    size_t vecEmpSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(vecEmpSize, uVecEmpty.size());
+
+    std::vector<uint8_t> uVec(100, 100);
+    variant = uVec;
+    size_t uVecSize = UnifiedDataUtils::GetVariantSize(variant);
+    EXPECT_EQ(uVecSize, uVec.size());
+}
+
+/**
+* @tc.name: GetDetailsSize001
+* @tc.desc: Normal testcase of GetDetailsSize
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetDetailsSize001, TestSize.Level1)
+{
+    std::string int32Key = "int32Key";
+    std::string int64Key = "int64Key";
+    std::string strKey = "strKey";
+    std::string str = "string size";
+    UDDetails details = {
+        {int32Key, (int32_t)100},
+        {int64Key, (int64_t)100},
+        {strKey, str}
+    };
+    size_t ret = UnifiedDataUtils::GetDetailsSize(details);
+    EXPECT_EQ(ret, int32Key.size() + int64Key.size() + strKey.size() + INT32_SIZE + INT64_SIZE + str.size());
+}
+
+/**
+* @tc.name: IsPersistByIntention001
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsPersistByIntention001, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_DATA_HUB);
+    EXPECT_TRUE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_BUTT);
+    EXPECT_FALSE(ret1);
+
+    bool ret2 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_DRAG);
+    EXPECT_FALSE(ret2);
+
+    bool ret3 = UnifiedDataUtils::IsPersist(Intention::UD_INTENTION_BASE);
+    EXPECT_FALSE(ret3);
+}
+
+/**
+* @tc.name: IsPersistByStr001
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsPersistByStr001, TestSize.Level1)
+{
+    bool ret = UnifiedDataUtils::IsPersist("DataHub");
+    EXPECT_TRUE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsPersist("drag");
+    EXPECT_FALSE(ret1);
+
+    bool ret2 = UnifiedDataUtils::IsPersist("invalid param");
+    EXPECT_FALSE(ret2);
+}
+
+/**
+* @tc.name: GetIntentionByString001
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetIntentionByString001, TestSize.Level1)
+{
+    Intention ret = UnifiedDataUtils::GetIntentionByString("DataHub");
+    EXPECT_EQ(ret, Intention::UD_INTENTION_DATA_HUB);
+
+    Intention ret1 = UnifiedDataUtils::GetIntentionByString("drag");
+    EXPECT_EQ(ret1, Intention::UD_INTENTION_DRAG);
+
+    Intention ret2 = UnifiedDataUtils::GetIntentionByString("invalid param");
+    EXPECT_EQ(ret2, UD_INTENTION_BUTT);
+}
+
+/**
+* @tc.name: IsValidOptions001
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, IsValidOptions001, TestSize.Level1)
+{
+    std::string keyDataHub = "udmf://DataHub/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
+    std::string keyDrag = "udmf://drag/com.hmos.photos/CSl;cdcGFcmdkasaccCSCAAScscdc";
+    std::string intentionDataHub = "DataHub";
+    std::string intentionDrag = "drag";
+    std::string intentionEmpty = "";
+
+    bool ret = UnifiedDataUtils::IsValidOptions("", intentionDataHub);
+    EXPECT_TRUE(ret);
+
+    bool ret1 = UnifiedDataUtils::IsValidOptions(keyDataHub, intentionEmpty);
+    EXPECT_TRUE(ret1);
+
+    bool ret2 = UnifiedDataUtils::IsValidOptions(keyDataHub, intentionDataHub);
+    EXPECT_TRUE(ret2);
+
+    bool ret3 = UnifiedDataUtils::IsValidOptions(keyDataHub, intentionDrag);
+    EXPECT_FALSE(ret3);
+
+    bool ret4 = UnifiedDataUtils::IsValidOptions(keyDrag, intentionDrag);
+    EXPECT_FALSE(ret4);
+}
+
+/**
+* @tc.name: GetValue001
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetValue001, TestSize.Level1)
+{
+    Object object;
+    std::string key = "key";
+    std::string content = "content";
+    object.value_ = {
+        {key, content}
+    };
+    std::string value;
+    bool ret = object.GetValue(key, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, content);
+
+    std::string valueEmpty;
+    bool ret1 = object.GetValue("invalid key", valueEmpty);
+    EXPECT_FALSE(ret1);
+    EXPECT_TRUE(valueEmpty.empty());
+}
+
+/**
+* @tc.name: GetValue002
+* @tc.desc: Normal testcase of IsPersist
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedMetaTest, GetValue002, TestSize.Level1)
+{
+    Object object;
+    std::shared_ptr<Object> objectInner = std::make_shared<Object>();
+    std::string key = "key";
+    std::string keyObj = "keyObj";
+    std::string content = "content";
+    objectInner->value_ = {
+        {key, content}
+    };
+    object.value_ = {
+        {key, content},
+        {keyObj, objectInner}
+    };
+    std::shared_ptr<Object> value = std::make_shared<Object>();
+    bool ret = object.GetValue(keyObj, value);
+    EXPECT_TRUE(ret);
+
+    std::string innerValue;
+    bool ret1 = value->GetValue(key, innerValue);
+    EXPECT_TRUE(ret1);
+    EXPECT_EQ(innerValue, content);
+
+    std::shared_ptr<Object> valueEmpty = std::make_shared<Object>();
+    bool ret2 = object.GetValue("invalid key", valueEmpty);
+    EXPECT_FALSE(ret2);
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/unified_record_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/unified_record_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d43a1c70521a78ca2038741236c63b3b48eda13c
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/unified_record_test.cpp
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "UnifiedRecordTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "unified_record.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class UnifiedRecordTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void UnifiedRecordTest::SetUpTestCase()
+{
+}
+
+void UnifiedRecordTest::TearDownTestCase()
+{
+}
+
+void UnifiedRecordTest::SetUp()
+{
+}
+
+void UnifiedRecordTest::TearDown()
+{
+}
+
+/**
+* @tc.name: GetSize001
+* @tc.desc: Normal testcase of GetSize
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedRecordTest, GetSize001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetSize001 begin.");
+    UnifiedRecord unifiedRecord;
+    int64_t ret = unifiedRecord.GetSize();
+    EXPECT_EQ(ret, 0);
+    LOG_INFO(UDMF_TEST, "GetSize001 end.");
+}
+
+/**
+* @tc.name: GetValue001
+* @tc.desc: Normal testcase of GetValue
+* @tc.type: FUNC
+*/
+HWTEST_F(UnifiedRecordTest, GetValue001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetValue001 begin.");
+    UnifiedRecord unifiedRecord;
+    unifiedRecord.value_ = "value";
+    ValueType ret = unifiedRecord.GetValue();
+    EXPECT_EQ(ret, unifiedRecord.value_);
+    LOG_INFO(UDMF_TEST, "GetValue001 end.");
+}
+
+
+/**
+ * @tc.name: Constructor_001
+ * @tc.desc: Verify the constructor.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UnifiedRecordTest, Constructor_001, TestSize.Level0)
+{
+    UnifiedRecord record;
+
+    auto type = record.GetType();
+    EXPECT_EQ(type, UD_BUTT);
+
+    auto types = record.GetUtdIds();
+    EXPECT_TRUE(types.empty());
+
+    auto originValue = record.GetOriginValue();
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(originValue));
+
+    auto entry = record.GetEntry("");
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(entry));
+
+    auto entries = record.GetEntries();
+    EXPECT_TRUE(entries->empty());
+}
+
+/**
+ * @tc.name: Constructor_002
+ * @tc.desc: Verify the constructor.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UnifiedRecordTest, Constructor_002, TestSize.Level0)
+{
+    auto utdId = UtdUtils::GetUtdIdFromUtdEnum(TEXT);
+
+    UnifiedRecord record(TEXT);
+    auto type = record.GetType();
+    EXPECT_EQ(type, TEXT);
+    auto types = record.GetUtdIds();
+    EXPECT_TRUE(types.find(utdId) != types.end());
+
+    auto originValue = record.GetOriginValue();
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(originValue));
+
+    auto entry = record.GetEntry(utdId);
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(entry));
+
+    auto entries = record.GetEntries();
+    auto it = entries->find(utdId);
+    ASSERT_TRUE(it != entries->end());
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(it->second));
+}
+
+/**
+ * @tc.name: Constructor_003
+ * @tc.desc: Verify the constructor.
+ * @tc.type: FUNC
+ */
+HWTEST_F(UnifiedRecordTest, Constructor_003, TestSize.Level0)
+{
+    auto utdId = UtdUtils::GetUtdIdFromUtdEnum(TEXT);
+    UnifiedRecord record(TEXT, "123456");
+    auto type = record.GetType();
+    EXPECT_EQ(type, TEXT);
+    auto types = record.GetUtdIds();
+    EXPECT_TRUE(types.find(utdId) != types.end());
+
+    auto originValue = record.GetOriginValue();
+    EXPECT_TRUE(std::holds_alternative<std::string>(originValue));
+    auto originValueStr = std::get_if<std::string>(&originValue);
+    EXPECT_EQ(*originValueStr, "123456");
+
+    auto entry = record.GetEntry(utdId);
+    EXPECT_TRUE(std::holds_alternative<std::string>(entry));
+    auto entryStr = std::get_if<std::string>(&entry);
+    EXPECT_EQ(*entryStr, "123456");
+
+    auto entries = record.GetEntries();
+    auto it = entries->find(utdId);
+    ASSERT_TRUE(it != entries->end());
+    auto entry2 = it->second;
+    EXPECT_TRUE(std::holds_alternative<std::string>(entry2));
+    auto entryStr2 = std::get_if<std::string>(&entry2);
+    EXPECT_EQ(*entryStr2, "123456");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/utd_client_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/utd_client_test.cpp
index 20e50fd595cd30876c7bc817b6b2823fb7335b73..bd64b784fa9b364fbabed6b5843478e89d746756 100644
--- a/udmf/framework/innerkitsimpl/test/unittest/utd_client_test.cpp
+++ b/udmf/framework/innerkitsimpl/test/unittest/utd_client_test.cpp
@@ -25,11 +25,15 @@
 #include "utd_client.h"
 #include "type_descriptor.h"
 #include "preset_type_descriptors.h"
+#include "utd_graph.h"
 
 using namespace testing::ext;
 using namespace OHOS::Security::AccessToken;
 using namespace OHOS::UDMF;
 using namespace OHOS;
+
+constexpr const char* CUSTOM_UTD_HAP_DIR = "/data/utd/utd-adt.json";
+
 namespace OHOS::Test {
 class UtdClientTest : public testing::Test {
 public:
@@ -1387,4 +1391,572 @@ HWTEST_F(UtdClientTest, IsUtd004, TestSize.Level1)
     EXPECT_EQ(result, false);
     LOG_INFO(UDMF_TEST, "IsUtd004 end.");
 }
+
+/**
+* @tc.name: GetUniformDataTypeByMIMETypeByPrefix001
+* @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 begin.");
+    std::string mimeType = "application/vnd.openxmlformats-officedocument.*";
+    std::string currType;
+    auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
+    EXPECT_EQ(status, E_OK);
+    std::shared_ptr<TypeDescriptor> descriptor;
+    status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
+    EXPECT_EQ(descriptor->GetTypeId(), currType);
+
+    std::string mimeType2 = "application/vnd.openxmlformats-officedocument.wordprocessingml.*";
+    std::string currType2;
+    status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
+    EXPECT_EQ(status, E_OK);
+    status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
+    EXPECT_EQ(descriptor->GetTypeId(), currType2);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypeByMIMETypeByPrefix002
+* @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 begin.");
+    std::string mimeType = "application/vnd.openxmlformats-OFFICEdocument.*";
+    std::string currType;
+    auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
+    EXPECT_EQ(status, E_OK);
+    std::shared_ptr<TypeDescriptor> descriptor;
+    status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
+    EXPECT_EQ(descriptor->GetTypeId(), currType);
+
+    std::string mimeType2 = "application/vnd.openxmlformats-OFFICEdocument.wordprocessingml.*";
+    std::string currType2;
+    status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
+    EXPECT_EQ(status, E_OK);
+    status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
+    EXPECT_EQ(descriptor->GetTypeId(), currType2);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByFilenameExtension001
+* @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 begin.");
+    std::string filenameExtension = ".azw3";
+    std::string blongsToType = "general.ebook";
+    std::vector<std::string> currTypes;
+    auto status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "com.amazon.azw3");
+
+    status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "com.amazon.azw3");
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByFilenameExtension002
+* @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 begin.");
+    std::string filenameExtension = ".ts";
+    std::vector<std::string> currTypes;
+    auto status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 2);
+    auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.type-script") != currTypes.end();
+    auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.ts") != currTypes.end();
+    ASSERT_EQ(find1, true);
+    ASSERT_EQ(find2, true);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByFilenameExtension003
+* @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 begin.");
+    std::string filenameExtension = ".ts";
+    std::vector<std::string> currTypes;
+    std::string blongsToType = "general.text";
+    auto status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "general.type-script");
+    
+    blongsToType = "general.video";
+    status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "general.ts");
+
+    blongsToType = "general.shell-script";
+    status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByFilenameExtension004
+* @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension with flexibleType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 begin.");
+    std::string filenameExtension = ".mytext";
+    std::string blongsToType = "general.plain-text";
+    std::vector<std::string> flexTypeIds;
+    auto status =
+        UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, flexTypeIds, blongsToType);
+    EXPECT_EQ(status, E_OK);
+    ASSERT_EQ(flexTypeIds.size(), 1);
+    std::string flexTypeId = flexTypeIds[0];
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004, flexTypeId = %{public}s.", flexTypeId.c_str());
+    std::shared_ptr<TypeDescriptor> descriptor;
+    status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
+    EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
+    EXPECT_EQ(descriptor->GetDescription().empty(), true);
+    EXPECT_EQ(descriptor->GetIconFile().empty(), true);
+    EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
+    EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
+    bool checkRet = false;
+    ASSERT_NE(descriptor, nullptr);
+    status = descriptor->IsHigherLevelType("general.object", checkRet);    //  cmp with gengral type.
+    EXPECT_EQ(status, E_OK);
+    EXPECT_EQ(checkRet, false);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByMIMEType001
+* @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 begin.");
+    std::string mimeType = "application/x-mobi8-ebook";
+    std::string blongsToType = "general.ebook";
+    std::vector<std::string> currTypes;
+    auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "com.amazon.azw3");
+
+    status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "com.amazon.azw3");
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByMIMEType002
+* @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 begin.");
+    std::string mimeType = "application/msword";
+    std::vector<std::string> currTypes;
+    std::string blongsToType = "general.composite-object";
+    auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 2);
+    auto find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
+    auto find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
+    ASSERT_EQ(find1, true);
+    ASSERT_EQ(find2, true);
+
+    status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 2);
+    find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
+    find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
+    ASSERT_EQ(find1, true);
+    ASSERT_EQ(find2, true);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByMIMEType003
+* @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 begin.");
+    std::string mimeType = "video/x-ms-asf";
+    std::vector<std::string> currTypes;
+    std::string blongsToType = "general.media";
+    auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 2);
+    auto find1 = std::find(currTypes.begin(), currTypes.end(),
+                           "com.microsoft.advanced-systems-format") != currTypes.end();
+    auto find2 = std::find(currTypes.begin(), currTypes.end(),
+                           "com.microsoft.advanced-stream-redirector") != currTypes.end();
+    ASSERT_EQ(find1, true);
+    ASSERT_EQ(find2, true);
+
+    blongsToType = "general.video";
+    status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0], "com.microsoft.advanced-stream-redirector");
+
+    blongsToType = "general.text";
+    status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 1);
+    ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByMIMETypeByPrefix001
+* @tc.desc: normal testcase of GetUniformDatasTypeByMIMEType by prefix.
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMETypeByPrefix001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 begin.");
+    std::string mimeType = "model/*";
+    std::vector<std::string> currTypes;
+    auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
+    ASSERT_EQ(status, E_OK);
+    ASSERT_EQ(currTypes.size(), 3);
+    auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.iges") != currTypes.end();
+    auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.mesh-model") != currTypes.end();
+    auto find3 = std::find(currTypes.begin(), currTypes.end(), "com.autodesk.dwf") != currTypes.end();
+    ASSERT_EQ(find1, true);
+    ASSERT_EQ(find2, true);
+    ASSERT_EQ(find3, true);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 end.");
+}
+
+/**
+* @tc.name: IsValidMimeType001,
+* @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "?"
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsValidMimeType001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsValidMimeType001 begin.");
+    const std::string mimeType = "mimeType?";
+    UtdClient utdClient;
+    bool ret = utdClient.IsValidMimeType(mimeType);
+    EXPECT_EQ(ret, false);
+    LOG_INFO(UDMF_TEST, "IsValidMimeType001 end.");
+}
+
+/**
+* @tc.name: IsValidMimeType002
+* @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains ":"
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsValidMimeType002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsValidMimeType002 begin.");
+    const std::string mimeType = "mimeType:";
+    UtdClient utdClient;
+    bool ret = utdClient.IsValidMimeType(mimeType);
+    EXPECT_EQ(ret, false);
+    LOG_INFO(UDMF_TEST, "IsValidMimeType002 end.");
+}
+
+/**
+* @tc.name: IsValidMimeType003
+* @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "="
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsValidMimeType003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsValidMimeType003 begin.");
+    const std::string mimeType = "mimeType=";
+    UtdClient utdClient;
+    bool ret = utdClient.IsValidMimeType(mimeType);
+    EXPECT_EQ(ret, false);
+    LOG_INFO(UDMF_TEST, "IsValidMimeType003 end.");
+}
+
+/**
+* @tc.name: IsValidMimeType004
+* @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "\\"
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsValidMimeType004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsValidMimeType004 begin.");
+    const std::string mimeType = "mimeType\\";
+    UtdClient utdClient;
+    bool ret = utdClient.IsValidMimeType(mimeType);
+    EXPECT_EQ(ret, false);
+    LOG_INFO(UDMF_TEST, "IsValidMimeType004 end.");
+}
+
+/**
+* @tc.name: GetFlexibleTypeDescriptor001
+* @tc.desc: Abnormal testcase of GetFlexibleTypeDescriptor, typeId is ""
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetFlexibleTypeDescriptor001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetFlexibleTypeDescriptor001 begin.");
+    const std::string typeId = "";
+    std::shared_ptr<TypeDescriptor> descriptor = nullptr;
+    UtdClient utdClient;
+    Status ret = utdClient.GetFlexibleTypeDescriptor(typeId, descriptor);
+    EXPECT_EQ(ret, Status::E_ERROR);
+    LOG_INFO(UDMF_TEST, "GetFlexibleTypeDescriptor001 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByFilenameExtension005
+* @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, typeId is not empty,
+* belongsTo is not DEFAULT_TYPE_ID and typeId, belongsTo is not a lower level type
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension005 begin.");
+    const std::string fileExtension = "fileExtension";
+    std::vector<std::string> typeIds = std::vector<std::string>();
+    const std::string belongsTo = "";
+    UtdClient utdClient;
+    Status ret = utdClient.GetUniformDataTypesByFilenameExtension(fileExtension, typeIds, belongsTo);
+    EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension005 end.");
+}
+
+/**
+* @tc.name: GetTypeIdFromCfg001
+* @tc.desc: Abnormal testcase of GetTypeIdFromCfg, mimeType is not empty, mimeType.back() is not '*'
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetTypeIdFromCfg001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg001 begin.");
+    const std::string mimeType = "mimeType";
+    UtdClient utdClient;
+    utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
+    std::string ret = utdClient.GetTypeIdFromCfg(mimeType);
+    EXPECT_EQ(ret, "");
+    LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg001 end.");
+}
+
+/**
+* @tc.name: GetUniformDataTypesByMIMEType004
+* @tc.desc: Abnormal testcase of GetUniformDataTypesByMIMEType, mimeType is not empty, mimeType.back() is not '*'
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType004, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType004 begin.");
+    const std::string mimeType = "mimeType";
+    std::vector<std::string> typeIds = std::vector<std::string>();
+    const std::string belongsTo = "";
+    UtdClient utdClient;
+    Status ret = utdClient.GetUniformDataTypesByMIMEType(mimeType, typeIds, belongsTo);
+    EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
+    LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType004 end.");
+}
+
+/**
+* @tc.name: IsUtd005
+* @tc.desc: Abnormal testcase of IsUtd, typeId is empty
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsUtd005, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsUtd005 begin.");
+    std::string typeId = "";
+    bool result = true;
+    UtdClient utdClient;
+    Status ret = utdClient.IsUtd(typeId, result);
+    EXPECT_EQ(result, false);
+    EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
+    LOG_INFO(UDMF_TEST, "IsUtd005 end.");
+}
+
+/**
+* @tc.name: IsHapTokenType001
+* @tc.desc: Normal testcase of IsHapTokenType
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, IsHapTokenType001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "IsHapTokenType001 begin.");
+    HapInfoParams info = {
+        .userID = 100,
+        .bundleName = "ohos.test.demo",
+        .instIndex = 0,
+        .appIDDesc = "ohos.test.demo"
+    };
+
+    HapPolicyParams policy = {
+        .apl = APL_NORMAL,
+        .domain = "test.domain",
+        .permList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .bundleName = "ohos.test.demo",
+                .grantMode = 1,
+                .availableLevel = APL_NORMAL,
+                .label = "label",
+                .labelId = 1,
+                .description = "test",
+                .descriptionId = 1
+            }
+        },
+        .permStateList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .isGeneral = true,
+                .resDeviceID = {"local"},
+                .grantStatus = {PermissionState::PERMISSION_GRANTED},
+                .grantFlags = {1}
+            }
+        }
+    };
+    auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
+    SetSelfTokenID(tokenID.tokenIDEx);
+    UtdClient utdClient;
+    bool ret = utdClient.IsHapTokenType();
+    EXPECT_TRUE(ret);
+    LOG_INFO(UDMF_TEST, "IsHapTokenType001 end.");
+}
+
+/**
+* @tc.name: GetCustomUtdPath001
+* @tc.desc: Normal testcase of GetCustomUtdPath
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, GetCustomUtdPath001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "GetCustomUtdPath001 begin.");
+    HapInfoParams info = {
+        .userID = 100,
+        .bundleName = "ohos.test.demo",
+        .instIndex = 0,
+        .appIDDesc = "ohos.test.demo"
+    };
+
+    HapPolicyParams policy = {
+        .apl = APL_NORMAL,
+        .domain = "test.domain",
+        .permList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .bundleName = "ohos.test.demo",
+                .grantMode = 1,
+                .availableLevel = APL_NORMAL,
+                .label = "label",
+                .labelId = 1,
+                .description = "test",
+                .descriptionId = 1
+            }
+        },
+        .permStateList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .isGeneral = true,
+                .resDeviceID = {"local"},
+                .grantStatus = {PermissionState::PERMISSION_GRANTED},
+                .grantFlags = {1}
+            }
+        }
+    };
+    auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
+    SetSelfTokenID(tokenID.tokenIDEx);
+    UtdClient utdClient;
+    std::string ret = utdClient.GetCustomUtdPath();
+    EXPECT_EQ(ret, std::string(CUSTOM_UTD_HAP_DIR));
+    LOG_INFO(UDMF_TEST, "GetCustomUtdPath001 end.");
+}
+
+/**
+* @tc.name: SubscribeUtdChange001
+* @tc.desc: Normal testcase of SubscribeUtdChange
+* @tc.type: FUNC
+*/
+HWTEST_F(UtdClientTest, SubscribeUtdChange001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "SubscribeUtdChange001 begin.");
+    HapInfoParams info = {
+        .userID = 100,
+        .bundleName = "ohos.test.demo",
+        .instIndex = 0,
+        .appIDDesc = "ohos.test.demo"
+    };
+
+    HapPolicyParams policy = {
+        .apl = APL_NORMAL,
+        .domain = "test.domain",
+        .permList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .bundleName = "ohos.test.demo",
+                .grantMode = 1,
+                .availableLevel = APL_NORMAL,
+                .label = "label",
+                .labelId = 1,
+                .description = "test",
+                .descriptionId = 1
+            }
+        },
+        .permStateList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .isGeneral = true,
+                .resDeviceID = {"local"},
+                .grantStatus = {PermissionState::PERMISSION_GRANTED},
+                .grantFlags = {1}
+            }
+        }
+    };
+    auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
+    SetSelfTokenID(tokenID.tokenIDEx);
+    UtdClient utdClient;
+    utdClient.SubscribeUtdChange();
+    EXPECT_EQ(utdClient.subscriber_, nullptr);
+    LOG_INFO(UDMF_TEST, "SubscribeUtdChange001 end.");
+}
 } // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/innerkitsimpl/test/unittest/video_test.cpp b/udmf/framework/innerkitsimpl/test/unittest/video_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c4b4e996b7a2c2e3e60f540b8aaf10a396d0d5c
--- /dev/null
+++ b/udmf/framework/innerkitsimpl/test/unittest/video_test.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "VideoTest"
+
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "logger.h"
+#include "udmf_capi_common.h"
+#include "video.h"
+
+using namespace testing::ext;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+namespace OHOS::Test {
+using namespace std;
+
+class VideoTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void VideoTest::SetUpTestCase()
+{
+}
+
+void VideoTest::TearDownTestCase()
+{
+}
+
+void VideoTest::SetUp()
+{
+}
+
+void VideoTest::TearDown()
+{
+}
+
+/**
+* @tc.name: Video001
+* @tc.desc: Normal testcase of Video
+* @tc.type: FUNC
+*/
+HWTEST_F(VideoTest, Video001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "Video001 begin.");
+    UDType type = UDType::ENTITY;
+    ValueType value = 0;
+    Video video(type, value);
+    EXPECT_EQ(video.dataType_, VIDEO);
+    LOG_INFO(UDMF_TEST, "Video001 end.");
+}
+} // OHOS::Test
\ No newline at end of file
diff --git a/udmf/framework/jskitsimpl/common/napi_data_utils.cpp b/udmf/framework/jskitsimpl/common/napi_data_utils.cpp
index 129ddb6682475872e6102256cfe224e0149d696e..fdf87e133a733a1ecd197f31fb3bb08175dae9c8 100644
--- a/udmf/framework/jskitsimpl/common/napi_data_utils.cpp
+++ b/udmf/framework/jskitsimpl/common/napi_data_utils.cpp
@@ -15,8 +15,6 @@
 #define LOG_TAG "NapiDataUtils"
 #include "napi_data_utils.h"
 
-#include "napi_queue.h"
-
 namespace OHOS {
 namespace UDMF {
 constexpr int32_t STR_MAX_LENGTH = 4096;
@@ -417,6 +415,117 @@ napi_status NapiDataUtils::SetValue(napi_env env, const std::shared_ptr<OHOS::AA
     return napi_ok;
 }
 
+napi_status NapiDataUtils::GetValue(napi_env env, napi_value in, std::shared_ptr<Object> &object)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value -> std::GetValue Object");
+    napi_value attributeNames = nullptr;
+    NAPI_CALL_BASE(env, napi_get_property_names(env, in, &attributeNames), napi_invalid_arg);
+    uint32_t attributesNum = 0;
+    NAPI_CALL_BASE(env, napi_get_array_length(env, attributeNames, &attributesNum), napi_invalid_arg);
+    for (uint32_t i = 0; i < attributesNum; i++) {
+        napi_value attributeNameNapi = nullptr;
+        NAPI_CALL_BASE(env, napi_get_element(env, attributeNames, i, &attributeNameNapi), napi_invalid_arg);
+        size_t len = 0;
+        char str[STR_MAX_SIZE] = { 0 };
+        NAPI_CALL_BASE(env, napi_get_value_string_utf8(
+            env, attributeNameNapi, str, STR_MAX_SIZE, &len), napi_invalid_arg);
+        std::string attributeName = str;
+        napi_value attributeValueNapi = nullptr;
+        NAPI_CALL_BASE(env, napi_get_named_property(env, in, str, &attributeValueNapi), napi_invalid_arg);
+
+        bool isArrayBuffer = false;
+        NAPI_CALL_BASE(env, napi_is_arraybuffer(env, attributeValueNapi, &isArrayBuffer), napi_invalid_arg);
+        if (isArrayBuffer) {
+            void *data = nullptr;
+            size_t dataLen = 0;
+            NAPI_CALL_BASE(env, napi_get_arraybuffer_info(env, attributeValueNapi, &data, &dataLen), napi_invalid_arg);
+            object->value_[attributeName] = std::vector<uint8_t>(
+                reinterpret_cast<uint8_t *>(data), reinterpret_cast<uint8_t *>(data) + dataLen);
+            continue;
+        }
+        napi_valuetype valueType = napi_undefined;
+        NAPI_CALL_BASE(env, napi_typeof(env, attributeValueNapi, &valueType), napi_invalid_arg);
+        switch (valueType) {
+            case napi_valuetype::napi_object:
+                object->value_[attributeName] = std::make_shared<Object>();
+                break;
+            case napi_valuetype::napi_number:
+                object->value_[attributeName] = double();
+                break;
+            case napi_valuetype::napi_string:
+                object->value_[attributeName] = std::string();
+                break;
+            case napi_valuetype::napi_boolean:
+                object->value_[attributeName] = bool();
+                break;
+            case napi_valuetype::napi_undefined:
+                object->value_[attributeName] = std::monostate();
+                break;
+            case napi_valuetype::napi_null:
+                object->value_[attributeName] = nullptr;
+                break;
+            default:
+                return napi_invalid_arg;
+        }
+        napi_status status = napi_ok;
+        std::visit([&](auto &value) {status = NapiDataUtils::GetValue(env, attributeValueNapi, value);},
+            object->value_[attributeName]);
+        if (status != napi_ok) {
+            return status;
+        }
+    }
+    return napi_ok;
+}
+
+napi_status NapiDataUtils::SetValue(napi_env env, const std::shared_ptr<Object> &object, napi_value &out)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value -> std::GetValue Object");
+    napi_create_object(env, &out);
+    for (auto &[key, value] : object->value_) {
+        napi_value valueNapi = nullptr;
+        if (std::holds_alternative<std::vector<uint8_t>>(value)) {
+            auto array = std::get<std::vector<uint8_t>>(value);
+            void *data = nullptr;
+            size_t len = array.size();
+            NAPI_CALL_BASE(env, napi_create_arraybuffer(env, len, &data, &valueNapi), napi_generic_failure);
+            if (memcpy_s(data, len, reinterpret_cast<const void *>(array.data()), len) != 0) {
+                LOG_ERROR(UDMF_KITS_NAPI, "memcpy_s failed");
+                return napi_generic_failure;
+            }
+        } else {
+            std::visit([&](const auto &value) {NapiDataUtils::SetValue(env, value, valueNapi);}, value);
+        }
+        napi_set_named_property(env, out, key.c_str(), valueNapi);
+    }
+    return napi_ok;
+}
+
+napi_status NapiDataUtils::GetValue(napi_env env, napi_value in, std::monostate &out)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value -> std::monostate");
+    out = std::monostate{};
+    return napi_ok;
+}
+
+napi_status NapiDataUtils::SetValue(napi_env env, const std::monostate &in, napi_value &out)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value <- std::monostate");
+    return napi_get_undefined(env, &out);
+}
+
+napi_status NapiDataUtils::GetValue(napi_env env, napi_value in, nullptr_t &out)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value -> null");
+    out = nullptr;
+    return napi_ok;
+}
+
+napi_status NapiDataUtils::SetValue(napi_env env, const nullptr_t &in, napi_value &out)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "napi_value <- null");
+    return napi_get_null(env, &out);
+}
+
 bool NapiDataUtils::IsTypeForNapiValue(napi_env env, napi_value param, napi_valuetype expectType)
 {
     napi_valuetype valueType = napi_undefined;
@@ -451,17 +560,17 @@ napi_value NapiDataUtils::DefineClass(napi_env env, const std::string &name,
     const napi_property_descriptor *properties, size_t count, napi_callback newcb)
 {
     // base64("data.udmf") as rootPropName, i.e. global.<root>
-    const std::string rootPropName = "ZGF0YS51ZG1m";
+    constexpr const char *rootPropName = "ZGF0YS51ZG1m";
     napi_value root = nullptr;
     bool hasRoot = false;
     napi_value global = nullptr;
     napi_get_global(env, &global);
-    napi_has_named_property(env, global, rootPropName.c_str(), &hasRoot);
+    napi_has_named_property(env, global, rootPropName, &hasRoot);
     if (hasRoot) {
-        napi_get_named_property(env, global, rootPropName.c_str(), &root);
+        napi_get_named_property(env, global, rootPropName, &root);
     } else {
         napi_create_object(env, &root);
-        napi_set_named_property(env, global, rootPropName.c_str(), root);
+        napi_set_named_property(env, global, rootPropName, root);
     }
 
     std::string propName = "constructor_of_" + name;
diff --git a/udmf/framework/jskitsimpl/common/napi_error_utils.cpp b/udmf/framework/jskitsimpl/common/napi_error_utils.cpp
index bec7603ee95eefb1d42223957d3631918133a0c2..d0a999484b78bf1368ce6c7244cedffb6773f387 100644
--- a/udmf/framework/jskitsimpl/common/napi_error_utils.cpp
+++ b/udmf/framework/jskitsimpl/common/napi_error_utils.cpp
@@ -21,12 +21,12 @@ namespace OHOS {
 namespace UDMF {
 using NapiErrorCode = OHOS::UDMF::NapiErrorCode;
 
-static const NapiErrorCode JS_ERROR_CODE_MSGS[] = {
+static constexpr NapiErrorCode JS_ERROR_CODE_MSGS[] = {
     { Status::E_NO_PERMISSION, 201, "Permission denied!" },
     { Status::E_INVALID_PARAMETERS, 401, "Parameter error." },
     { Status::E_SETTINGS_EXISTED, 20400001, "Settings already exist." },
     { Status::E_NO_SYSTEM_PERMISSION, 202,
-      "Permission denied, application which is not a system application uses system API." },
+        "Permission denied, application which is not a system application uses system API." },
 };
 
 const std::optional<NapiErrorCode> GetErrorCode(int32_t errorCode)
@@ -90,8 +90,8 @@ void ThrowNapiError(napi_env env, int32_t status, const std::string &errMessage,
     } else {
         jsCode = std::to_string(napiError.jsCode);
     }
-    LOG_INFO(UDMF_KITS_NAPI, "ThrowNapiError, status:%{public}d, jsCode: %{public}s, message: %{public}s",
-             status, jsCode.c_str(), errMessage.c_str());
+    LOG_INFO(UDMF_KITS_NAPI, "ThrowNapiError, status:%{public}d, jsCode: %{public}s, message: %{public}s", status,
+        jsCode.c_str(), errMessage.c_str());
     napi_throw_error(env, jsCode.c_str(), message.c_str());
 }
 } // namespace UDMF
diff --git a/udmf/framework/jskitsimpl/common/napi_queue.cpp b/udmf/framework/jskitsimpl/common/napi_queue.cpp
index de1cb55bee0b01e0a6ddf5a46fa99563edf3df1e..cad9556fc655ae8eebf774a0c5ebfe14646f6c85 100644
--- a/udmf/framework/jskitsimpl/common/napi_queue.cpp
+++ b/udmf/framework/jskitsimpl/common/napi_queue.cpp
@@ -15,8 +15,6 @@
 #define LOG_TAG "NapiQueue"
 #include "napi_queue.h"
 
-#include "logger.h"
-
 namespace OHOS {
 namespace UDMF {
 ContextBase::~ContextBase()
diff --git a/udmf/framework/jskitsimpl/data/application_defined_record_napi.cpp b/udmf/framework/jskitsimpl/data/application_defined_record_napi.cpp
index 78f2a64637035a8030dae4c07aab32816ef62671..e63b9146d9df1db483202851d989920a1b03fb49 100644
--- a/udmf/framework/jskitsimpl/data/application_defined_record_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/application_defined_record_napi.cpp
@@ -16,9 +16,6 @@
 #include "application_defined_record_napi.h"
 
 #include "application_defined_record.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/audio_napi.cpp b/udmf/framework/jskitsimpl/data/audio_napi.cpp
index fc1120311eeeabfe2979f96e5f68d8c7d265902c..a692aefefceabf9af02fda7387f36e7e204a774d 100644
--- a/udmf/framework/jskitsimpl/data/audio_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/audio_napi.cpp
@@ -17,9 +17,6 @@
 
 #include "audio.h"
 #include "file_napi.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/file_napi.cpp b/udmf/framework/jskitsimpl/data/file_napi.cpp
index 81b693e210ad4d1ea46a7ff18641191e5bb6257a..84b762a010dc22ac52ee0ef630f38058c3e71c62 100644
--- a/udmf/framework/jskitsimpl/data/file_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/file_napi.cpp
@@ -16,9 +16,6 @@
 #include "file_napi.h"
 
 #include "file.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/folder_napi.cpp b/udmf/framework/jskitsimpl/data/folder_napi.cpp
index cce3647e469d5b26e579ee9c48f0d4ddcaac308a..9ec6a6ff310c59bf28f3b4ca70a71791e1626526 100644
--- a/udmf/framework/jskitsimpl/data/folder_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/folder_napi.cpp
@@ -17,9 +17,6 @@
 
 #include "file_napi.h"
 #include "folder.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/html_napi.cpp b/udmf/framework/jskitsimpl/data/html_napi.cpp
index e040e490acc3e955fcc064a7b49478d4e7dcbd1f..5773093967ff88c0a9d7c15a9ad12d49b901b3f9 100644
--- a/udmf/framework/jskitsimpl/data/html_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/html_napi.cpp
@@ -16,9 +16,6 @@
 #include "html_napi.h"
 
 #include "html.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "text_napi.h"
 #include "unified_record_napi.h"
 
diff --git a/udmf/framework/jskitsimpl/data/image_napi.cpp b/udmf/framework/jskitsimpl/data/image_napi.cpp
index 38376c466068065053fc22046da1f7d53220d59b..8df4f80ea70fea10c204c9ae53b3a56c1d64417a 100644
--- a/udmf/framework/jskitsimpl/data/image_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/image_napi.cpp
@@ -17,9 +17,6 @@
 
 #include "file_napi.h"
 #include "image.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/link_napi.cpp b/udmf/framework/jskitsimpl/data/link_napi.cpp
index 1663c4340140a5b9b80c1d4655758b049c92e264..e27ff13392daf177757c3614a6388c23c22f178a 100644
--- a/udmf/framework/jskitsimpl/data/link_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/link_napi.cpp
@@ -16,9 +16,6 @@
 #include "link_napi.h"
 
 #include "link.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "text_napi.h"
 #include "unified_record_napi.h"
 
diff --git a/udmf/framework/jskitsimpl/data/plain_text_napi.cpp b/udmf/framework/jskitsimpl/data/plain_text_napi.cpp
index 22312481289db8b575c07ab45f7bb702486c7f20..73ba739e06ad929f61c7d7c5bf46905023f8247a 100644
--- a/udmf/framework/jskitsimpl/data/plain_text_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/plain_text_napi.cpp
@@ -15,9 +15,6 @@
 #define LOG_TAG "PlainTextNapi"
 #include "plain_text_napi.h"
 
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "plain_text.h"
 #include "text_napi.h"
 #include "unified_record_napi.h"
diff --git a/udmf/framework/jskitsimpl/data/summary_napi.cpp b/udmf/framework/jskitsimpl/data/summary_napi.cpp
index 6df5cedea8f2d847a47e6875d5f4b95f95c3d630..95d936a92210dc3e4ccc20129448d551a4a16b77 100644
--- a/udmf/framework/jskitsimpl/data/summary_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/summary_napi.cpp
@@ -16,8 +16,6 @@
 #include "summary_napi.h"
 
 #include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_types.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/system_defined_appitem_napi.cpp b/udmf/framework/jskitsimpl/data/system_defined_appitem_napi.cpp
index 813eebc0c753a0239859f9be737b58e1ff0eef31..2401a64cac39cc92f013ce508d0e3a968937b3f1 100644
--- a/udmf/framework/jskitsimpl/data/system_defined_appitem_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/system_defined_appitem_napi.cpp
@@ -15,9 +15,6 @@
 #define LOG_TAG "SystemDefinedAppItemNapi"
 #include "system_defined_appitem_napi.h"
 
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "system_defined_appitem.h"
 #include "system_defined_record_napi.h"
 #include "unified_record_napi.h"
diff --git a/udmf/framework/jskitsimpl/data/system_defined_form_napi.cpp b/udmf/framework/jskitsimpl/data/system_defined_form_napi.cpp
index 48343d3ea2157cd4ce899ca4e9316486c82bf829..41ae7bca17c988ea9a3ae88d8667b6209f42731a 100644
--- a/udmf/framework/jskitsimpl/data/system_defined_form_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/system_defined_form_napi.cpp
@@ -15,9 +15,6 @@
 #define LOG_TAG "SystemDefinedFormNapi"
 #include "system_defined_form_napi.h"
 
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "system_defined_form.h"
 #include "system_defined_record_napi.h"
 #include "unified_record_napi.h"
diff --git a/udmf/framework/jskitsimpl/data/system_defined_pixelmap_napi.cpp b/udmf/framework/jskitsimpl/data/system_defined_pixelmap_napi.cpp
index 33cd0a29922b89ed5f67dcb2a8825918558be156..20dba8471c93fc1418a2e0f54052001378577426 100644
--- a/udmf/framework/jskitsimpl/data/system_defined_pixelmap_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/system_defined_pixelmap_napi.cpp
@@ -16,9 +16,6 @@
 #include "system_defined_pixelmap_napi.h"
 
 #include "system_defined_pixelmap.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 #include "system_defined_record_napi.h"
 
diff --git a/udmf/framework/jskitsimpl/data/system_defined_record_napi.cpp b/udmf/framework/jskitsimpl/data/system_defined_record_napi.cpp
index 19b7a2a8e28c8e356583d464787c3f94157c119c..b27f9d78d67d242a9a2e5cdb8f3d79a80a89d7f7 100644
--- a/udmf/framework/jskitsimpl/data/system_defined_record_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/system_defined_record_napi.cpp
@@ -16,9 +16,6 @@
 #include "system_defined_record_napi.h"
 
 #include "system_defined_record.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/text_napi.cpp b/udmf/framework/jskitsimpl/data/text_napi.cpp
index 8c50fe1a1c8767c452c3a0be535998fff808949d..38efd69e695fe23f2a55fef302180a0bfee53cdf 100644
--- a/udmf/framework/jskitsimpl/data/text_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/text_napi.cpp
@@ -16,9 +16,6 @@
 #include "text_napi.h"
 
 #include "text.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 
 namespace OHOS {
diff --git a/udmf/framework/jskitsimpl/data/type_descriptor_napi.cpp b/udmf/framework/jskitsimpl/data/type_descriptor_napi.cpp
index 044b0e2501860b012371da26f68d45bd8cb0513b..aed28997bbfe4e6bc28076a044db6197ae1fd4d8 100644
--- a/udmf/framework/jskitsimpl/data/type_descriptor_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/type_descriptor_napi.cpp
@@ -14,9 +14,7 @@
  */
 #define LOG_TAG "TypeDescriptorNapi"
 #include "type_descriptor_napi.h"
-#include "utd_client.h"
 #include "napi_data_utils.h"
-#include "napi_error_utils.h"
 
 namespace OHOS {
 namespace UDMF {
diff --git a/udmf/framework/jskitsimpl/data/unified_data_channel_napi.cpp b/udmf/framework/jskitsimpl/data/unified_data_channel_napi.cpp
index 3d91f11c621c0eef7b5fbf60858f878f03c41232..65c21490b3b3f9650a0922b9319a77eaefbfe92d 100644
--- a/udmf/framework/jskitsimpl/data/unified_data_channel_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/unified_data_channel_napi.cpp
@@ -16,11 +16,8 @@
 #include "unified_data_channel_napi.h"
 
 #include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "udmf_client.h"
 #include "unified_data_napi.h"
-#include "unified_meta.h"
 
 namespace OHOS {
 namespace UDMF {
diff --git a/udmf/framework/jskitsimpl/data/unified_data_napi.cpp b/udmf/framework/jskitsimpl/data/unified_data_napi.cpp
index de6e5d7ef1944a46a9b0bb4bf5280b7b78370d2a..72da7cb974f5f00ce8c9f4d0013149786b1aa743 100644
--- a/udmf/framework/jskitsimpl/data/unified_data_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/unified_data_napi.cpp
@@ -22,8 +22,6 @@
 #include "html_napi.h"
 #include "image_napi.h"
 #include "link_napi.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
 #include "plain_text_napi.h"
 #include "system_defined_appitem_napi.h"
 #include "system_defined_form_napi.h"
diff --git a/udmf/framework/jskitsimpl/data/unified_data_properties_napi.cpp b/udmf/framework/jskitsimpl/data/unified_data_properties_napi.cpp
index 812962173acd4e897162733258403194b27eea23..995309f5aa135989a688a86881ba62055117ec3e 100644
--- a/udmf/framework/jskitsimpl/data/unified_data_properties_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/unified_data_properties_napi.cpp
@@ -16,9 +16,7 @@
 #include "unified_data_properties_napi.h"
 
 #include "napi_data_utils.h"
-#include "napi_error_utils.h"
 #include "unified_data.h"
-#include "unified_meta.h"
 
 namespace OHOS {
 namespace UDMF {
diff --git a/udmf/framework/jskitsimpl/data/unified_record_napi.cpp b/udmf/framework/jskitsimpl/data/unified_record_napi.cpp
index 4d1aa123c26524376137582cfa92957ed63084e9..67a83a5e1d2c5a65977209d36fdaa475c24e037b 100644
--- a/udmf/framework/jskitsimpl/data/unified_record_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/unified_record_napi.cpp
@@ -15,10 +15,6 @@
 #define LOG_TAG "UnifiedRecordNapi"
 #include "unified_record_napi.h"
 
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
-
 #include "plain_text.h"
 #include "html.h"
 #include "link.h"
@@ -140,20 +136,23 @@ void UnifiedRecordNapi::GetNativeValue(napi_env env, std::string type, napi_valu
     ASSERT_ERR_VOID(env, status == napi_ok,
         Status::E_INVALID_PARAMETERS, "Parameter error: parameter value type must be ValueType");
     if (valueType == napi_object) {
-        ASSERT_ERR_VOID(env, type == "openharmony.pixel-map" || type == "openharmony.want",
-            Status::E_INVALID_PARAMETERS,
-            "Parameter error: when type of value is object, parameter type must be pixel-map or want UTD type");
         if (type == "openharmony.pixel-map") {
-            std::shared_ptr<OHOS::Media::PixelMap> data;
-            value = data;
+            value = std::shared_ptr<OHOS::Media::PixelMap>(nullptr);
+        } else if (type == "openharmony.want") {
+            value = std::shared_ptr<OHOS::AAFwk::Want>(nullptr);
         } else {
-            std::shared_ptr<OHOS::AAFwk::Want> data;
-            value = data;
+            value = std::make_shared<Object>();
         }
     } else if (valueType == napi_string) {
         value = std::string();
     } else if (valueType == napi_number) {
         value = double();
+    } else if (valueType == napi_boolean) {
+        value = bool();
+    } else if (valueType == napi_undefined) {
+        value = std::monostate();
+    } else if (valueType == napi_null) {
+        value = nullptr;
     }
     std::visit([&](auto &value) { status = NapiDataUtils::GetValue(env, valueNapi, value); }, value);
     ASSERT_ERR_VOID(env, status == napi_ok, Status::E_ERROR, "get unifiedRecord failed");
diff --git a/udmf/framework/jskitsimpl/data/uniform_type_descriptor_napi.cpp b/udmf/framework/jskitsimpl/data/uniform_type_descriptor_napi.cpp
index ea934002d87f969aa591bc35af5f2dc028a82cf9..3fba456bbf028c5af1bd0daac3f22cfba6d9ab13 100644
--- a/udmf/framework/jskitsimpl/data/uniform_type_descriptor_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/uniform_type_descriptor_napi.cpp
@@ -15,11 +15,6 @@
 #define LOG_TAG "UniformTypeDescriptorNapi"
 #include "uniform_type_descriptor_napi.h"
 #include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
-#include "unified_meta.h"
-#include "type_descriptor_napi.h"
-#include "type_descriptor.h"
 #include "utd_client.h"
 
 namespace OHOS {
@@ -34,6 +29,8 @@ napi_value UniformTypeDescriptorNapi::UniformTypeDescriptorInit(napi_env env, na
         DECLARE_NAPI_FUNCTION("getTypeDescriptor", GetTypeDescriptor),
         DECLARE_NAPI_FUNCTION("getUniformDataTypeByFilenameExtension", GetUniformDataTypeByFilenameExtension),
         DECLARE_NAPI_FUNCTION("getUniformDataTypeByMIMEType", GetUniformDataTypeByMIMEType),
+        DECLARE_NAPI_FUNCTION("getUniformDataTypesByFilenameExtension", GetMultiUniformDataTypesByFilenameExtension),
+        DECLARE_NAPI_FUNCTION("getUniformDataTypesByMIMEType", GetMultiUniformDataTypesByMIMEType),
     };
 
     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
@@ -165,5 +162,77 @@ napi_value UniformTypeDescriptorNapi::GetUniformDataTypeByMIMEType(napi_env env,
 
     return ctxt->output;
 }
+
+napi_value UniformTypeDescriptorNapi::GetMultiUniformDataTypesByFilenameExtension(napi_env env, napi_callback_info info)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "GetMultiUniformDataTypesByFilenameExtension is called!");
+    std::string filenameExtension;
+    std::string belongsTo;
+    auto ctxt = std::make_shared<ContextBase>();
+    auto input = [env, ctxt, &filenameExtension, &belongsTo](size_t argc, napi_value* argv) {
+        LOG_DEBUG(UDMF_KITS_NAPI, "get utd types by fileExtention, argc = %{public}zu !", argc);
+        // required 1 arguments : typeId
+        ASSERT_BUSINESS_ERR(ctxt, argc >= 1,
+            Status::E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
+        ctxt->status = NapiDataUtils::GetValue(env, argv[0], filenameExtension);
+        ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
+            "Parameter error: parameter filenameExtension type must be string");
+        if (argc > 1) {
+            ctxt->status = NapiDataUtils::GetValue(env, argv[1], belongsTo);
+            ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok && !belongsTo.empty(), E_INVALID_PARAMETERS,
+                "Parameter error: parameter belongsTo type must be string");
+        } else {
+            belongsTo = DEFAULT_TYPE_ID;
+        }
+    };
+    ctxt->GetCbInfoSync(env, info, input);
+    ASSERT_NULL(!ctxt->isThrowError, "GetMultiUniformDataTypesByFilenameExtension Exit");
+    std::vector<std::string> typeIds;
+    auto status = E_OK;
+    status = UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, typeIds, belongsTo);
+    ASSERT_ERR(ctxt->env, status == E_OK, status, "invalid arguments!");
+    if (!typeIds.empty()) {
+        NapiDataUtils::SetValue(env, typeIds, ctxt->output);
+    } else {
+        napi_get_null(env, &ctxt->output);
+    }
+    return ctxt->output;
+}
+
+napi_value UniformTypeDescriptorNapi::GetMultiUniformDataTypesByMIMEType(napi_env env, napi_callback_info info)
+{
+    LOG_DEBUG(UDMF_KITS_NAPI, "GetMultiUniformDataTypesByMIMEType is called!");
+    std::string mimeType;
+    std::string belongsTo;
+    auto ctxt = std::make_shared<ContextBase>();
+    auto input = [env, ctxt, &mimeType, &belongsTo](size_t argc, napi_value* argv) {
+        LOG_DEBUG(UDMF_KITS_NAPI, "get utd types by MIMEType, argc = %{public}zu !", argc);
+        // required 1 arguments : typeId
+        ASSERT_BUSINESS_ERR(ctxt, argc >= 1,
+            Status::E_INVALID_PARAMETERS, "Parameter error: Mandatory parameters are left unspecified");
+        ctxt->status = NapiDataUtils::GetValue(env, argv[0], mimeType);
+        ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok, E_INVALID_PARAMETERS,
+            "Parameter error: parameter mimeType type must be string");
+        if (argc > 1) {
+            ctxt->status = NapiDataUtils::GetValue(env, argv[1], belongsTo);
+            ASSERT_BUSINESS_ERR(ctxt, ctxt->status == napi_ok && !belongsTo.empty(), E_INVALID_PARAMETERS,
+                "Parameter error: parameter belongsTo type must be string");
+        } else {
+            belongsTo = DEFAULT_TYPE_ID;
+        }
+    };
+    ctxt->GetCbInfoSync(env, info, input);
+    ASSERT_NULL(!ctxt->isThrowError, "GetMultiUniformDataTypesByMIMEType Exit");
+    std::vector<std::string> typeIds;
+    auto status = E_OK;
+    status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, typeIds, belongsTo);
+    ASSERT_ERR(ctxt->env, status == E_OK, status, "invalid arguments!");
+    if (!typeIds.empty()) {
+        NapiDataUtils::SetValue(env, typeIds, ctxt->output);
+    } else {
+        napi_get_null(env, &ctxt->output);
+    }
+    return ctxt->output;
+}
 } // namespace UDMF
 } // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/jskitsimpl/data/video_napi.cpp b/udmf/framework/jskitsimpl/data/video_napi.cpp
index c91f048fd6a237c55ef990ac1624cd1612085b03..2dbe64a6d947f6d75a41cbf1edb27231f25d937a 100644
--- a/udmf/framework/jskitsimpl/data/video_napi.cpp
+++ b/udmf/framework/jskitsimpl/data/video_napi.cpp
@@ -16,9 +16,6 @@
 #include "video_napi.h"
 
 #include "file_napi.h"
-#include "napi_data_utils.h"
-#include "napi_error_utils.h"
-#include "napi_queue.h"
 #include "unified_record_napi.h"
 #include "video.h"
 
diff --git a/udmf/framework/jskitsimpl/unittest/UdmfJsTest.js b/udmf/framework/jskitsimpl/unittest/UdmfJsTest.js
index 2047bb1b37f84e6378614c37d2f5c64e4050d839..9999cf81b384b48c86de3fdd0a973416a375fa35 100644
--- a/udmf/framework/jskitsimpl/unittest/UdmfJsTest.js
+++ b/udmf/framework/jskitsimpl/unittest/UdmfJsTest.js
@@ -1306,4 +1306,389 @@ describe('UdmfJSTest', function () {
     const data4 = records[3].getValue();
     expect(data4).assertEqual(8899.7788);
   });
+
+  /**
+   * @tc.name UDSTest001
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('UDSTest001', 0, async function () {
+    const TAG = 'UDSTest001';
+    console.info(TAG, 'start');
+
+    let plainTextDetails = {
+      'key1': 'value1',
+      'key2': 'value2',
+    };
+    let plainText = {
+      uniformDataType: UTD.UniformDataType.PLAIN_TEXT,
+      textContent: 'This is plainText textContent example',
+      abstract: 'this is abstract',
+      details: plainTextDetails
+    };
+    let record1 = new UDC.UnifiedRecord(UTD.UniformDataType.PLAIN_TEXT, plainText);
+    let unifiedData = new UDC.UnifiedData(record1);
+    let records = unifiedData.getRecords();
+    expect(records.length).assertEqual(1);
+    const value1 = records[0].getValue();
+
+    expect(value1.uniformDataType).assertEqual(plainText.uniformDataType);
+    expect(value1.textContent).assertEqual(plainText.textContent);
+    expect(value1.abstract).assertEqual(plainText.abstract);
+    expect(value1.details.key1).assertEqual(plainText.details.key1);
+    expect(value1.details.key2).assertEqual(plainText.details.key2);
+  });
+
+  /**
+   * @tc.name UDSTest002
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('UDSTest002', 0, async function (done) {
+    const TAG = 'UDSTest002';
+    console.info(TAG, 'start');
+
+    let plainTextDetails = {
+      'key1': 'value1',
+      'key2': 'value2',
+    };
+    let plainText = {
+      uniformDataType: UTD.UniformDataType.PLAIN_TEXT,
+      textContent: 'This is plainText textContent example',
+      abstract: 'this is abstract',
+      details: plainTextDetails
+    };
+    let record1 = new UDC.UnifiedRecord(UTD.UniformDataType.PLAIN_TEXT, plainText);
+    let unifiedData = new UDC.UnifiedData(record1);
+    
+    try {
+      UDC.insertData(optionsValid, unifiedData).then((data) => {
+        console.info(TAG, `insert success. The key: ${data}`);
+        let options = { key: data };
+        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
+        UDC.queryData(options).then((data) => {
+          console.info(TAG, 'query success.');
+          expect(data.length).assertEqual(1);
+          let records = data[0].getRecords();
+          expect(records.length).assertEqual(1);
+          let value = records[0].getValue();
+          expect(value.uniformDataType).assertEqual(plainText.uniformDataType);
+          expect(value.textContent).assertEqual(plainText.textContent);
+          expect(value.abstract).assertEqual(plainText.abstract);
+          expect(value.details.key1).assertEqual(plainText.details.key1);
+          expect(value.details.key2).assertEqual(plainText.details.key2);
+          UDC.deleteData(options).then((data) => {
+            console.info(TAG, 'delete success.');
+            expect(data.length).assertEqual(1);
+            done();
+          }).catch(() => {
+            console.error(TAG, 'Unreachable code!');
+            expect(null).assertFail();
+            done();
+          });
+        }).catch(() => {
+          console.error(TAG, 'Unreachable code!');
+          expect(null).assertFail();
+          done();
+        });
+      }).catch(() => {
+        console.error(TAG, 'Unreachable code!');
+        expect(null).assertFail();
+        done();
+      });
+    } catch (e) {
+      console.error(TAG, 'Unreachable code!');
+      expect(null).assertFail();
+      done();
+    }
+  });
+
+  /**
+   * @tc.name UDSTest003
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('UDSTest003', 0, async function (done) {
+    const TAG = 'UDSTest003';
+    console.info(TAG, 'start');
+
+    let hyperLinkDetails = {
+      'key1': 'value1',
+      'key2': 'value2',
+    };
+    let hyperLink = {
+      uniformDataType: UTD.UniformDataType.HYPERLINK,
+      url: 'www.xxx',
+      description: 'hyperlinkDescription',
+      details: hyperLinkDetails
+    };
+    let record1 = new UDC.UnifiedRecord(UTD.UniformDataType.HYPERLINK, hyperLink);
+    let unifiedData = new UDC.UnifiedData(record1);
+    
+    try {
+      UDC.insertData(optionsValid, unifiedData).then((data) => {
+        console.info(TAG, `insert success. The key: ${data}`);
+        let options = { key: data };
+        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
+        UDC.queryData(options).then((data) => {
+          console.info(TAG, 'query success.');
+          expect(data.length).assertEqual(1);
+          let records = data[0].getRecords();
+          expect(records.length).assertEqual(1);
+          let value = records[0].getValue();
+          expect(value.uniformDataType).assertEqual(hyperLink.uniformDataType);
+          expect(value.url).assertEqual(hyperLink.url);
+          expect(value.description).assertEqual(hyperLink.description);
+          expect(value.details.key1).assertEqual(hyperLink.details.key1);
+          expect(value.details.key2).assertEqual(hyperLink.details.key2);
+          UDC.deleteData(options).then((data) => {
+            console.info(TAG, 'delete success.');
+            expect(data.length).assertEqual(1);
+            done();
+          }).catch(() => {
+            console.error(TAG, 'Unreachable code!');
+            expect(null).assertFail();
+            done();
+          });
+        }).catch(() => {
+          console.error(TAG, 'Unreachable code!');
+          expect(null).assertFail();
+          done();
+        });
+      }).catch(() => {
+        console.error(TAG, 'Unreachable code!');
+        expect(null).assertFail();
+        done();
+      });
+    } catch (e) {
+      console.error(TAG, 'Unreachable code!');
+      expect(null).assertFail();
+      done();
+    }
+  });
+
+  /**
+   * @tc.name UDSTest004
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('UDSTest004', 0, async function (done) {
+    const TAG = 'UDSTest004';
+    console.info(TAG, 'start');
+
+    let htmlDetails = {
+      'key1': 'value1',
+      'key2': 'value2',
+    };
+    let html = {
+      uniformDataType: UTD.UniformDataType.HTML,
+      htmlContent: 'www.xxx',
+      plainContent: 'htmlDescription',
+      details: htmlDetails
+    };
+    let record1 = new UDC.UnifiedRecord(UTD.UniformDataType.HTML, html);
+    let unifiedData = new UDC.UnifiedData(record1);
+    
+    try {
+      UDC.insertData(optionsValid, unifiedData).then((data) => {
+        console.info(TAG, `insert success. The key: ${data}`);
+        let options = { key: data };
+        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
+        UDC.queryData(options).then((data) => {
+          console.info(TAG, 'query success.');
+          expect(data.length).assertEqual(1);
+          let records = data[0].getRecords();
+          expect(records.length).assertEqual(1);
+          let value = records[0].getValue();
+          expect(value.uniformDataType).assertEqual(html.uniformDataType);
+          expect(value.htmlContent).assertEqual(html.htmlContent);
+          expect(value.plainContent).assertEqual(html.plainContent);
+          expect(value.details.key1).assertEqual(html.details.key1);
+          expect(value.details.key2).assertEqual(html.details.key2);
+          UDC.deleteData(options).then((data) => {
+            console.info(TAG, 'delete success.');
+            expect(data.length).assertEqual(1);
+            done();
+          }).catch(() => {
+            console.error(TAG, 'Unreachable code!');
+            expect(null).assertFail();
+            done();
+          });
+        }).catch(() => {
+          console.error(TAG, 'Unreachable code!');
+          expect(null).assertFail();
+          done();
+        });
+      }).catch(() => {
+        console.error(TAG, 'Unreachable code!');
+        expect(null).assertFail();
+        done();
+      });
+    } catch (e) {
+      console.error(TAG, 'Unreachable code!');
+      expect(null).assertFail();
+      done();
+    }
+  });
+
+  /**
+   * @tc.name UDSTest005
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('UDSTest005', 0, async function (done) {
+    const TAG = 'UDSTest005';
+    console.info(TAG, 'start');
+
+    let systemDefinedDetails = {
+      'key1': 'value1',
+      'key2': 'value2',
+    };
+    let systemDefined = {
+      uniformDataType: 'openharmony.app-item',
+      appId: 'app-itemAppId',
+      appName: 'app-itemAppName',
+      appIconId: 'app-itemAppIconId',
+      appLabelId: 'app-itemAppLabelId',
+      bundleName: 'app-itemBundleName',
+      abilityName: 'app-itemAbilityName',
+      details: systemDefinedDetails
+    };
+    let record1 = new UDC.UnifiedRecord('openharmony.app-item', systemDefined);
+    let unifiedData = new UDC.UnifiedData(record1);
+    
+    try {
+      UDC.insertData(optionsValid, unifiedData).then((data) => {
+        console.info(TAG, `insert success. The key: ${data}`);
+        let options = { key: data };
+        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
+        UDC.queryData(options).then((data) => {
+          console.info(TAG, 'query success.');
+          expect(data.length).assertEqual(1);
+          let records = data[0].getRecords();
+          expect(records.length).assertEqual(1);
+          let value = records[0].getValue();
+          expect(value.uniformDataType).assertEqual(systemDefined.uniformDataType);
+          expect(value.appId).assertEqual(systemDefined.appId);
+          expect(value.appName).assertEqual(systemDefined.appName);
+          expect(value.appIconId).assertEqual(systemDefined.appIconId);
+          expect(value.appLabelId).assertEqual(systemDefined.appLabelId);
+          expect(value.bundleName).assertEqual(systemDefined.bundleName);
+          expect(value.abilityName).assertEqual(systemDefined.abilityName);
+          expect(value.details.key1).assertEqual(systemDefined.details.key1);
+          expect(value.details.key2).assertEqual(systemDefined.details.key2);
+          UDC.deleteData(options).then((data) => {
+            console.info(TAG, 'delete success.');
+            expect(data.length).assertEqual(1);
+            done();
+          }).catch(() => {
+            console.error(TAG, 'Unreachable code!');
+            expect(null).assertFail();
+            done();
+          });
+        }).catch(() => {
+          console.error(TAG, 'Unreachable code!');
+          expect(null).assertFail();
+          done();
+        });
+      }).catch(() => {
+        console.error(TAG, 'Unreachable code!');
+        expect(null).assertFail();
+        done();
+      });
+    } catch (e) {
+      console.error(TAG, 'Unreachable code!');
+      expect(null).assertFail();
+      done();
+    }
+  });
+
+  /**
+   * @tc.name ObjectTest001
+   * @tc.desc
+   * @tc.type: FUNC
+   * @tc.require:
+   */
+  it('ObjectTest001', 0, async function (done) {
+    const TAG = 'ObjectTest001';
+    console.info(TAG, 'start');
+
+    const data = new ArrayBuffer(256);
+    let view1 = new Uint32Array(data);
+    view1[0] = 123456;
+
+    let ObjectDetails1 = {
+      'key1': 'value001',
+      'key2': data,
+      'key3': undefined,
+      'key4': null,
+    };
+    let ObjectDetails2 = {
+      'key1': 'value100',
+      'key2': data,
+      'key3': undefined,
+      'key4': null,
+      details: ObjectDetails1
+    };
+    let systemDefined = {
+      labelId: 'LabelId',
+      details: ObjectDetails2
+    };
+    let record1 = new UDC.UnifiedRecord('self_defined_type', systemDefined);
+    let unifiedData = new UDC.UnifiedData(record1);
+
+    try {
+      UDC.insertData(optionsValid, unifiedData).then((data) => {
+        console.info(TAG, `insert success. The key: ${data}`);
+        let options = { key: data };
+        console.info(TAG, `query start. The options: ${JSON.stringify(options)}`);
+        UDC.queryData(options).then((data) => {
+          console.info(TAG, 'query success.');
+          expect(data.length).assertEqual(1);
+          let records = data[0].getRecords();
+          expect(records.length).assertEqual(1);
+          let value = records[0].getValue();
+          expect(value.labelId).assertEqual(systemDefined.labelId);
+          expect(value.details.key1).assertEqual(systemDefined.details.key1);
+          expect(value.details.key2.byteLength).assertEqual(systemDefined.details.key2.byteLength);
+          let view2 = new Uint32Array(value.details.key2);
+          expect(view2[0]).assertEqual(view1[0]);
+          expect(value.details.key3).assertEqual(systemDefined.details.key3);
+          expect(value.details.key4).assertEqual(systemDefined.details.key4);
+          expect(value.details.details.key1).assertEqual(systemDefined.details.details.key1);
+          expect(value.details.details.key2.byteLength).assertEqual(systemDefined.details.details.key2.byteLength);
+          let view3 = new Uint32Array(value.details.details.key2);
+          expect(view3[0]).assertEqual(view1[0]);
+          expect(value.details.details.key3).assertEqual(systemDefined.details.details.key3);
+          expect(value.details.details.key4).assertEqual(systemDefined.details.details.key4);
+          UDC.deleteData(options).then((data) => {
+            console.info(TAG, 'delete success.');
+            expect(data.length).assertEqual(1);
+            done();
+          }).catch(() => {
+            console.error(TAG, 'Unreachable code!');
+            expect(null).assertFail();
+            done();
+          });
+        }).catch(() => {
+          console.error(TAG, 'Unreachable code!');
+          expect(null).assertFail();
+          done();
+        });
+      }).catch(() => {
+        console.error(TAG, 'Unreachable code!');
+        expect(null).assertFail();
+        done();
+      });
+    } catch (e) {
+      console.error(TAG, 'Unreachable code!');
+      expect(null).assertFail();
+      done();
+    }
+  });
 });
\ No newline at end of file
diff --git a/udmf/framework/jskitsimpl/unittest/UdmfUtdJsTest.js b/udmf/framework/jskitsimpl/unittest/UdmfUtdJsTest.js
index 1c1e21b02dfaa60a4875c7c980b3cffb7b26a680..9862329c1b4e5b10f52132712689a1dc789f7cd3 100644
--- a/udmf/framework/jskitsimpl/unittest/UdmfUtdJsTest.js
+++ b/udmf/framework/jskitsimpl/unittest/UdmfUtdJsTest.js
@@ -339,7 +339,7 @@ describe('UdmfUtdJSTest', function () {
     const TAG = 'UdmfTestTypeDescriptor012:';
     console.info(TAG, 'start');
     let typeObj = UTD.getTypeDescriptor('general.type-script');
-    let ret = typeObj.belongsTo('general.plain-text');
+    let ret = typeObj.belongsTo('general.text');
     expect(ret === true).assertTrue();
     console.info(TAG, 'typeDescriptor, ret ' + typeObj);
     console.info(TAG, 'end');
@@ -355,7 +355,7 @@ describe('UdmfUtdJSTest', function () {
     const TAG = 'UdmfTestTypeDescriptor013:';
     console.info(TAG, 'start');
     let typeObj = UTD.getTypeDescriptor('general.type-script');
-    let ret = typeObj.isLowerLevelType('general.plain-text');
+    let ret = typeObj.isLowerLevelType('general.text');
     expect(ret === true).assertTrue();
     console.info(TAG, 'typeDescriptor, ret ' + ret);
     console.info(TAG, 'end');
@@ -370,7 +370,7 @@ describe('UdmfUtdJSTest', function () {
   it ('UdmfTestTypeDescriptor014', 0, function () {
     const TAG = 'UdmfTestTypeDescriptor014:';
     console.info(TAG, 'start');
-    let typeObj = UTD.getTypeDescriptor('general.plain-text');
+    let typeObj = UTD.getTypeDescriptor('general.text');
     let ret = typeObj.isHigherLevelType('general.type-script');
     expect(ret === true).assertTrue();
     console.info(TAG, 'typeDescriptor, ret ' + typeObj);
@@ -386,7 +386,7 @@ describe('UdmfUtdJSTest', function () {
   it ('UdmfTestTypeDescriptor015', 0, function () {
     const TAG = 'UdmfTestTypeDescriptor015:';
     console.info(TAG, 'start');
-    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', 'general.plain-text');
+    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', 'general.text');
     expect(typeId === 'general.type-script').assertTrue();
     console.info(TAG, 'typeDescriptor, ret ' + typeId);
     console.info(TAG, 'end');
@@ -787,4 +787,202 @@ describe('UdmfUtdJSTest', function () {
     }
     console.info(TAG, 'end');
   });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor036
+  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor036', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor036:';
+    console.info(TAG, 'start');
+    let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt');
+    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+    expect(typeIds.includes('general.plain-text')).assertTrue();
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor037
+  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor037', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor037:';
+    console.info(TAG, 'start');
+    let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'general.text');
+    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+    expect(typeIds.includes('general.plain-text')).assertTrue();
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor038
+  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid param
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor038', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor038:';
+    console.info(TAG, 'start');
+    try {
+      let flexTypeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'general.video');
+      console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + flexTypeIds);
+      let flexTypeObj = UTD.getTypeDescriptor(flexTypeIds[0]);
+      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + flexTypeObj);
+      console.info(TAG, 'UDMF,typeId:' + flexTypeObj.typeId);
+      console.info(TAG, 'belongingToTypes:' + flexTypeObj.belongingToTypes);
+      console.info(TAG, 'filenameExtension:' + flexTypeObj.filenameExtensions);
+      console.info(TAG, 'mimeTypes:' + flexTypeObj.mimeTypes);
+      expect(flexTypeObj.typeId).assertEqual(flexTypeIds[0]);
+      expect(flexTypeObj.belongingToTypes.length).assertEqual(1);
+      expect(flexTypeObj.filenameExtensions[0]).assertEqual('.txt');
+      expect(flexTypeObj.mimeTypes.length).assertEqual(0);
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor039
+  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid param
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor039', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor039:';
+    console.info(TAG, 'start');
+    try {
+      let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'invalid.invalid');
+      console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+      expect().assertFail();
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor040
+  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid para
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor040', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor040:';
+    console.info(TAG, 'start');
+    try {
+      let typeIds = UTD.getUniformDataTypesByFilenameExtension('.invalid', '');
+      console.error(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+      expect().assertFail();
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor041
+  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor041', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor041:';
+    console.info(TAG, 'start');
+    let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain');
+    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+    expect(typeIds.includes('general.plain-text')).assertTrue();
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor042
+  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor042', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor042:';
+    console.info(TAG, 'start');
+    let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'general.text');
+    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
+    expect(typeIds.includes('general.plain-text')).assertTrue();
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor043
+  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid param
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor043', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor043:';
+    console.info(TAG, 'start');
+    try {
+      let flexTypeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'general.video');
+      console.info(TAG, 'GetUniformDataTypesByMIMEType, ret ' + flexTypeIds);
+      let flexTypeObj = UTD.getTypeDescriptor(flexTypeIds[0]);
+      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + flexTypeObj);
+      console.info(TAG, 'UDMF,typeId:' + flexTypeObj.typeId);
+      console.info(TAG, 'belongingToTypes:' + flexTypeObj.belongingToTypes);
+      console.info(TAG, 'filenameExtension:' + flexTypeObj.filenameExtensions);
+      console.info(TAG, 'mimeTypes:' + flexTypeObj.mimeTypes);
+      expect(flexTypeObj.typeId).assertEqual(flexTypeIds[0]);
+      expect(flexTypeObj.belongingToTypes.length).assertEqual(1);
+      expect(flexTypeObj.filenameExtensions.length).assertEqual(0);
+      expect(flexTypeObj.mimeTypes.length).assertEqual(1);
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor044
+  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid param
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor044', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor044:';
+    console.info(TAG, 'start');
+    try {
+      let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'invalid.invalid');
+      console.info(TAG, 'GetUniformDataTypesByMIMEType, ret ' + typeIds);
+      expect().assertFail();
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
+
+  /*
+  * @tc.name UdmfTestTypeDescriptor045
+  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid para
+  * @tc.type: FUNC
+  * @tc.require: issueNumber
+  */
+  it('UdmfTestTypeDescriptor045', 0, function () {
+    const TAG = 'UdmfTestTypeDescriptor045:';
+    console.info(TAG, 'start');
+    try {
+      let typeIds = UTD.getUniformDataTypesByMIMEType('invalid/invalid', '');
+      console.error(TAG, 'GetUniformDataTypesByMIMEType, ret ' + typeIds);
+      expect().assertFail();
+    } catch (e) {
+      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
+      expect(e.code === ERROR_PARAMETER).assertTrue();
+    }
+    console.info(TAG, 'end');
+  });
 });
\ No newline at end of file
diff --git a/udmf/framework/ndkimpl/data/data_provider_impl.cpp b/udmf/framework/ndkimpl/data/data_provider_impl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1ff6ff501c87fef912d848ddaa8849c1f027b208
--- /dev/null
+++ b/udmf/framework/ndkimpl/data/data_provider_impl.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "DataProviderImpl"
+#include "data_provider_impl.h"
+#include "unified_meta.h"
+#include "udmf_capi_common.h"
+#include "logger.h"
+
+namespace OHOS {
+namespace UDMF {
+void DataProviderImpl::SetInnerProvider(OH_UdmfRecordProvider* provider)
+{
+    innerProvider_ = provider;
+}
+
+OH_UdmfRecordProvider* DataProviderImpl::GetInnerProvider()
+{
+    return innerProvider_;
+}
+
+ValueType DataProviderImpl::GetValueByType(const std::string &utdId)
+{
+    if (utdId.empty()) {
+        return std::monostate();
+    }
+    auto value = (innerProvider_->callback)(innerProvider_->context, utdId.c_str());
+    if (value == nullptr) {
+        LOG_ERROR(
+            UDMF_CAPI, "get empty data when execute custom callback function, utdId is %{public}s", utdId.c_str());
+        return std::monostate();
+    }
+    UdsObject* object = static_cast<UdsObject *>(value);
+    if (IsInvalidUdsObjectByType(object, static_cast<UDType>(UtdUtils::GetUtdEnumFromUtdId(utdId)))) {
+        LOG_ERROR(UDMF_CAPI, "data type mismatch");
+        return std::monostate();
+    }
+    std::shared_ptr<OHOS::UDMF::Object> obj = std::move(object->obj);
+    delete object;
+    return obj;
+}
+
+} // namespace UDMF
+} // namespace OHOS
\ No newline at end of file
diff --git a/udmf/framework/ndkimpl/data/udmf.cpp b/udmf/framework/ndkimpl/data/udmf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85c264ceb0aed266ba9887e8563f287abd6eb411
--- /dev/null
+++ b/udmf/framework/ndkimpl/data/udmf.cpp
@@ -0,0 +1,826 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "Udmf"
+#include "udmf.h"
+#include "udmf_err_code.h"
+#include "data_provider_impl.h"
+#include "udmf_client.h"
+#include "securec.h"
+#include "udmf_capi_common.h"
+#include "int_wrapper.h"
+#include "string_wrapper.h"
+#include "unified_meta.h"
+#include "udmf_meta.h"
+#include "logger.h"
+#include "plain_text.h"
+#include "link.h"
+#include "html.h"
+#include "system_defined_appitem.h"
+#include "application_defined_record.h"
+#include "system_defined_pixelmap.h"
+
+using namespace OHOS::UDMF;
+
+static constexpr uint64_t MAX_RECORDS_COUNT = 4 * 1024 * 1024;
+static constexpr uint64_t MAX_RECORDS_SIZE = 4 * 1024 * 1024;
+static constexpr uint64_t MAX_KEY_STRING_LEN = 1 * 1024 * 1024;
+
+static void DestroyStringArray(char**& bufArray, unsigned int& count)
+{
+    if (bufArray == nullptr) {
+        return;
+    }
+    for (unsigned int i = 0; i < count; i++) {
+        if (bufArray[i] != nullptr) {
+            delete[] bufArray[i];
+            bufArray[i] = nullptr;
+        }
+    }
+    delete[] bufArray;
+    bufArray = nullptr;
+    count = 0;
+}
+
+static void DestroyUnifiedRecordArray(OH_UdmfRecord**& records, unsigned int& count)
+{
+    if (records == nullptr) {
+        return;
+    }
+    for (unsigned int i = 0; i < count; i++) {
+        if (records[i] != nullptr) {
+            delete records[i];
+            records[i] = nullptr;
+        }
+    }
+    delete[] records;
+    records = nullptr;
+    count = 0;
+}
+
+static char** StrVectorToTypesArray(const std::vector<std::string>& strVector)
+{
+    unsigned int vectorSize = strVector.size();
+    if (vectorSize > MAX_RECORDS_COUNT) {
+        return nullptr;
+    }
+    char** typesArray = new (std::nothrow) char* [vectorSize] {nullptr};
+    for (unsigned int i = 0; i < vectorSize; ++i) {
+        unsigned int strLen = strVector[i].length() + 1;
+        if (strLen > MAX_KEY_STRING_LEN) {
+            LOG_INFO(UDMF_CAPI, "string exceeds maximum length, length is %{public}d", strLen);
+            DestroyStringArray(typesArray, vectorSize);
+            return nullptr;
+        }
+        typesArray[i] = new (std::nothrow) char[strLen];
+        if (typesArray[i] == nullptr ||
+            (strcpy_s(typesArray[i], strLen, strVector[i].c_str())) != EOK) {
+            LOG_ERROR(UDMF_CAPI, "string copy failed");
+            DestroyStringArray(typesArray, vectorSize);
+            return nullptr;
+        }
+    }
+    return typesArray;
+}
+
+static OH_UdmfRecord** CreateUnifiedDataRecordsArray(OH_UdmfData* unifiedData,
+                                                     std::vector<std::shared_ptr<UnifiedRecord>>& records)
+{
+    unsigned int size = static_cast<unsigned int>(records.size());
+    if (unifiedData == nullptr || size == 0 || size > MAX_RECORDS_COUNT) {
+        return nullptr;
+    }
+    OH_UdmfRecord** result = new (std::nothrow) OH_UdmfRecord* [size] { nullptr };
+    if (result == nullptr) {
+        return nullptr;
+    }
+    for (unsigned int i = 0; i < size; i++) {
+        result[i] = new (std::nothrow) OH_UdmfRecord;
+        if (result[i] == nullptr) {
+            DestroyUnifiedRecordArray(result, size);
+            return nullptr;
+        }
+        result[i]->record_ = records[i];
+    }
+    unifiedData->records = result;
+    unifiedData->recordsCount = size;
+    return unifiedData->records;
+}
+
+static bool IsUnifiedDataValid(OH_UdmfData* data)
+{
+    return data != nullptr && data->unifiedData_ != nullptr &&
+           data->cid == NdkStructId::UDMF_UNIFIED_DATA_STRUCT_ID;
+}
+
+static bool IsUnifiedRecordValid(OH_UdmfRecord* record)
+{
+    return record != nullptr && record->record_ != nullptr &&
+           record->cid == NdkStructId::UDMF_UNIFIED_RECORD_STRUCT_ID;
+}
+
+static bool IsUnifiedPropertiesValid(OH_UdmfProperty* properties)
+{
+    return properties != nullptr && properties->properties_ != nullptr &&
+           properties->cid == NdkStructId::UDMF_UNIFIED_DATA_PROPERTIES_ID;
+}
+
+OH_UdmfData* OH_UdmfData_Create()
+{
+    OH_UdmfData* data = new (std::nothrow) OH_UdmfData;
+    if (data == nullptr) {
+        return nullptr;
+    }
+    data->unifiedData_ = std::make_shared<UnifiedData>();
+    return data;
+}
+
+void OH_UdmfData_Destroy(OH_UdmfData* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    DestroyStringArray(data->typesArray, data->typesCount);
+    DestroyUnifiedRecordArray(data->records, data->recordsCount);
+    delete data;
+}
+
+int OH_UdmfData_AddRecord(OH_UdmfData* unifiedData, OH_UdmfRecord* record)
+{
+    if (!IsUnifiedDataValid(unifiedData) || !IsUnifiedRecordValid(record)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    unifiedData->unifiedData_->AddRecord(record->record_);
+    return UDMF_E_OK;
+}
+
+bool OH_UdmfData_HasType(OH_UdmfData* unifiedData, const char* type)
+{
+    return IsUnifiedDataValid(unifiedData) && type != nullptr && unifiedData->unifiedData_->HasTypeInEntries(type);
+}
+
+char** OH_UdmfData_GetTypes(OH_UdmfData* unifiedData, unsigned int* count)
+{
+    if (!IsUnifiedDataValid(unifiedData) || count == nullptr) {
+        return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(unifiedData->mutex);
+    if (unifiedData->typesArray != nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "return cache value");
+        *count = unifiedData->typesCount;
+        return unifiedData->typesArray;
+    }
+    std::vector<std::string> typeLabels = unifiedData->unifiedData_->GetEntriesTypes();
+    unifiedData->typesArray = StrVectorToTypesArray(typeLabels);
+    unifiedData->typesArray == nullptr ? unifiedData->typesCount = 0 : unifiedData->typesCount = typeLabels.size();
+    *count = unifiedData->typesCount;
+    return unifiedData->typesArray;
+}
+
+char** OH_UdmfRecord_GetTypes(OH_UdmfRecord* record, unsigned int* count)
+{
+    if (!IsUnifiedRecordValid(record) || count == nullptr) {
+        return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(record->mutex);
+    if (record->typesArray != nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "return cache value");
+        *count = record->typesCount;
+        return record->typesArray;
+    }
+    auto types = record->record_->GetUtdIds();
+    std::vector<std::string> typeLabels {types.begin(), types.end()};
+    record->typesArray = StrVectorToTypesArray(typeLabels);
+    record->typesArray == nullptr ? record->typesCount = 0 : record->typesCount = typeLabels.size();
+    *count = record->typesCount;
+    return record->typesArray;
+}
+
+OH_UdmfRecord** OH_UdmfData_GetRecords(OH_UdmfData* unifiedData, unsigned int* count)
+{
+    if (!IsUnifiedDataValid(unifiedData) || count == nullptr) {
+        return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(unifiedData->mutex);
+    if (unifiedData->records != nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "return cache value");
+        *count = unifiedData->recordsCount;
+        return unifiedData->records;
+    }
+    std::vector<std::shared_ptr<UnifiedRecord>> records = unifiedData->unifiedData_->GetRecords();
+    CreateUnifiedDataRecordsArray(unifiedData, records);
+    *count = unifiedData->recordsCount;
+    return unifiedData->records;
+}
+
+static int GetFirstPlainText(OH_UdmfRecord **records, unsigned int recordCount, OH_UdsPlainText* plainText)
+{
+    int ret = UDMF_ERR;
+    if (records == nullptr || recordCount == 0) {
+        return ret;
+    }
+    for (unsigned int i = 0; i < recordCount; i++) {
+        const char *type = OH_UdsPlainText_GetType(plainText);
+        if (type == nullptr || !records[i]->record_->HasType(type)) {
+            continue;
+        }
+        ret = OH_UdmfRecord_GetPlainText(records[i], plainText);
+        if (ret == UDMF_E_OK) {
+            return ret;
+        }
+    }
+    return ret;
+}
+
+static int GetFirstHtml(OH_UdmfRecord **records, unsigned int recordCount, OH_UdsHtml* html)
+{
+    int ret = UDMF_ERR;
+    if (records == nullptr || recordCount == 0) {
+        return ret;
+    }
+    for (unsigned int i = 0; i < recordCount; i++) {
+        const char *type = OH_UdsHtml_GetType(html);
+        if (type == nullptr || !records[i]->record_->HasType(type)) {
+            continue;
+        }
+        ret = OH_UdmfRecord_GetHtml(records[i], html);
+        if (ret == UDMF_E_OK) {
+            return ret;
+        }
+    }
+    return ret;
+}
+
+int OH_UdmfData_GetPrimaryPlainText(OH_UdmfData* data, OH_UdsPlainText* plainText)
+{
+    if (!IsUnifiedDataValid(data) || IsInvalidUdsObjectPtr(plainText, UDS_PLAIN_TEXT_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(data->mutex);
+    if (data->records == nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "no cache value");
+        std::vector<std::shared_ptr<UnifiedRecord>> records = data->unifiedData_->GetRecords();
+        CreateUnifiedDataRecordsArray(data, records);
+    }
+
+    return GetFirstPlainText(data->records, data->recordsCount, plainText);
+}
+
+int OH_UdmfData_GetPrimaryHtml(OH_UdmfData* data, OH_UdsHtml* html)
+{
+    if (!IsUnifiedDataValid(data) || IsInvalidUdsObjectPtr(html, UDS_HTML_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(data->mutex);
+    if (data->records == nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "no cache value");
+        std::vector<std::shared_ptr<UnifiedRecord>> records = data->unifiedData_->GetRecords();
+        CreateUnifiedDataRecordsArray(data, records);
+    }
+
+    return GetFirstHtml(data->records, data->recordsCount, html);
+}
+
+int OH_UdmfData_GetRecordCount(OH_UdmfData *data)
+{
+    if (!IsUnifiedDataValid(data)) {
+        return 0;
+    }
+    std::lock_guard<std::mutex> lock(data->mutex);
+    if (data->records == nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "no cache value");
+        std::vector<std::shared_ptr<UnifiedRecord>> records = data->unifiedData_->GetRecords();
+        CreateUnifiedDataRecordsArray(data, records);
+    }
+    return static_cast<int>(data->recordsCount);
+}
+
+OH_UdmfRecord* OH_UdmfData_GetRecord(OH_UdmfData* data, unsigned int index)
+{
+    if (!IsUnifiedDataValid(data) || index < 0) {
+        return nullptr;
+    }
+    std::lock_guard<std::mutex> lock(data->mutex);
+    if (data->records == nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "no cache value");
+        std::vector<std::shared_ptr<UnifiedRecord>> records = data->unifiedData_->GetRecords();
+        CreateUnifiedDataRecordsArray(data, records);
+    }
+    if (index >= data->recordsCount || data->records == nullptr) {
+        return nullptr;
+    }
+    return data->records[index];
+}
+
+bool OH_UdmfData_IsLocal(OH_UdmfData* data)
+{
+    if (!IsUnifiedDataValid(data) || data->unifiedData_->GetProperties() == nullptr) {
+        return true;
+    }
+    bool isRemote = data->unifiedData_->GetProperties()->isRemote;
+    return !isRemote;
+}
+
+int OH_Udmf_GetUnifiedData(const char* key, Udmf_Intention intention, OH_UdmfData* data)
+{
+    if (!IsUnifiedDataValid(data) || key == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    Intention queryOptIntent;
+    switch (intention) {
+        case UDMF_INTENTION_DRAG:
+            queryOptIntent = Intention::UD_INTENTION_DRAG;
+            break;
+        default:
+            return UDMF_E_INVALID_PARAM;
+    }
+    QueryOption query = {.key = std::string(key), .intention = queryOptIntent};
+    if (UdmfClient::GetInstance().GetData(query, *(data->unifiedData_)) != E_OK) {
+        LOG_ERROR(UDMF_CAPI, "get data error");
+        return UDMF_ERR;
+    }
+    return UDMF_E_OK;
+}
+
+int OH_Udmf_SetUnifiedData(Udmf_Intention intention, OH_UdmfData* unifiedData, char* key, unsigned int keyLen)
+{
+    if (!IsUnifiedDataValid(unifiedData) || key == nullptr || keyLen < UDMF_KEY_BUFFER_LEN) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    enum Intention customOptIntent;
+    switch (intention) {
+        case UDMF_INTENTION_DRAG:
+            customOptIntent = Intention::UD_INTENTION_DRAG;
+            break;
+        default:
+            return UDMF_E_INVALID_PARAM;
+    }
+    CustomOption option = {.intention = customOptIntent};
+    std::string keyStr;
+    if ((UdmfClient::GetInstance().SetData(option, *(unifiedData->unifiedData_), keyStr)) != E_OK) {
+        LOG_ERROR(UDMF_CAPI, "set data error");
+        return UDMF_ERR;
+    }
+    if (strcpy_s(key, keyLen, keyStr.c_str()) != EOK) {
+        LOG_INFO(UDMF_CAPI, "string copy failed");
+        return UDMF_ERR;
+    }
+    return UDMF_E_OK;
+}
+
+OH_UdmfRecord* OH_UdmfRecord_Create()
+{
+    OH_UdmfRecord* record = new (std::nothrow) OH_UdmfRecord;
+    if (record == nullptr) {
+        return nullptr;
+    }
+    record->record_ = std::make_shared<UnifiedRecord>();
+    return record;
+}
+
+void OH_UdmfRecord_Destroy(OH_UdmfRecord* record)
+{
+    if (record == nullptr) {
+        return;
+    }
+    if (record->recordData != nullptr) {
+        delete[] record->recordData;
+        record->recordData = nullptr;
+    }
+    delete record;
+}
+
+int OH_UdmfRecord_AddGeneralEntry(OH_UdmfRecord* record, const char* typeId,
+                                  const unsigned char* entry, unsigned int count)
+{
+    if (!IsUnifiedRecordValid(record) || typeId == nullptr || entry == nullptr || count == 0 ||
+        count > MAX_GENERAL_ENTRY_SIZE || strlen(typeId) > MAX_KEY_STRING_LEN) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::string utdId(typeId);
+    std::string prefix(APPLICATION_DEFINED_TYPE);
+    if (utdId.compare(0, prefix.length(), prefix) != 0) {
+        LOG_ERROR(UDMF_CAPI, "not appdefined type:%{public}s", utdId.c_str());
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::vector<uint8_t> recordValue(entry, entry + count);
+    if (record->record_->GetType() == UD_BUTT) {
+        record->record_ = std::make_shared<ApplicationDefinedRecord>(APPLICATION_DEFINED_RECORD, recordValue);
+        record->record_->SetUtdId(typeId);
+    } else {
+        record->record_->AddEntry(utdId, std::move(recordValue));
+    }
+    record->recordDataLen = count;
+    return UDMF_E_OK;
+}
+
+static int GetValueFromUdsArrayBuffer(OH_UdmfRecord *record, const char *typeId, ValueType value)
+{
+    OH_UdsArrayBuffer *buffer = OH_UdsArrayBuffer_Create();
+    buffer->obj = std::get<std::shared_ptr<Object>>(value);
+
+    int ret = OH_UdsArrayBuffer_GetData(buffer, &record->recordData, &record->recordDataLen);
+    if (ret != UDMF_E_OK) {
+        LOG_ERROR(UDMF_CAPI, "get data from buffer failed. ret: %{public}d", ret);
+        return ret;
+    }
+    record->lastType = const_cast<char*>(typeId);
+    return UDMF_E_OK;
+}
+
+static int GetValueFromUint8Array(OH_UdmfRecord *record, const char *typeId, ValueType value)
+{
+    auto recordValue = std::get_if<std::vector<uint8_t>>(&value);
+    if (recordValue == nullptr) {
+        return UDMF_ERR;
+    }
+    record->recordDataLen = recordValue->size();
+    if (record->recordDataLen > MAX_RECORDS_SIZE) {
+        LOG_INFO(UDMF_CAPI, "data size exceeds maximum size");
+        return UDMF_ERR;
+    }
+    record->recordData = new (std::nothrow) unsigned char[record->recordDataLen];
+    if (record->recordData == nullptr) {
+        return UDMF_ERR;
+    }
+    auto err = memcpy_s(record->recordData, record->recordDataLen, recordValue->data(), record->recordDataLen);
+    if (err != EOK) {
+        LOG_ERROR(UDMF_CAPI, "memcpy error! type:%{public}s", typeId);
+        return UDMF_ERR;
+    }
+    record->lastType = const_cast<char*>(typeId);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_GetGeneralEntry(OH_UdmfRecord* record, const char* typeId, unsigned char** entry, unsigned int* count)
+{
+    if (!IsUnifiedRecordValid(record) || typeId == nullptr || entry == nullptr || count == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+
+    std::lock_guard<std::mutex> lock(record->mutex);
+    if (!record->record_->HasType(typeId)) {
+        LOG_ERROR(UDMF_CAPI, "no type:%{public}s", typeId);
+        return UDMF_E_INVALID_PARAM;
+    }
+    if (record->lastType == typeId && record->recordData != nullptr) {
+        LOG_DEBUG(UDMF_CAPI, "return cache value");
+        *entry = record->recordData;
+        *count = record->recordDataLen;
+        return UDMF_E_OK;
+    }
+    if (record->recordData != nullptr) {
+        delete[] record->recordData;
+        record->recordData = nullptr;
+    }
+    auto value = record->record_->GetEntry(typeId);
+
+    int result = UDMF_ERR;
+    if (std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        result = GetValueFromUdsArrayBuffer(record, typeId, value);
+    } else if (std::holds_alternative<std::vector<uint8_t>>(value)) {
+        result = GetValueFromUint8Array(record, typeId, value);
+    } else {
+        LOG_ERROR(UDMF_CAPI, "Not contains right data type.");
+    }
+    if (result != UDMF_E_OK) {
+        LOG_ERROR(UDMF_CAPI, "Get value from valueType failed. typeId: %{public}s, result: %{public}d", typeId, result);
+        return result;
+    }
+    *count = record->recordDataLen;
+    *entry = record->recordData;
+    return UDMF_E_OK;
+}
+
+template<typename T>
+void AddUds(OH_UdmfRecord* record, UdsObject* udsObject, UDType type)
+{
+    if (record->record_->GetType() == UD_BUTT) {
+        record->record_ = std::make_shared<T>(type, udsObject->obj);
+    } else {
+        record->record_->AddEntry(UtdUtils::GetUtdIdFromUtdEnum(type), udsObject->obj);
+    }
+}
+
+int OH_UdmfRecord_AddPlainText(OH_UdmfRecord* record, OH_UdsPlainText* plainText)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(plainText, UDS_PLAIN_TEXT_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<PlainText>(record, plainText, PLAIN_TEXT);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddHyperlink(OH_UdmfRecord* record, OH_UdsHyperlink* hyperlink)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(hyperlink, UDS_HYPERLINK_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<Link>(record, hyperlink, HYPERLINK);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddHtml(OH_UdmfRecord* record, OH_UdsHtml* html)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(html, UDS_HTML_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<Html>(record, html, HTML);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddAppItem(OH_UdmfRecord* record, OH_UdsAppItem* appItem)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(appItem, UDS_APP_ITEM_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<SystemDefinedAppItem>(record, appItem, SYSTEM_DEFINED_APP_ITEM);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddFileUri(OH_UdmfRecord* record, OH_UdsFileUri* fileUri)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(fileUri, UDS_FILE_URI_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<UnifiedRecord>(record, fileUri, UDType::FILE_URI);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddPixelMap(OH_UdmfRecord* record, OH_UdsPixelMap* pixelMap)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(pixelMap, UDS_PIXEL_MAP_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    AddUds<SystemDefinedPixelMap>(record, pixelMap, UDType::SYSTEM_DEFINED_PIXEL_MAP);
+    return UDMF_E_OK;
+}
+
+int GetUds(OH_UdmfRecord* record, UdsObject* udsObject, UDType type)
+{
+    auto value = record->record_->GetEntry(UtdUtils::GetUtdIdFromUtdEnum(type));
+    if (!std::holds_alternative<std::shared_ptr<Object>>(value)) {
+        return UDMF_ERR;
+    }
+    udsObject->obj = std::get<std::shared_ptr<Object>>(value);
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_AddArrayBuffer(OH_UdmfRecord* record, const char* type, OH_UdsArrayBuffer* buffer)
+{
+    if (!IsUnifiedRecordValid(record) || type == nullptr || strlen(type) > MAX_KEY_STRING_LEN ||
+        IsInvalidUdsObjectPtr(buffer, UDS_ARRAY_BUFFER_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    unsigned char *entry;
+    unsigned int size;
+    int ret = OH_UdsArrayBuffer_GetData(buffer, &entry, &size);
+    if (ret != UDMF_E_OK) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    buffer->obj->value_[UNIFORM_DATA_TYPE] = type;
+    return OH_UdmfRecord_AddGeneralEntry(record, type, entry, size);
+}
+
+int OH_UdmfRecord_GetPlainText(OH_UdmfRecord* record, OH_UdsPlainText* plainText)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(plainText, UDS_PLAIN_TEXT_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, plainText, PLAIN_TEXT);
+}
+
+int OH_UdmfRecord_GetHyperlink(OH_UdmfRecord* record, OH_UdsHyperlink* hyperlink)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(hyperlink, UDS_HYPERLINK_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, hyperlink, HYPERLINK);
+}
+
+int OH_UdmfRecord_GetHtml(OH_UdmfRecord* record, OH_UdsHtml* html)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(html, UDS_HTML_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, html, HTML);
+}
+
+int OH_UdmfRecord_GetAppItem(OH_UdmfRecord* record, OH_UdsAppItem* appItem)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(appItem, UDS_APP_ITEM_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, appItem, SYSTEM_DEFINED_APP_ITEM);
+}
+
+int OH_UdmfRecord_GetFileUri(OH_UdmfRecord* record, OH_UdsFileUri* fileUri)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(fileUri, UDS_FILE_URI_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, fileUri, UDType::FILE_URI);
+}
+
+int OH_UdmfRecord_GetPixelMap(OH_UdmfRecord* record, OH_UdsPixelMap* pixelMap)
+{
+    if (!IsUnifiedRecordValid(record) || IsInvalidUdsObjectPtr(pixelMap, UDS_PIXEL_MAP_STRUCT_ID)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    return GetUds(record, pixelMap, UDType::SYSTEM_DEFINED_PIXEL_MAP);
+}
+
+int OH_UdmfRecord_GetArrayBuffer(OH_UdmfRecord* record, const char* type, OH_UdsArrayBuffer* buffer)
+{
+    unsigned int size = 0;
+    unsigned char *entry;
+    int ret = OH_UdmfRecord_GetGeneralEntry(record, type, &entry, &size);
+    if (ret != UDMF_E_OK) {
+        LOG_ERROR(UDMF_CAPI, "OH_UdmfRecord_GetGeneralEntry ret: %{public}d.", ret);
+        return ret;
+    }
+    return OH_UdsArrayBuffer_SetData(buffer, entry, size);
+}
+
+OH_UdmfProperty* OH_UdmfProperty_Create(OH_UdmfData* data)
+{
+    if (!IsUnifiedDataValid(data)) {
+        return nullptr;
+    }
+    OH_UdmfProperty* properties = new (std::nothrow) OH_UdmfProperty;
+    if (properties == nullptr) {
+        return nullptr;
+    }
+    properties->properties_ = data->unifiedData_->GetProperties();
+    return properties;
+}
+
+void OH_UdmfProperty_Destroy(OH_UdmfProperty* properties)
+{
+    if (properties != nullptr) {
+        delete properties;
+    }
+}
+
+const char* OH_UdmfProperty_GetTag(OH_UdmfProperty* properties)
+{
+    if (!IsUnifiedPropertiesValid(properties)) {
+        return nullptr;
+    }
+    return properties->properties_->tag.c_str();
+}
+
+int64_t OH_UdmfProperty_GetTimestamp(OH_UdmfProperty* properties)
+{
+    if (!IsUnifiedPropertiesValid(properties)) {
+        return -1;
+    }
+    return properties->properties_->timestamp;
+}
+
+Udmf_ShareOption OH_UdmfProperty_GetShareOption(OH_UdmfProperty* properties)
+{
+    if (!IsUnifiedPropertiesValid(properties)) {
+        return Udmf_ShareOption::SHARE_OPTIONS_INVALID;
+    }
+    switch (properties->properties_->shareOptions) {
+        case ShareOptions::IN_APP:
+            return Udmf_ShareOption::SHARE_OPTIONS_IN_APP;
+        case ShareOptions::CROSS_APP:
+            return Udmf_ShareOption::SHARE_OPTIONS_CROSS_APP;
+        default:
+            return Udmf_ShareOption::SHARE_OPTIONS_INVALID;
+    }
+}
+
+int OH_UdmfProperty_GetExtrasIntParam(OH_UdmfProperty* properties, const char* key, const int defaultValue)
+{
+    return (IsUnifiedPropertiesValid(properties) && key != nullptr) ?
+           properties->properties_->extras.GetIntParam(key, defaultValue) : defaultValue;
+}
+
+const char* OH_UdmfProperty_GetExtrasStringParam(OH_UdmfProperty* properties, const char* key)
+{
+    if (!IsUnifiedPropertiesValid(properties) || key == nullptr) {
+        return nullptr;
+    }
+    properties->extraStr = properties->properties_->extras.GetStringParam(key);
+    return properties->extraStr.c_str();
+}
+
+int OH_UdmfProperty_SetTag(OH_UdmfProperty* properties, const char* tag)
+{
+    if (!IsUnifiedPropertiesValid(properties) || tag == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    properties->properties_->tag = tag;
+    return UDMF_E_OK;
+}
+
+int OH_UdmfProperty_SetShareOption(OH_UdmfProperty* properties, Udmf_ShareOption option)
+{
+    if (!IsUnifiedPropertiesValid(properties)) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(properties->mutex);
+    switch (option) {
+        case Udmf_ShareOption::SHARE_OPTIONS_IN_APP:
+            properties->properties_->shareOptions = ShareOptions::IN_APP;
+            break;
+        case Udmf_ShareOption::SHARE_OPTIONS_CROSS_APP:
+            properties->properties_->shareOptions = ShareOptions::CROSS_APP;
+            break;
+        default:
+            return UDMF_E_INVALID_PARAM;
+    }
+    return UDMF_E_OK;
+}
+
+int OH_UdmfProperty_SetExtrasIntParam(OH_UdmfProperty* properties, const char* key, int param)
+{
+    if (!IsUnifiedPropertiesValid(properties) || key == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(properties->mutex);
+    properties->properties_->extras.SetParam(key, OHOS::AAFwk::Integer::Box(param));
+    return UDMF_E_OK;
+}
+
+int OH_UdmfProperty_SetExtrasStringParam(OH_UdmfProperty* properties, const char* key, const char* param)
+{
+    if (!IsUnifiedPropertiesValid(properties) || key == nullptr || param == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(properties->mutex);
+    properties->properties_->extras.SetParam(key, OHOS::AAFwk::String::Box(param));
+    return UDMF_E_OK;
+}
+
+OH_UdmfRecordProvider* OH_UdmfRecordProvider_Create()
+{
+    OH_UdmfRecordProvider* provider = new (std::nothrow) OH_UdmfRecordProvider();
+    if (provider == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "allocate OH_UdmfRecordProvider memory fail");
+    }
+    return provider;
+}
+
+int OH_UdmfRecordProvider_Destroy(OH_UdmfRecordProvider* provider)
+{
+    if (provider == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    if (provider->context != nullptr && provider->finalize != nullptr) {
+        (provider->finalize)(provider->context);
+        LOG_INFO(UDMF_CAPI, "free context finished");
+    }
+    delete provider;
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecordProvider_SetData(OH_UdmfRecordProvider* provider, void* context,
+    const OH_UdmfRecordProvider_GetData callback, const UdmfData_Finalize finalize)
+{
+    if (provider == nullptr || callback == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    provider->callback = callback;
+    if (context != nullptr && finalize == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "finalize function is null when context not null");
+        return UDMF_E_INVALID_PARAM;
+    }
+    provider->context = context;
+    provider->finalize = finalize;
+    return UDMF_E_OK;
+}
+
+int OH_UdmfRecord_SetProvider(OH_UdmfRecord* record, const char* const* types, unsigned int count,
+    OH_UdmfRecordProvider* provider)
+{
+    if (!IsUnifiedRecordValid(record) || types == nullptr || count == 0 || provider == nullptr) {
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::shared_ptr<DataProviderImpl> providerBox = std::make_shared<DataProviderImpl>();
+    providerBox->SetInnerProvider(provider);
+    std::set<std::string> udTypes;
+    for (unsigned int i = 0; i < count; ++i) {
+        if (types[i] == nullptr) {
+            LOG_ERROR(UDMF_CAPI, "The type with index %{public}d is empty", i);
+            continue;
+        }
+        udTypes.emplace(types[i]);
+    }
+    record->record_->SetEntryGetter(udTypes, providerBox);
+    return UDMF_E_OK;
+}
diff --git a/udmf/framework/ndkimpl/data/udmf_capi_common.h b/udmf/framework/ndkimpl/data/udmf_capi_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7ee65c75502614a663f6e8d116cda0502639506
--- /dev/null
+++ b/udmf/framework/ndkimpl/data/udmf_capi_common.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_CAPI_COMMON_H
+#define UDMF_CAPI_COMMON_H
+
+#include "unified_record.h"
+#include "unified_data.h"
+#include <mutex>
+#include <cstdint>
+
+# define MAX_GENERAL_ENTRY_SIZE (128 * 1024 * 1024)
+
+struct UdsObject {
+    const int64_t cid;
+    std::shared_ptr<OHOS::UDMF::Object> obj;
+    std::mutex mutex;
+    explicit UdsObject(int cid);
+    template<typename T> bool HasObjectKey(const char* paramName);
+    template<typename T> T* GetUdsValue(const char* paramName);
+    template<typename T> int SetUdsValue(const char* paramName, T pramValue);
+};
+
+enum NdkStructId : std::int64_t {
+    UTD_STRUCT_ID = 1002930,
+    UDS_PLAIN_TEXT_STRUCT_ID,
+    UDS_HYPERLINK_STRUCT_ID,
+    UDS_HTML_STRUCT_ID,
+    UDS_APP_ITEM_STRUCT_ID,
+    UDMF_UNIFIED_DATA_STRUCT_ID,
+    UDMF_UNIFIED_RECORD_STRUCT_ID,
+    UDMF_UNIFIED_DATA_PROPERTIES_ID,
+    UDS_FILE_URI_STRUCT_ID,
+    UDS_PIXEL_MAP_STRUCT_ID,
+    UDS_ARRAY_BUFFER_STRUCT_ID,
+};
+
+struct OH_Utd {
+    const int64_t cid = UTD_STRUCT_ID;
+    std::mutex mutex;
+    std::string typeId;
+    const char** belongingToTypes{nullptr};
+    unsigned int belongingToTypesCount{0};
+    const char** filenameExtensions{nullptr};
+    unsigned int filenameExtensionsCount{0};
+    const char** mimeTypes{nullptr};
+    unsigned int mimeTypeCount{0};
+    std::string description;
+    std::string referenceURL;
+    std::string iconFile;
+};
+
+struct OH_UdsPlainText : public UdsObject {
+    OH_UdsPlainText();
+};
+struct OH_UdsHyperlink : public UdsObject {
+    OH_UdsHyperlink();
+};
+struct OH_UdsHtml : public UdsObject {
+    OH_UdsHtml();
+};
+struct OH_UdsAppItem : public UdsObject {
+    OH_UdsAppItem();
+};
+struct OH_UdsFileUri : public UdsObject {
+    OH_UdsFileUri();
+};
+struct OH_UdsPixelMap : public UdsObject {
+    OH_UdsPixelMap();
+};
+struct OH_UdsArrayBuffer : public UdsObject {
+    OH_UdsArrayBuffer();
+};
+
+struct OH_UdmfRecord {
+    const int64_t cid = UDMF_UNIFIED_RECORD_STRUCT_ID;
+    std::shared_ptr<OHOS::UDMF::UnifiedRecord> record_;
+    unsigned char *recordData{nullptr};
+    unsigned int recordDataLen{0};
+    char **typesArray{nullptr};
+    unsigned int typesCount{0};
+    char *lastType{nullptr};
+    std::mutex mutex;
+};
+
+struct OH_UdmfData {
+    const int64_t cid = UDMF_UNIFIED_DATA_STRUCT_ID;
+    std::shared_ptr<OHOS::UDMF::UnifiedData> unifiedData_;
+    char **typesArray{nullptr};
+    unsigned int typesCount{0};
+    OH_UdmfRecord **records{nullptr};
+    unsigned int recordsCount{0};
+    std::mutex mutex;
+};
+
+struct OH_UdmfProperty {
+    const int64_t cid = UDMF_UNIFIED_DATA_PROPERTIES_ID;
+    std::shared_ptr<OHOS::UDMF::UnifiedDataProperties> properties_;
+    std::mutex mutex;
+    std::string extraStr;
+};
+
+bool IsInvalidUdsObjectPtr(const UdsObject* pThis, int cid);
+
+bool IsInvalidUdsObjectByType(const UdsObject* pThis, const OHOS::UDMF::UDType& type);
+
+#endif
diff --git a/udmf/framework/ndkimpl/data/uds.cpp b/udmf/framework/ndkimpl/data/uds.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cec6cd0d1da7480433e653f2300c920ccaa45f05
--- /dev/null
+++ b/udmf/framework/ndkimpl/data/uds.cpp
@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "Uds"
+
+#include "uds.h"
+#include "logger.h"
+#include "securec.h"
+#include "unified_meta.h"
+#include "udmf_capi_common.h"
+#include "udmf_meta.h"
+#include "udmf_err_code.h"
+#include "pixel_map.h"
+#include "pixelmap_native_impl.h"
+
+using namespace OHOS::UDMF;
+
+static const char* GetUdsStrValue(UdsObject* pThis, NdkStructId ndkStructId, const char* pramName)
+{
+    if (IsInvalidUdsObjectPtr(pThis, ndkStructId)) {
+        return nullptr;
+    }
+    auto value = pThis->GetUdsValue<std::string>(pramName);
+    return value == nullptr ? nullptr : value->c_str();
+}
+
+bool IsInvalidUdsObjectPtr(const UdsObject* pThis, int cid)
+{
+    return pThis == nullptr || pThis->cid != cid || pThis->obj == nullptr;
+}
+
+bool IsInvalidUdsObjectByType(const UdsObject* pThis, const UDType& type)
+{
+    switch (type) {
+        case PLAIN_TEXT:
+            return IsInvalidUdsObjectPtr(pThis, UDS_PLAIN_TEXT_STRUCT_ID);
+        case HYPERLINK:
+            return IsInvalidUdsObjectPtr(pThis, UDS_HYPERLINK_STRUCT_ID);
+        case HTML:
+            return IsInvalidUdsObjectPtr(pThis, UDS_HTML_STRUCT_ID);
+        case SYSTEM_DEFINED_APP_ITEM:
+            return IsInvalidUdsObjectPtr(pThis, UDS_APP_ITEM_STRUCT_ID);
+        case FILE_URI:
+            return IsInvalidUdsObjectPtr(pThis, UDS_FILE_URI_STRUCT_ID);
+        case SYSTEM_DEFINED_PIXEL_MAP:
+            return IsInvalidUdsObjectPtr(pThis, UDS_PIXEL_MAP_STRUCT_ID);
+        default:
+            return false;
+    }
+}
+
+UdsObject::UdsObject(const int cid) : cid(cid) {}
+
+OH_UdsPlainText::OH_UdsPlainText() : UdsObject(NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID) {}
+
+OH_UdsHyperlink::OH_UdsHyperlink() : UdsObject(NdkStructId::UDS_HYPERLINK_STRUCT_ID) {}
+
+OH_UdsHtml::OH_UdsHtml() : UdsObject(NdkStructId::UDS_HTML_STRUCT_ID) {}
+
+OH_UdsAppItem::OH_UdsAppItem() : UdsObject(NdkStructId::UDS_APP_ITEM_STRUCT_ID) {}
+
+OH_UdsFileUri::OH_UdsFileUri() : UdsObject(NdkStructId::UDS_FILE_URI_STRUCT_ID) {}
+
+OH_UdsPixelMap::OH_UdsPixelMap() : UdsObject(NdkStructId::UDS_PIXEL_MAP_STRUCT_ID) {}
+
+OH_UdsArrayBuffer::OH_UdsArrayBuffer() : UdsObject(NdkStructId::UDS_ARRAY_BUFFER_STRUCT_ID) {}
+
+template<typename T>
+bool UdsObject::HasObjectKey(const char* paramName)
+{
+    auto it = obj->value_.find(paramName);
+    if (it == obj->value_.end() || !std::holds_alternative<T>(it->second)) {
+        LOG_ERROR(UDMF_CAPI, "Don't have property %{public}s.", paramName);
+        return false;
+    }
+    return true;
+}
+
+template<typename T>
+T* UdsObject::GetUdsValue(const char* paramName)
+{
+    if (!HasObjectKey<T>(paramName)) {
+        return nullptr;
+    }
+    return std::get_if<T>(&(obj->value_[paramName]));
+}
+
+template<typename T>
+int UdsObject::SetUdsValue(const char* paramName, const T pramValue)
+{
+    if (!HasObjectKey<T>(paramName)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    std::lock_guard<std::mutex> lock(mutex);
+    obj->value_[paramName] = pramValue;
+    return Udmf_ErrCode::UDMF_E_OK;
+}
+
+OH_UdsPlainText* OH_UdsPlainText_Create()
+{
+    OH_UdsPlainText* plainText = new (std::nothrow) OH_UdsPlainText();
+    if (plainText == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    plainText->obj = std::make_shared<Object>();
+    plainText->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_PLAIN_TEXT;
+    plainText->obj->value_[CONTENT] = "";
+    plainText->obj->value_[ABSTRACT] = "";
+    return plainText;
+}
+
+void OH_UdsPlainText_Destroy(OH_UdsPlainText* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsPlainText_GetType(OH_UdsPlainText* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+const char* OH_UdsPlainText_GetContent(OH_UdsPlainText* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID, CONTENT);
+}
+
+const char* OH_UdsPlainText_GetAbstract(OH_UdsPlainText* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID, ABSTRACT);
+}
+
+int OH_UdsPlainText_SetContent(OH_UdsPlainText* pThis, const char* content)
+{
+    if (content == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(CONTENT, content);
+}
+
+int OH_UdsPlainText_SetAbstract(OH_UdsPlainText* pThis, const char* abstract)
+{
+    if (abstract == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_PLAIN_TEXT_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(ABSTRACT, abstract);
+}
+
+OH_UdsHyperlink* OH_UdsHyperlink_Create()
+{
+    OH_UdsHyperlink* hyperlink = new (std::nothrow) OH_UdsHyperlink();
+    if (hyperlink == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    hyperlink->obj = std::make_shared<Object>();
+    hyperlink->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_HYPERLINK;
+    hyperlink->obj->value_[URL] = "";
+    hyperlink->obj->value_[DESCRIPTION] = "";
+    return hyperlink;
+}
+
+void OH_UdsHyperlink_Destroy(OH_UdsHyperlink* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_HYPERLINK_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsHyperlink_GetType(OH_UdsHyperlink* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HYPERLINK_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+const char* OH_UdsHyperlink_GetUrl(OH_UdsHyperlink* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HYPERLINK_STRUCT_ID, URL);
+}
+
+const char* OH_UdsHyperlink_GetDescription(OH_UdsHyperlink* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HYPERLINK_STRUCT_ID, DESCRIPTION);
+}
+
+int OH_UdsHyperlink_SetUrl(OH_UdsHyperlink* pThis, const char* url)
+{
+    if (url == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_HYPERLINK_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(URL, url);
+}
+
+int OH_UdsHyperlink_SetDescription(OH_UdsHyperlink* pThis, const char* description)
+{
+    if (description == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_HYPERLINK_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(DESCRIPTION, description);
+}
+
+OH_UdsHtml* OH_UdsHtml_Create()
+{
+    OH_UdsHtml* html = new (std::nothrow) OH_UdsHtml();
+    if (html == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    html->obj = std::make_shared<Object>();
+    html->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_HTML;
+    html->obj->value_[HTML_CONTENT] = "";
+    html->obj->value_[PLAIN_CONTENT] = "";
+    return html;
+}
+
+void OH_UdsHtml_Destroy(OH_UdsHtml* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_HTML_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsHtml_GetType(OH_UdsHtml* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HTML_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+const char* OH_UdsHtml_GetContent(OH_UdsHtml* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HTML_STRUCT_ID, HTML_CONTENT);
+}
+
+const char* OH_UdsHtml_GetPlainContent(OH_UdsHtml* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_HTML_STRUCT_ID, PLAIN_CONTENT);
+}
+
+int OH_UdsHtml_SetContent(OH_UdsHtml* pThis, const char* content)
+{
+    if (content == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_HTML_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(HTML_CONTENT, content);
+}
+
+int OH_UdsHtml_SetPlainContent(OH_UdsHtml* pThis, const char* plainContent)
+{
+    if (plainContent == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_HTML_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(PLAIN_CONTENT, plainContent);
+}
+
+OH_UdsAppItem* OH_UdsAppItem_Create()
+{
+    OH_UdsAppItem* appItem = new (std::nothrow) OH_UdsAppItem();
+    if (appItem == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    appItem->obj = std::make_shared<Object>();
+    appItem->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_OPENHARMONY_APP_ITEM;
+    appItem->obj->value_[APP_ID] = "";
+    appItem->obj->value_[APP_NAME] = "";
+    appItem->obj->value_[APP_ICON_ID] = "";
+    appItem->obj->value_[APP_LABEL_ID] = "";
+    appItem->obj->value_[BUNDLE_NAME] = "";
+    appItem->obj->value_[ABILITY_NAME] = "";
+    return appItem;
+}
+
+void OH_UdsAppItem_Destroy(OH_UdsAppItem* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_APP_ITEM_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsAppItem_GetType(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+const char* OH_UdsAppItem_GetId(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, APP_ID);
+}
+
+const char* OH_UdsAppItem_GetName(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, APP_NAME);
+}
+
+const char* OH_UdsAppItem_GetIconId(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, APP_ICON_ID);
+}
+
+const char* OH_UdsAppItem_GetLabelId(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, APP_LABEL_ID);
+}
+
+const char* OH_UdsAppItem_GetBundleName(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, BUNDLE_NAME);
+}
+
+const char* OH_UdsAppItem_GetAbilityName(OH_UdsAppItem* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID, ABILITY_NAME);
+}
+
+int OH_UdsAppItem_SetId(OH_UdsAppItem* pThis, const char* appId)
+{
+    if (appId == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(APP_ID, appId);
+}
+
+int OH_UdsAppItem_SetName(OH_UdsAppItem* pThis, const char* appName)
+{
+    if (appName == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(APP_NAME, appName);
+}
+
+int OH_UdsAppItem_SetIconId(OH_UdsAppItem* pThis, const char* appIconId)
+{
+    if (appIconId == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(APP_ICON_ID, appIconId);
+}
+
+int OH_UdsAppItem_SetLabelId(OH_UdsAppItem* pThis, const char* appLabelId)
+{
+    if (appLabelId == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(APP_LABEL_ID, appLabelId);
+}
+
+int OH_UdsAppItem_SetBundleName(OH_UdsAppItem* pThis, const char* bundleName)
+{
+    if (bundleName == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(BUNDLE_NAME, bundleName);
+}
+
+int OH_UdsAppItem_SetAbilityName(OH_UdsAppItem* pThis, const char* abilityName)
+{
+    if (abilityName == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_APP_ITEM_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(ABILITY_NAME, abilityName);
+}
+
+OH_UdsFileUri* OH_UdsFileUri_Create()
+{
+    OH_UdsFileUri* fileUri = new (std::nothrow) OH_UdsFileUri();
+    if (fileUri == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    fileUri->obj = std::make_shared<Object>();
+    fileUri->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_GENERAL_FILE_URI;
+    fileUri->obj->value_[FILE_URI_PARAM] = "";
+    fileUri->obj->value_[FILE_TYPE] = "";
+    return fileUri;
+}
+
+void OH_UdsFileUri_Destroy(OH_UdsFileUri* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_FILE_URI_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsFileUri_GetType(OH_UdsFileUri* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_FILE_URI_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+const char* OH_UdsFileUri_GetFileUri(OH_UdsFileUri* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_FILE_URI_STRUCT_ID, FILE_URI_PARAM);
+}
+
+const char* OH_UdsFileUri_GetFileType(OH_UdsFileUri* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_FILE_URI_STRUCT_ID, FILE_TYPE);
+}
+
+int OH_UdsFileUri_SetFileUri(OH_UdsFileUri* pThis, const char* fileUri)
+{
+    if (fileUri == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_FILE_URI_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(FILE_URI_PARAM, fileUri);
+}
+
+int OH_UdsFileUri_SetFileType(OH_UdsFileUri* pThis, const char* fileType)
+{
+    if (fileType == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_FILE_URI_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::string>(FILE_TYPE, fileType);
+}
+
+OH_UdsPixelMap* OH_UdsPixelMap_Create()
+{
+    OH_UdsPixelMap* pixelMap = new (std::nothrow) OH_UdsPixelMap();
+    if (pixelMap == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    pixelMap->obj = std::make_shared<Object>();
+    pixelMap->obj->value_[UNIFORM_DATA_TYPE] = UDMF_META_OPENHARMONY_PIXEL_MAP;
+    pixelMap->obj->value_[PIXEL_MAP] = std::make_shared<OHOS::Media::PixelMap>();
+    return pixelMap;
+}
+
+void OH_UdsPixelMap_Destroy(OH_UdsPixelMap* pThis)
+{
+    if (pThis != nullptr && pThis->cid == NdkStructId::UDS_PIXEL_MAP_STRUCT_ID) {
+        delete pThis;
+    }
+}
+
+const char* OH_UdsPixelMap_GetType(OH_UdsPixelMap* pThis)
+{
+    return GetUdsStrValue(pThis, NdkStructId::UDS_PIXEL_MAP_STRUCT_ID, UNIFORM_DATA_TYPE);
+}
+
+void OH_UdsPixelMap_GetPixelMap(OH_UdsPixelMap* pThis, OH_PixelmapNative* pixelmapNative)
+{
+    if (IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_PIXEL_MAP_STRUCT_ID)) {
+        return;
+    }
+    auto pixelMap = pThis->GetUdsValue<std::shared_ptr<OHOS::Media::PixelMap>>(PIXEL_MAP);
+    if (pixelMap != nullptr) {
+        *pixelmapNative = OH_PixelmapNative(*pixelMap);
+    }
+}
+
+int OH_UdsPixelMap_SetPixelMap(OH_UdsPixelMap* pThis, OH_PixelmapNative* pixelmapNative)
+{
+    if (pixelmapNative == nullptr || IsInvalidUdsObjectPtr(pThis, NdkStructId::UDS_PIXEL_MAP_STRUCT_ID)) {
+        return Udmf_ErrCode::UDMF_E_INVALID_PARAM;
+    }
+    return pThis->SetUdsValue<std::shared_ptr<OHOS::Media::PixelMap>>(PIXEL_MAP, pixelmapNative->GetInnerPixelmap());
+}
+
+OH_UdsArrayBuffer* OH_UdsArrayBuffer_Create()
+{
+    auto *buffer = new (std::nothrow) OH_UdsArrayBuffer();
+    if (buffer == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    buffer->obj = std::make_shared<Object>();
+    buffer->obj->value_[UNIFORM_DATA_TYPE] = "";
+    buffer->obj->value_[ARRAY_BUFFER] = std::vector<uint8_t>();
+    buffer->obj->value_[ARRAY_BUFFER_LENGTH] = 0;
+    return buffer;
+}
+
+int OH_UdsArrayBuffer_Destroy(OH_UdsArrayBuffer* buffer)
+{
+    if (IsInvalidUdsObjectPtr(buffer, NdkStructId::UDS_ARRAY_BUFFER_STRUCT_ID)) {
+        LOG_ERROR(UDMF_CAPI, "Param is invalid.");
+        return UDMF_E_INVALID_PARAM;
+    }
+    delete buffer;
+    return UDMF_E_OK;
+}
+
+int OH_UdsArrayBuffer_SetData(OH_UdsArrayBuffer* buffer, unsigned char* data, unsigned int len)
+{
+    if (data == nullptr || len == 0 || IsInvalidUdsObjectPtr(buffer, NdkStructId::UDS_ARRAY_BUFFER_STRUCT_ID) ||
+        len > MAX_GENERAL_ENTRY_SIZE) {
+        LOG_ERROR(UDMF_CAPI, "Param is invalid.");
+        return UDMF_E_INVALID_PARAM;
+    }
+    std::vector<uint8_t> arrayBuffer(data, data + len);
+    int ret = buffer->SetUdsValue<std::vector<uint8_t>>(ARRAY_BUFFER, arrayBuffer);
+    if (ret != UDMF_E_OK) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory. ret: %{public}d", ret);
+        return ret;
+    }
+    ret = buffer->SetUdsValue<int>(ARRAY_BUFFER_LENGTH, static_cast<int>(len));
+    return ret;
+}
+
+int OH_UdsArrayBuffer_GetData(OH_UdsArrayBuffer* buffer, unsigned char** data, unsigned int* len)
+{
+    if (buffer == nullptr || IsInvalidUdsObjectPtr(buffer, NdkStructId::UDS_ARRAY_BUFFER_STRUCT_ID)) {
+        LOG_ERROR(UDMF_CAPI, "Param is invalid.");
+        return UDMF_E_INVALID_PARAM;
+    }
+    const auto arrayBuffer = buffer->GetUdsValue<std::vector<uint8_t>>(ARRAY_BUFFER);
+    if (arrayBuffer == nullptr || arrayBuffer->empty()) {
+        return UDMF_ERR;
+    }
+    const auto length = buffer->GetUdsValue<int>(ARRAY_BUFFER_LENGTH);
+    if (length == nullptr || *length <= 0 || *length > MAX_GENERAL_ENTRY_SIZE) {
+        return UDMF_ERR;
+    }
+
+    *data = arrayBuffer->data();
+    *len = *length;
+    return UDMF_E_OK;
+}
\ No newline at end of file
diff --git a/udmf/framework/ndkimpl/data/utd.cpp b/udmf/framework/ndkimpl/data/utd.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0969a7d760eec4ede47fa9791381be400250419
--- /dev/null
+++ b/udmf/framework/ndkimpl/data/utd.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Utd"
+#include "utd.h"
+
+#include "securec.h"
+#include "logger.h"
+#include "utd_client.h"
+#include "udmf_capi_common.h"
+#include "udmf_err_code.h"
+
+using namespace OHOS::UDMF;
+
+static constexpr const int32_t MAX_UTD_SIZE = 50;
+
+typedef Status (UtdClient::*GetUtdByConditionPtr)(const std::string&, std::string&, std::string);
+
+static void DestroyArrayPtr(const char** &arrayPtr, unsigned int& count)
+{
+    if (arrayPtr == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Cannot delete arrayPtr because it's a nullptr.");
+        return;
+    }
+    for (unsigned int i = 0; i < count; i++) {
+        if (arrayPtr[i] != nullptr) {
+            delete[] arrayPtr[i];
+            arrayPtr[i] = nullptr;
+        }
+    }
+    delete[] arrayPtr;
+    arrayPtr = nullptr;
+    count = 0;
+    LOG_INFO(UDMF_CAPI, "delete arrayPtr finish.");
+}
+
+static const char** CreateStrArrByVector(const std::vector<std::string>& paramVector, unsigned int* count)
+{
+    unsigned int size = paramVector.size();
+    if (size == 0 || size > MAX_UTD_SIZE) {
+        LOG_ERROR(UDMF_CAPI, "Cannot create array, because size is illegal or exceeds the max value of UTD.");
+        *count = 0;
+        return nullptr;
+    }
+    auto charPtr = new (std::nothrow) char* [size];
+    if (charPtr == nullptr) {
+        *count = 0;
+        return nullptr;
+    }
+    for (unsigned int i = 0; i < size; i++) {
+        charPtr[i] = new (std::nothrow) char[paramVector[i].size() + 1];
+        if (charPtr[i] == nullptr ||
+            strcpy_s(charPtr[i], paramVector[i].size() + 1, paramVector[i].c_str()) != UDMF_E_OK) {
+            LOG_ERROR(UDMF_CAPI, "obtain the memory error, or str copy error!");
+            const char** arrayPtr = const_cast<const char**>(charPtr);
+            DestroyArrayPtr(arrayPtr, size);
+            *count = 0;
+            return nullptr;
+        }
+    }
+    *count = size;
+    return const_cast<const char**>(charPtr);
+}
+
+static std::shared_ptr<TypeDescriptor> GetTypeDescriptorByUtdClient(const char* typeId)
+{
+    std::shared_ptr<TypeDescriptor> typeDescriptor;
+    UtdClient::GetInstance().GetTypeDescriptor(typeId, typeDescriptor);
+    return typeDescriptor;
+}
+
+static bool IsUtdInvalid(OH_Utd* pThis)
+{
+    return pThis == nullptr || pThis->cid != NdkStructId::UTD_STRUCT_ID;
+}
+
+static const char** GetTypesByCondition(const char* condition, unsigned int* count, GetUtdByConditionPtr funcPtr)
+{
+    if (condition == nullptr || count == nullptr || funcPtr == nullptr) {
+        return nullptr;
+    }
+    std::string typeIdStr;
+    Status result = (UtdClient::GetInstance().*funcPtr)(condition, typeIdStr, DEFAULT_TYPE_ID);
+    if (result != Status::E_OK || typeIdStr.empty()) {
+        LOG_ERROR(UDMF_CAPI, "Failed to obtain typeId by invoking the native function.");
+        return nullptr;
+    }
+    auto typeId = new (std::nothrow) char[typeIdStr.size() + 1];
+    if (typeId == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "obtain typeId's memory error!");
+        return nullptr;
+    }
+    if (strcpy_s(typeId, typeIdStr.size() + 1, typeIdStr.c_str()) != UDMF_E_OK) {
+        LOG_ERROR(UDMF_CAPI, "str copy error!");
+        delete[] typeId;
+        return nullptr;
+    }
+    *count = 1;
+    auto typeIds = new char* [*count];
+    typeIds[0] = typeId;
+    return const_cast<const char**>(typeIds);
+}
+
+OH_Utd* OH_Utd_Create(const char* typeId)
+{
+    if (typeId == nullptr) {
+        return nullptr;
+    }
+    auto pThis = new (std::nothrow) OH_Utd();
+    if (pThis == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to apply for memory.");
+        return nullptr;
+    }
+    auto typeDescriptor = GetTypeDescriptorByUtdClient(typeId);
+    if (typeDescriptor == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+        delete pThis;
+        return nullptr;
+    }
+    pThis->typeId = typeDescriptor->GetTypeId();
+    pThis->description = typeDescriptor->GetDescription();
+    pThis->referenceURL = typeDescriptor->GetReferenceURL();
+    pThis->iconFile = typeDescriptor->GetIconFile();
+    pThis->belongingToTypes =
+        CreateStrArrByVector(typeDescriptor->GetBelongingToTypes(), &(pThis->belongingToTypesCount));
+    pThis->filenameExtensions =
+        CreateStrArrByVector(typeDescriptor->GetFilenameExtensions(), &(pThis->filenameExtensionsCount));
+    pThis->mimeTypes = CreateStrArrByVector(typeDescriptor->GetMimeTypes(), &(pThis->mimeTypeCount));
+    return pThis;
+}
+
+void OH_Utd_Destroy(OH_Utd* pThis)
+{
+    if (IsUtdInvalid(pThis)) {
+        LOG_ERROR(UDMF_CAPI, "Failed to Destroy UTD, because pThis maybe nullptr or non-UTD struct ptr.");
+        return;
+    }
+    DestroyArrayPtr(pThis->belongingToTypes, pThis->belongingToTypesCount);
+    DestroyArrayPtr(pThis->filenameExtensions, pThis->filenameExtensionsCount);
+    DestroyArrayPtr(pThis->mimeTypes, pThis->mimeTypeCount);
+    delete pThis;
+    LOG_INFO(UDMF_CAPI, "OH_Utd ptr already be delete");
+}
+
+const char* OH_Utd_GetTypeId(OH_Utd* pThis)
+{
+    return IsUtdInvalid(pThis) ? nullptr : pThis->typeId.c_str();
+}
+
+const char* OH_Utd_GetDescription(OH_Utd* pThis)
+{
+    return IsUtdInvalid(pThis) ? nullptr : pThis->description.c_str();
+}
+
+const char* OH_Utd_GetReferenceUrl(OH_Utd* pThis)
+{
+    return IsUtdInvalid(pThis) ? nullptr : pThis->referenceURL.c_str();
+}
+
+const char* OH_Utd_GetIconFile(OH_Utd* pThis)
+{
+    return IsUtdInvalid(pThis) ? nullptr : pThis->iconFile.c_str();
+}
+
+const char** OH_Utd_GetBelongingToTypes(OH_Utd* pThis, unsigned int* count)
+{
+    if (IsUtdInvalid(pThis) || count == nullptr) {
+        return nullptr;
+    }
+    *count = pThis->belongingToTypesCount;
+    return pThis->belongingToTypes;
+}
+
+const char** OH_Utd_GetFilenameExtensions(OH_Utd* pThis, unsigned int* count)
+{
+    if (IsUtdInvalid(pThis) || count == nullptr) {
+        return nullptr;
+    }
+    *count = pThis->filenameExtensionsCount;
+    return pThis->filenameExtensions;
+}
+
+const char** OH_Utd_GetMimeTypes(OH_Utd* pThis, unsigned int* count)
+{
+    if (IsUtdInvalid(pThis) || count == nullptr) {
+        return nullptr;
+    }
+    *count = pThis->mimeTypeCount;
+    return pThis->mimeTypes;
+}
+
+const char** OH_Utd_GetTypesByFilenameExtension(const char* extension, unsigned int* count)
+{
+    return GetTypesByCondition(extension, count, &UtdClient::GetUniformDataTypeByFilenameExtension);
+}
+
+const char** OH_Utd_GetTypesByMimeType(const char* mimeType, unsigned int* count)
+{
+    return GetTypesByCondition(mimeType, count, &UtdClient::GetUniformDataTypeByMIMEType);
+}
+
+bool OH_Utd_BelongsTo(const char* srcTypeId, const char* destTypeId)
+{
+    if (srcTypeId == nullptr || destTypeId == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "The input parameter is nullptr");
+        return false;
+    }
+    auto typeDescriptor = GetTypeDescriptorByUtdClient(srcTypeId);
+    if (typeDescriptor == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+        return false;
+    }
+    bool checkResult{false};
+    if (typeDescriptor->BelongsTo(destTypeId, checkResult) != Status::E_OK) {
+        LOG_ERROR(UDMF_CAPI, "invoke the native function error.");
+    }
+    return checkResult;
+}
+
+bool OH_Utd_IsLower(const char* srcTypeId, const char* destTypeId)
+{
+    if (srcTypeId == nullptr || destTypeId == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "The input parameter is nullptr");
+        return false;
+    }
+    auto typeDescriptor = GetTypeDescriptorByUtdClient(srcTypeId);
+    if (typeDescriptor == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+        return false;
+    }
+    bool checkResult{false};
+    if (typeDescriptor->IsLowerLevelType(destTypeId, checkResult) != Status::E_OK) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+    }
+    return checkResult;
+}
+
+bool OH_Utd_IsHigher(const char* srcTypeId, const char* destTypeId)
+{
+    if (srcTypeId == nullptr || destTypeId == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "The input parameter is nullptr");
+        return false;
+    }
+    auto typeDescriptor = GetTypeDescriptorByUtdClient(srcTypeId);
+    if (typeDescriptor == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+        return false;
+    }
+    bool checkResult{false};
+    if (typeDescriptor->IsHigherLevelType(destTypeId, checkResult) != Status::E_OK) {
+        LOG_ERROR(UDMF_CAPI, "Failed to create by invoking the native function.");
+    }
+    return checkResult;
+}
+
+bool OH_Utd_Equals(OH_Utd* utd1, OH_Utd* utd2)
+{
+    if (IsUtdInvalid(utd1) || IsUtdInvalid(utd2)) {
+        LOG_ERROR(UDMF_CAPI, "The input parameter is invalid");
+        return false;
+    }
+    auto typeDescriptor1 = GetTypeDescriptorByUtdClient(utd1->typeId.c_str());
+    if (typeDescriptor1 == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "utd1 failed to create by invoking the native function.");
+        return false;
+    }
+    auto typeDescriptor2 = GetTypeDescriptorByUtdClient(utd2->typeId.c_str());
+    if (typeDescriptor2 == nullptr) {
+        LOG_ERROR(UDMF_CAPI, "utd2 failed to create by invoking the native function.");
+        return false;
+    }
+    return typeDescriptor1->Equals(typeDescriptor2);
+}
+
+void OH_Utd_DestroyStringList(const char** list, unsigned int count)
+{
+    DestroyArrayPtr(list, count);
+}
diff --git a/udmf/framework/ndkimpl/unittest/BUILD.gn b/udmf/framework/ndkimpl/unittest/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..22da82a79fe98d7d91e3e019e10b25b7f0c918bd
--- /dev/null
+++ b/udmf/framework/ndkimpl/unittest/BUILD.gn
@@ -0,0 +1,93 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/test.gni")
+import("//foundation/distributeddatamgr/udmf/udmf.gni")
+
+module_output_path = "udmf/ndkimpl"
+
+###############################################################################
+config("module_private_config") {
+  include_dirs = [
+    "${udmf_interfaces_path}/ndk/data",
+    "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_interfaces_path}/innerkits/common",
+    "${udmf_framework_path}/common",
+    "${udmf_framework_path}/ndkimpl/data",
+  ]
+}
+
+common_deps = [
+  "${udmf_interfaces_path}/innerkits:udmf_client",
+  "${udmf_interfaces_path}/innerkits:utd_client",
+  "${udmf_interfaces_path}/ndk:libudmf",
+]
+
+common_external_deps = [
+  "ability_base:want",
+  "access_token:libaccesstoken_sdk",
+  "access_token:libnativetoken",
+  "access_token:libtoken_setproc",
+  "c_utils:utils",
+  "image_framework:image",
+  "image_framework:image_native",
+  "image_framework:pixelmap",
+  "samgr:samgr_proxy",
+]
+
+ohos_unittest("UtdTest") {
+  module_out_path = module_output_path
+
+  sources = [ "utd_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+}
+
+ohos_unittest("UdsTest") {
+  module_out_path = module_output_path
+
+  sources = [ "uds_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+}
+
+ohos_unittest("UdmfTest") {
+  module_out_path = module_output_path
+
+  sources = [ "udmf_test.cpp" ]
+
+  configs = [ ":module_private_config" ]
+
+  deps = common_deps
+
+  external_deps = common_external_deps
+}
+
+###############################################################################
+group("unittest") {
+  testonly = true
+
+  deps = [
+    ":UdmfTest",
+    ":UdsTest",
+    ":UtdTest",
+  ]
+}
+###############################################################################
diff --git a/udmf/framework/ndkimpl/unittest/ndk_data_conversion_test.cpp b/udmf/framework/ndkimpl/unittest/ndk_data_conversion_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d8dc45592d7257d496d073331f1cfff3e101f27
--- /dev/null
+++ b/udmf/framework/ndkimpl/unittest/ndk_data_conversion_test.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "NdkDataConversionTest"
+
+#include "ndk_data_conversion.h"
+#include <gtest/gtest.h>
+#include <memory>
+#include "token_setproc.h"
+#include "accesstoken_kit.h"
+#include "nativetoken_kit.h"
+#include "logger.h"
+#include "error_code.h"
+#include "udmf.h"
+#include "udmf_capi_common.h"
+#include "uds.h"
+
+using namespace testing::ext;
+using namespace OHOS::Security::AccessToken;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+
+namespace OHOS::Test {
+    class NdkDataConversionTest : public testing::Test {
+    public:
+        static void SetUpTestCase(void);
+
+        static void TearDownTestCase(void);
+
+        void SetUp();
+
+        void TearDown();
+    };
+
+    void NdkDataConversionTest::SetUpTestCase(void) {}
+
+    void NdkDataConversionTest::TearDownTestCase(void) {}
+
+    void NdkDataConversionTest::SetUp(void) {}
+
+    void NdkDataConversionTest::TearDown(void) {}
+
+    /**
+     * @tc.name: GetNativeUnifiedData_001
+     * @tc.desc: Normal testcase of GetNativeUnifiedData
+     * @tc.type: FUNC
+     */
+    HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_001, TestSize.Level1) {
+        LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 begin.");
+        UnifiedRecord unifiedRecord;
+        const std::string uid("typeId");
+        unifiedRecord.SetUid(uid);
+        OH_UdmfData* ndkData = OH_UdmfData_Create();
+        const std::shared_ptr<UnifiedRecord> recordPtr = std::make_shared<UnifiedRecord>(unifiedRecord);
+        ndkData->unifiedData_->AddRecord(recordPtr);
+        auto data = std::make_shared<UnifiedData>();
+
+        Status status = NdkDataConversion::GetNativeUnifiedData(ndkData, data);
+        ASSERT_EQ(E_OK, status);
+        EXPECT_EQ("typeId", data->GetRecordAt(0)->GetUid());
+
+        OH_UdmfData* ndkDataNull = nullptr;
+        status = NdkDataConversion::GetNativeUnifiedData(ndkDataNull, data);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+
+        std::shared_ptr<UnifiedData> dataNull;
+        status = NdkDataConversion::GetNativeUnifiedData(ndkData, dataNull);
+        OH_UdmfData_Destroy(ndkData);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+        LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 end.");
+    }
+
+    /**
+     * @tc.name: GetNativeUnifiedData_002
+     * @tc.desc: Normal testcase of GetNativeUnifiedData
+     * @tc.type: FUNC
+     */
+    HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_002, TestSize.Level1) {
+        LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 begin.");
+        auto plainText = OH_UdsPlainText_Create();
+        OH_UdmfData* fakeNdkData = reinterpret_cast<OH_UdmfData*>(plainText);
+        auto data = std::make_shared<UnifiedData>();
+        Status status = NdkDataConversion::GetNativeUnifiedData(fakeNdkData, data);
+        OH_UdsPlainText_Destroy(plainText);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+        LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 end.");
+    }
+
+    /**
+     * @tc.name: GetNdkUnifiedData_001
+     * @tc.desc: Error testcase of GetNdkUnifiedData
+     * @tc.type: FUNC
+     */
+    HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_001, TestSize.Level1) {
+        LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 begin.");
+        UnifiedRecord unifiedRecord;
+        const std::string uid("typeId");
+        unifiedRecord.SetUid(uid);
+        const std::shared_ptr<UnifiedRecord> recordPtr = std::make_shared<UnifiedRecord>(unifiedRecord);
+        auto data= std::make_shared<UnifiedData>();
+        data->AddRecord(recordPtr);
+        OH_UdmfData* ndkData = OH_UdmfData_Create();
+        Status status = NdkDataConversion::GetNdkUnifiedData(data, ndkData);
+        ASSERT_EQ(E_OK, status);
+        EXPECT_EQ("typeId", ndkData->unifiedData_->GetRecordAt(0)->GetUid());
+
+        OH_UdmfData* ndkDataNull = nullptr;
+        status = NdkDataConversion::GetNdkUnifiedData(data, ndkDataNull);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+
+        std::shared_ptr<UnifiedData> dataNull;
+        status = NdkDataConversion::GetNdkUnifiedData(dataNull, ndkData);
+        OH_UdmfData_Destroy(ndkData);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+        LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 end.");
+    }
+
+    /**
+     * @tc.name: GetNdkUnifiedData_002
+     * @tc.desc: Error testcase of GetNdkUnifiedData
+     * @tc.type: FUNC
+     */
+    HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_002, TestSize.Level1) {
+        LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 begin.");
+        auto plainText = OH_UdsPlainText_Create();
+        OH_UdmfData* fakeNdkData = reinterpret_cast<OH_UdmfData*>(plainText);
+        auto data = std::make_shared<UnifiedData>();
+        Status status = NdkDataConversion::GetNdkUnifiedData(data, fakeNdkData);
+        OH_UdsPlainText_Destroy(plainText);
+        ASSERT_EQ(E_INVALID_PARAMETERS, status);
+        LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 end.");
+    }
+}
\ No newline at end of file
diff --git a/udmf/framework/ndkimpl/unittest/udmf_test.cpp b/udmf/framework/ndkimpl/unittest/udmf_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5992a2e98c57426904129be584b7e40f552858e1
--- /dev/null
+++ b/udmf/framework/ndkimpl/unittest/udmf_test.cpp
@@ -0,0 +1,1888 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <gtest/gtest.h>
+#include "token_setproc.h"
+#include "accesstoken_kit.h"
+#include "directory_ex.h"
+#include "nativetoken_kit.h"
+#include <unistd.h>
+#include <memory>
+#include "udmf.h"
+#include "uds.h"
+#include "udmf_err_code.h"
+#include "unified_data.h"
+#include "unified_record.h"
+#include "udmf_capi_common.h"
+#include "udmf_client.h"
+#include "plain_text.h"
+#include "udmf_meta.h"
+#include "data_provider_impl.h"
+
+using namespace testing::ext;
+using namespace OHOS::Security::AccessToken;
+using namespace OHOS::UDMF;
+
+namespace OHOS::Test {
+class UDMFTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static void AllocHapToken1();
+    static void AllocHapToken2();
+    void SetHapToken1();
+    bool CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size);
+    static void FinalizeFunc(void* context);
+    static void* GetDataCallbackFunc(void* context, const char* type);
+    static constexpr int USER_ID = 100;
+    static constexpr int INST_INDEX = 0;
+};
+
+void UDMFTest::SetUpTestCase()
+{
+    AllocHapToken1();
+    AllocHapToken2();
+}
+
+void UDMFTest::TearDownTestCase()
+{
+    auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
+    AccessTokenKit::DeleteToken(tokenId);
+    tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
+    AccessTokenKit::DeleteToken(tokenId);
+}
+
+void UDMFTest::SetUp()
+{
+    SetHapToken1();
+}
+
+void UDMFTest::TearDown()
+{
+}
+
+void UDMFTest::AllocHapToken1()
+{
+    HapInfoParams info = {
+        .userID = USER_ID,
+        .bundleName = "ohos.test.demo1",
+        .instIndex = INST_INDEX,
+        .appIDDesc = "ohos.test.demo1"
+    };
+
+    HapPolicyParams policy = {
+        .apl = APL_NORMAL,
+        .domain = "test.domain",
+        .permList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .bundleName = "ohos.test.demo1",
+                .grantMode = 1,
+                .availableLevel = APL_NORMAL,
+                .label = "label",
+                .labelId = 1,
+                .description = "test1",
+                .descriptionId = 1
+            }
+        },
+        .permStateList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .isGeneral = true,
+                .resDeviceID = { "local" },
+                .grantStatus = { PermissionState::PERMISSION_GRANTED },
+                .grantFlags = { 1 }
+            }
+        }
+    };
+    auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
+    SetSelfTokenID(tokenID.tokenIDEx);
+}
+
+void UDMFTest::AllocHapToken2()
+{
+    HapInfoParams info = {
+        .userID = USER_ID,
+        .bundleName = "ohos.test.demo2",
+        .instIndex = INST_INDEX,
+        .appIDDesc = "ohos.test.demo2"
+    };
+
+    HapPolicyParams policy = {
+        .apl = APL_NORMAL,
+        .domain = "test.domain",
+        .permList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .bundleName = "ohos.test.demo2",
+                .grantMode = 1,
+                .availableLevel = APL_NORMAL,
+                .label = "label",
+                .labelId = 1,
+                .description = "test2",
+                .descriptionId = 1
+            }
+        },
+        .permStateList = {
+            {
+                .permissionName = "ohos.permission.test",
+                .isGeneral = true,
+                .resDeviceID = { "local" },
+                .grantStatus = { PermissionState::PERMISSION_GRANTED },
+                .grantFlags = { 1 }
+            }
+        }
+    };
+    auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
+    SetSelfTokenID(tokenID.tokenIDEx);
+}
+
+void UDMFTest::SetHapToken1()
+{
+    auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
+    SetSelfTokenID(tokenId);
+}
+
+bool UDMFTest::CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size)
+{
+    EXPECT_NE(dst, nullptr);
+    EXPECT_NE(src, nullptr);
+    for (int i = 0; i < size; ++i) {
+        if (dst[i] != src[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void UDMFTest::FinalizeFunc(void* context) {}
+
+void* UDMFTest::GetDataCallbackFunc(void* context, const char* type)
+{
+    auto plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetAbstract(plainText, "doing something");
+    OH_UdsPlainText_SetContent(plainText, "doing something");
+    return plainText;
+}
+
+/**
+ * @tc.name: OH_Udmf_CreateUnifiedData001
+ * @tc.desc: test OH_UdmfData_Create
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_CreateUnifiedData001, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    EXPECT_NE(unifiedData, nullptr);
+    EXPECT_NE(unifiedData->unifiedData_, nullptr);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddRecordToUnifiedData001
+ * @tc.desc: OH_UdmfData_AddRecord with return UDMF_E_INVALID_PARAM
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddRecordToUnifiedData001, TestSize.Level0)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+
+    int invalidRes1 = OH_UdmfData_AddRecord(nullptr, record);
+    EXPECT_EQ(invalidRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData unifiedData1;
+    int invalidRes2 = OH_UdmfData_AddRecord(&unifiedData1, record);
+    EXPECT_EQ(invalidRes2, UDMF_E_INVALID_PARAM);
+
+    int invalidRes3 = OH_UdmfData_AddRecord(unifiedData, nullptr);
+    EXPECT_EQ(invalidRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord unifiedRecord1;
+    int invalidRes4 = OH_UdmfData_AddRecord(unifiedData, nullptr);
+    EXPECT_EQ(invalidRes4, UDMF_E_INVALID_PARAM);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddRecordToUnifiedData002
+ * @tc.desc: OH_UdmfData_AddRecord with return UDMF_E_OK
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddRecordToUnifiedData002, TestSize.Level0)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    int status = OH_UdmfData_AddRecord(unifiedData, record);
+    EXPECT_EQ(status, UDMF_E_OK);
+
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_HasUnifiedDataType001
+ * @tc.desc: OH_UdmfData_HasType with return UDMF_E_INVALID_PARAM
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_HasUnifiedDataType001, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    char type[] = "general.plain-text";
+
+    bool status1 = OH_UdmfData_HasType(nullptr, type);
+    EXPECT_FALSE(status1);
+
+    bool status2 = OH_UdmfData_HasType(unifiedData, nullptr);
+    EXPECT_FALSE(status2);
+
+    OH_UdmfData unifiedData1;
+    bool status3 = OH_UdmfData_HasType(&unifiedData1, nullptr);
+    EXPECT_FALSE(status3);
+
+    bool status4 = OH_UdmfData_HasType(nullptr, nullptr);
+    EXPECT_FALSE(status4);
+
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_HasUnifiedDataType002
+ * @tc.desc: OH_UdmfData_HasType with return whether has type, number 1 represent true, number 0 represent false
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_HasUnifiedDataType002, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(unifiedData, record);
+
+    char type1[] = "general.plain-text";
+    int hasType1 = OH_UdmfData_HasType(unifiedData, type1);
+    EXPECT_EQ(hasType1, 1);
+
+    char type2[] = "general.html";
+    int hasType2 = OH_UdmfData_HasType(unifiedData, type2);
+    EXPECT_EQ(hasType2, 0);
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetUnifiedDataTypes001
+ * @tc.desc: OH_UdmfData_GetTypes with invalid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetUnifiedDataTypes001, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+
+    unsigned int count1 = 0;
+    char **types1 = OH_UdmfData_GetTypes(nullptr, &count1);
+    EXPECT_EQ(types1, nullptr);
+
+    OH_UdmfData data;
+    char **types2 = OH_UdmfData_GetTypes(&data, &count1);
+    EXPECT_EQ(types2, nullptr);
+
+    char **types3 = OH_UdmfData_GetTypes(unifiedData, nullptr);
+    EXPECT_EQ(types3, nullptr);
+
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetUnifiedDataTypes002
+ * @tc.desc: OH_UdmfData_GetTypes with valid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetUnifiedDataTypes002, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(unifiedData, record);
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsHyperlink *hyperlink = OH_UdsHyperlink_Create();
+    OH_UdmfRecord_AddHyperlink(record1, hyperlink);
+    OH_UdmfData_AddRecord(unifiedData, record1);
+
+    unsigned int count1 = 0;
+    char **types1 = OH_UdmfData_GetTypes(unifiedData, &count1);
+    EXPECT_NE(types1, nullptr);
+    EXPECT_EQ(count1, 2);
+
+    char **types2 = OH_UdmfData_GetTypes(unifiedData, &count1);
+    EXPECT_EQ(types1, types2);
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdsHyperlink_Destroy(hyperlink);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetUnifiedRecordTypes001
+ * @tc.desc: OH_UdmfRecord_GetTypes with invalid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetUnifiedRecordTypes001, TestSize.Level0)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    unsigned int count = 0;
+    char **types1 = OH_UdmfRecord_GetTypes(nullptr, &count);
+    EXPECT_EQ(types1, nullptr);
+
+    char **types2 = OH_UdmfRecord_GetTypes(record, nullptr);
+    EXPECT_EQ(types2, nullptr);
+
+    OH_UdmfRecord recordCp;
+    char **types3 = OH_UdmfRecord_GetTypes(&recordCp, nullptr);
+    EXPECT_EQ(types3, nullptr);
+
+    OH_UdmfRecord_Destroy(record);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetUnifiedRecordTypes002
+ * @tc.desc: OH_UdmfRecord_GetTypes with valid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetUnifiedRecordTypes002, TestSize.Level0)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plaintext = OH_UdsPlainText_Create();
+    OH_UdmfRecord_AddPlainText(record, plaintext);
+    unsigned int count = 0;
+    char **types1 = OH_UdmfRecord_GetTypes(record, &count);
+    EXPECT_NE(types1, nullptr);
+    EXPECT_EQ(count, 1);
+
+    char **types2 = OH_UdmfRecord_GetTypes(record, &count);
+    EXPECT_NE(types2, nullptr);
+    EXPECT_EQ(count, 1);
+    EXPECT_EQ(types2, types1);
+
+    OH_UdsPlainText_Destroy(plaintext);
+    OH_UdmfRecord_Destroy(record);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetRecords001
+ * @tc.desc: OH_UdmfRecord_GetTypes with invalid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetRecords001, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+
+    unsigned int count1 = 0;
+    OH_UdmfRecord **records1 = OH_UdmfData_GetRecords(nullptr, &count1);
+    EXPECT_EQ(records1, nullptr);
+
+    OH_UdmfData data;
+    OH_UdmfRecord **records2 = OH_UdmfData_GetRecords(&data, &count1);
+    EXPECT_EQ(records2, nullptr);
+
+    OH_UdmfRecord **records3 = OH_UdmfData_GetRecords(unifiedData, nullptr);
+    EXPECT_EQ(records3, nullptr);
+
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetRecords002
+ * @tc.desc: OH_UdmfRecord_GetTypes with valid params
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetRecords002, TestSize.Level0)
+{
+    OH_UdmfData *unifiedData = OH_UdmfData_Create();
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(unifiedData, record);
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsHyperlink *hyperlink = OH_UdsHyperlink_Create();
+    OH_UdmfRecord_AddHyperlink(record1, hyperlink);
+    OH_UdmfData_AddRecord(unifiedData, record1);
+
+    unsigned int count = 0;
+    OH_UdmfRecord **records1 = OH_UdmfData_GetRecords(unifiedData, &count);
+    EXPECT_EQ(count, 2);
+    EXPECT_NE(records1, nullptr);
+
+    OH_UdmfRecord **records2 = OH_UdmfData_GetRecords(unifiedData, &count);
+    EXPECT_EQ(count, 2);
+    EXPECT_NE(records2, nullptr);
+    EXPECT_EQ(records2, records1);
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdsHyperlink_Destroy(hyperlink);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdmfData_Destroy(unifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetUnifiedData001
+ * @tc.desc: OH_Udmf_SetUnifiedData with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, UdmfTest006, TestSize.Level0)
+{
+    Udmf_Intention intention = UDMF_INTENTION_DRAG;
+    int setRes1 = OH_Udmf_SetUnifiedData(intention, nullptr, nullptr, 0);
+    EXPECT_EQ(setRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData unifiedData;
+    int setRes2 = OH_Udmf_SetUnifiedData(intention, &unifiedData, nullptr, 0);
+    EXPECT_EQ(setRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData *unifiedData1 = OH_UdmfData_Create();
+    int setRes3 = OH_Udmf_SetUnifiedData(intention, unifiedData1, nullptr, 0);
+    EXPECT_EQ(setRes3, UDMF_E_INVALID_PARAM);
+
+    char key[] = "key";
+    int setRes4 = OH_Udmf_SetUnifiedData(intention, unifiedData1, key, 0);
+    EXPECT_EQ(setRes4, UDMF_E_INVALID_PARAM);
+
+    intention = static_cast<Udmf_Intention>(10);
+    int setRes5 = OH_Udmf_SetUnifiedData(intention, unifiedData1, key, UDMF_KEY_BUFFER_LEN);
+    EXPECT_EQ(setRes5, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData_Destroy(unifiedData1);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetUnifiedData001
+ * @tc.desc: OH_Udmf_GetUnifiedData with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetUnifiedData001, TestSize.Level0)
+{
+    Udmf_Intention intention = UDMF_INTENTION_DRAG;
+    int getRes1 = OH_Udmf_GetUnifiedData(nullptr, intention, nullptr);
+    EXPECT_EQ(getRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData unifiedData;
+    int getRes2 = OH_Udmf_GetUnifiedData(nullptr, intention, &unifiedData);
+    EXPECT_EQ(getRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData *unifiedData1 = OH_UdmfData_Create();
+    int getRes3 = OH_Udmf_GetUnifiedData(nullptr, intention, unifiedData1);
+    EXPECT_EQ(getRes3, UDMF_E_INVALID_PARAM);
+
+    int getRes4 = OH_Udmf_GetUnifiedData("KEY", UDMF_INTENTION_PASTEBOARD, unifiedData1);
+    EXPECT_EQ(getRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData_Destroy(unifiedData1);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetAndGetUnifiedData001
+ * @tc.desc: OH_Udmf_SetUnifiedData and OH_Udmf_GetUnifiedData with valid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetAndGetUnifiedData001, TestSize.Level0)
+{
+    OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    char content[] = "hello world";
+    OH_UdsPlainText_SetContent(plainText, content);
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(udmfUnifiedData, record);
+    Udmf_Intention intention = UDMF_INTENTION_DRAG;
+    char key[UDMF_KEY_BUFFER_LEN];
+
+    int setRes = OH_Udmf_SetUnifiedData(intention, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
+    EXPECT_EQ(setRes, UDMF_E_OK);
+    EXPECT_NE(key[0], '\0');
+    OH_UdmfData *readUnifiedData = OH_UdmfData_Create();
+    int getRes = OH_Udmf_GetUnifiedData(key, intention, readUnifiedData);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+    unsigned int count = 0;
+    OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(readUnifiedData, &count);
+    EXPECT_EQ(count, 1);
+    OH_UdsPlainText *getPlainText = OH_UdsPlainText_Create();
+    OH_UdmfRecord_GetPlainText(getRecords[0], getPlainText);
+    const char *getContent = OH_UdsPlainText_GetContent(getPlainText);
+    EXPECT_EQ(strcmp(getContent, content), 0);
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(udmfUnifiedData);
+
+    OH_UdsPlainText_Destroy(getPlainText);
+    OH_UdmfData_Destroy(readUnifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetAndGetUnifiedData002
+ * @tc.desc: OH_Udmf_SetUnifiedData and OH_Udmf_GetUnifiedData with valid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetAndGetUnifiedData002, TestSize.Level0)
+{
+    OH_UdmfData *udmfUnifiedData = OH_UdmfData_Create();
+    char typeId[] = "ApplicationDefined-myType";
+    unsigned char entry[] = "CreateGeneralRecord";
+    unsigned int count = sizeof(entry);
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    int setRes = OH_UdmfRecord_AddGeneralEntry(record, typeId, entry, count);
+    EXPECT_EQ(setRes, UDMF_E_OK);
+    setRes = OH_UdmfData_AddRecord(udmfUnifiedData, record);
+    EXPECT_EQ(setRes, UDMF_E_OK);
+    Udmf_Intention intention = UDMF_INTENTION_DRAG;
+    char key[UDMF_KEY_BUFFER_LEN];
+
+    setRes = OH_Udmf_SetUnifiedData(intention, udmfUnifiedData, key, UDMF_KEY_BUFFER_LEN);
+    EXPECT_EQ(setRes, UDMF_E_OK);
+    EXPECT_NE(key[0], '\0');
+    OH_UdmfData *readUnifiedData = OH_UdmfData_Create();
+    int getUnifiedDataRes = OH_Udmf_GetUnifiedData(key, intention, readUnifiedData);
+    EXPECT_EQ(getUnifiedDataRes, UDMF_E_OK);
+    unsigned int getRecordsCount = 0;
+    OH_UdmfRecord **getRecords = OH_UdmfData_GetRecords(readUnifiedData, &getRecordsCount);
+    EXPECT_EQ(getRecordsCount, 1);
+    EXPECT_NE(getRecords, nullptr);
+
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(readUnifiedData);
+    OH_UdmfData_Destroy(udmfUnifiedData);
+}
+
+/**
+ * @tc.name: OH_Udmf_CreateUnifiedRecord001
+ * @tc.desc: OH_Udmf_CreateUnifiedRecord001
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_CreateUnifiedRecord001, TestSize.Level0)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    EXPECT_NE(record, nullptr);
+    EXPECT_NE(record->record_, nullptr);
+    OH_UdmfRecord_Destroy(record);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddGeneralEntry001
+ * @tc.desc: test OH_UdmfRecord_AddGeneralEntry with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddGeneralEntry001, TestSize.Level0)
+{
+    int addRes1 = OH_UdmfRecord_AddGeneralEntry(nullptr, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int addRes2 = OH_UdmfRecord_AddGeneralEntry(&record1, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int addRes3 = OH_UdmfRecord_AddGeneralEntry(record2, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes3, UDMF_E_INVALID_PARAM);
+
+    char typeId[] = "general.plain-text";
+    int addRes4 = OH_UdmfRecord_AddGeneralEntry(record2, typeId, nullptr, 0);
+    EXPECT_EQ(addRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetGeneralEntry001
+ * @tc.desc: test OH_UdmfRecord_GetGeneralEntry with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetGeneralEntry001, TestSize.Level0)
+{
+    int addRes1 = OH_UdmfRecord_GetGeneralEntry(nullptr, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int addRes2 = OH_UdmfRecord_GetGeneralEntry(&record1, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int addRes3 = OH_UdmfRecord_GetGeneralEntry(record2, nullptr, nullptr, 0);
+    EXPECT_EQ(addRes3, UDMF_E_INVALID_PARAM);
+
+    char typeId[] = "general.plain-text";
+    int addRes4 = OH_UdmfRecord_GetGeneralEntry(record2, typeId, nullptr, 0);
+    EXPECT_EQ(addRes4, UDMF_E_INVALID_PARAM);
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddAndGetGeneralEntry002
+ * @tc.desc: test OH_UdmfRecord_AddGeneralEntry and OH_UdmfRecord_GetGeneralEntry with valid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddAndGetGeneralEntry002, TestSize.Level0)
+{
+    char typeId[] = "general.plain-text";
+    unsigned char entry[] = "CreateGeneralRecord";
+    unsigned int count = sizeof(entry);
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    int addRes1 = OH_UdmfRecord_AddGeneralEntry(record, typeId, entry, count);
+    EXPECT_EQ(addRes1, UDMF_E_INVALID_PARAM);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddAndGetGeneralEntry003
+ * @tc.desc: test OH_UdmfRecord_AddGeneralEntry and OH_UdmfRecord_GetGeneralEntry with appdefined type
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddAndGetGeneralEntry003, TestSize.Level0)
+{
+    char typeId[] = "ApplicationDefined-myType";
+    unsigned char entry[] = "CreateGeneralRecord1";
+    unsigned int count = sizeof(entry);
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    int addRes1 = OH_UdmfRecord_AddGeneralEntry(record, typeId, entry, count);
+    EXPECT_EQ(addRes1, UDMF_E_OK);
+
+    unsigned int getCount = 0;
+    unsigned char *getEntry;
+    int getRes = OH_UdmfRecord_GetGeneralEntry(record, typeId, &getEntry, &getCount);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+    EXPECT_EQ(getCount, count);
+    ASSERT_TRUE(CheckUnsignedChar(entry, getEntry, getCount));
+    OH_UdmfRecord_Destroy(record);
+}
+
+/**
+ * @tc.name: OH_Udmf_AddAndGetGeneralEntry004
+ * @tc.desc: test OH_UdmfRecord_AddGeneralEntry and OH_UdmfRecord_GetGeneralEntry with appdefined diff types
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(UDMFTest, OH_Udmf_AddAndGetGeneralEntry004, TestSize.Level0)
+{
+    char typeId1[] = "ApplicationDefined-myType1";
+    unsigned char entry1[] = "CreateGeneralRecord1";
+    unsigned int count1 = sizeof(entry1);
+    char typeId2[] = "ApplicationDefined-myType2";
+    unsigned char entry2[] = "CreateGeneralRecord2";
+    unsigned int count2 = sizeof(entry2);
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    int addRes1 = OH_UdmfRecord_AddGeneralEntry(record, typeId1, entry1, count1);
+    EXPECT_EQ(addRes1, UDMF_E_OK);
+    addRes1 = OH_UdmfRecord_AddGeneralEntry(record, typeId2, entry2, count2);
+    EXPECT_EQ(addRes1, UDMF_E_OK);
+
+    unsigned int getCount1 = 0;
+    unsigned char *getEntry1;
+    int getRes = OH_UdmfRecord_GetGeneralEntry(record, typeId1, &getEntry1, &getCount1);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+    EXPECT_EQ(getCount1, count1);
+    ASSERT_TRUE(CheckUnsignedChar(entry1, getEntry1, getCount1));
+
+    unsigned int getCount2 = 0;
+    unsigned char *getEntry2;
+    getRes = OH_UdmfRecord_GetGeneralEntry(record, typeId2, &getEntry2, &getCount2);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+    EXPECT_EQ(getCount2, count2);
+    ASSERT_TRUE(CheckUnsignedChar(entry2, getEntry2, getCount2));
+
+    OH_UdmfRecord_Destroy(record);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByPlainText001
+ * @tc.desc: test OH_UdmfRecord_AddPlainText with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByPlainText001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_AddPlainText(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_AddPlainText(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_AddPlainText(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsPlainText plainText;
+    int buildRes4 = OH_UdmfRecord_AddPlainText(record2, &plainText);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetPlainTextFromRecord001
+ * @tc.desc: test OH_UdmfRecord_GetPlainText with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetPlainTextFromRecord001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_GetPlainText(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_GetPlainText(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_GetPlainText(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsPlainText plainText;
+    int buildRes4 = OH_UdmfRecord_GetPlainText(record2, &plainText);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildAndGetPlainTextFromRecord001
+ * @tc.desc: test OH_UdmfRecord_GetPlainText and OH_Udmf_BuildPlainTextFromRecord with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildAndGetPlainTextFromRecord001, TestSize.Level0)
+{
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText1 = OH_UdsPlainText_Create();
+    char content[] = "hello world";
+    OH_UdsPlainText_SetContent(plainText1, content);
+    int buildRes = OH_UdmfRecord_AddPlainText(record1, plainText1);
+    EXPECT_EQ(buildRes, UDMF_E_OK);
+
+    OH_UdsPlainText *plainText2 = OH_UdsPlainText_Create();
+    int getRes = OH_UdmfRecord_GetPlainText(record1, plainText2);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+
+    const char *getContent = OH_UdsPlainText_GetContent(plainText2);
+    EXPECT_EQ(strcmp(content, getContent), 0);
+
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdsPlainText_Destroy(plainText1);
+    OH_UdsPlainText_Destroy(plainText2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByHyperlink001
+ * @tc.desc: test OH_UdmfRecord_AddHyperlink with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByHyperlink001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_AddHyperlink(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_AddHyperlink(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_AddHyperlink(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHyperlink hyperlink;
+    int buildRes4 = OH_UdmfRecord_AddHyperlink(record2, &hyperlink);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetHyperlinkFromRecord001
+ * @tc.desc: test OH_UdmfRecord_GetHyperlink with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetHyperlinkFromRecord001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_GetHyperlink(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_GetHyperlink(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_GetHyperlink(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHyperlink hyperlink;
+    int buildRes4 = OH_UdmfRecord_GetHyperlink(record2, &hyperlink);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildAndGetHyperlinkFromRecord001
+ * @tc.desc: test OH_Udmf_BuildAndGetHyperlinkFromRecord with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildAndGetHyperlinkFromRecord001, TestSize.Level0)
+{
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsHyperlink *hyperlink1 = OH_UdsHyperlink_Create();
+    char url[] = "https://gitee.com/openharmony/distributeddatamgr_udmf/members";
+    OH_UdsHyperlink_SetUrl(hyperlink1, url);
+    int buildRes = OH_UdmfRecord_AddHyperlink(record1, hyperlink1);
+    EXPECT_EQ(buildRes, UDMF_E_OK);
+
+    OH_UdsHyperlink *hyperlink2 = OH_UdsHyperlink_Create();
+    int getRes = OH_UdmfRecord_GetHyperlink(record1, hyperlink2);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+
+    const char *getUrl = OH_UdsHyperlink_GetUrl(hyperlink2);
+    EXPECT_EQ(strcmp(url, getUrl), 0);
+
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdsHyperlink_Destroy(hyperlink1);
+    OH_UdsHyperlink_Destroy(hyperlink2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByHtml001
+ * @tc.desc: test OH_UdmfRecord_AddHtml with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByHtml001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_AddHtml(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_AddHtml(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_AddHtml(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHtml html;
+    int buildRes4 = OH_UdmfRecord_AddHtml(record2, &html);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetHtmlFromRecord001
+ * @tc.desc: test OH_UdmfRecord_GetHtml with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetHtmlFromRecord001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_GetHtml(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_GetHtml(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_GetHtml(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHtml html;
+    int buildRes4 = OH_UdmfRecord_GetHtml(record2, &html);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildAndGetHtmlFromRecord001
+ * @tc.desc: test OH_Udmf_BuildAndGetHtmlFromRecord with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildAndGetHtmlFromRecord001, TestSize.Level0)
+{
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsHtml *html1 = OH_UdsHtml_Create();
+    char content[] = "hello world";
+    OH_UdsHtml_SetContent(html1, content);
+    int buildRes = OH_UdmfRecord_AddHtml(record1, html1);
+    EXPECT_EQ(buildRes, UDMF_E_OK);
+
+    OH_UdsHtml *html2 = OH_UdsHtml_Create();
+    int getRes = OH_UdmfRecord_GetHtml(record1, html2);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+
+    const char *getContent = OH_UdsHtml_GetContent(html2);
+    EXPECT_EQ(strcmp(content, getContent), 0);
+
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdsHtml_Destroy(html1);
+    OH_UdsHtml_Destroy(html2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByOpenHarmonyAppItem001
+ * @tc.desc: test OH_UdmfRecord_AddAppItem with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByOpenHarmonyAppItem001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_AddAppItem(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_AddAppItem(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_AddAppItem(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsAppItem appItem;
+    int buildRes4 = OH_UdmfRecord_AddAppItem(record2, &appItem);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetOpenHarmonyAppItemFromRecord001
+ * @tc.desc: test OH_UdmfRecord_GetAppItem with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetOpenHarmonyAppItemFromRecord001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_GetAppItem(nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_GetAppItem(&record1, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_GetAppItem(record2, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsAppItem appItem;
+    int buildRes4 = OH_UdmfRecord_GetAppItem(record2, &appItem);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildAndGetAppItemFromRecord001
+ * @tc.desc: test OH_Udmf_BuildAndGetAppItemFromRecord with invalid param
+ * @tc.type: FUNC
+ * @tc.require: AROOOH5R5G
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildAndGetAppItemFromRecord001, TestSize.Level0)
+{
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    OH_UdsAppItem *appItem1 = OH_UdsAppItem_Create();
+    char name[] = "appItem";
+    OH_UdsAppItem_SetName(appItem1, name);
+    int buildRes = OH_UdmfRecord_AddAppItem(record1, appItem1);
+    EXPECT_EQ(buildRes, UDMF_E_OK);
+
+    OH_UdsAppItem *appItem2 = OH_UdsAppItem_Create();
+    int getRes = OH_UdmfRecord_GetAppItem(record1, appItem2);
+    EXPECT_EQ(getRes, UDMF_E_OK);
+
+    const char *getName = OH_UdsAppItem_GetName(appItem2);
+    EXPECT_EQ(strcmp(name, getName), 0);
+
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdsAppItem_Destroy(appItem1);
+    OH_UdsAppItem_Destroy(appItem2);
+}
+
+/**
+ * @tc.name: OH_Udmf_CreatePropertiesFromUnifiedData001
+ * @tc.desc: Normal testcase of OH_UdmfProperty_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_CreatePropertiesFromUnifiedData001, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    auto duration = std::chrono::system_clock::now().time_since_epoch();
+    EXPECT_LE(properties->properties_->timestamp,
+        std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
+    OH_UdmfData_Destroy(data);
+    OH_UdmfProperty_Destroy(properties);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesTag001
+ * @tc.desc: Normal testcase of OH_Udmf_SetPropertiesTag001
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesTag001, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    std::string tag("tag");
+    int result = OH_UdmfProperty_SetTag(properties, tag.c_str());
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ(tag, OH_UdmfProperty_GetTag(properties));
+    OH_UdmfProperty_Destroy(properties);
+    OH_UdmfData_Destroy(data);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesShareOption001
+ * @tc.desc: set properties IN_APP
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesShareOption001, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    int result = OH_UdmfProperty_SetShareOption(properties, Udmf_ShareOption::SHARE_OPTIONS_IN_APP);
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ(Udmf_ShareOption::SHARE_OPTIONS_IN_APP, OH_UdmfProperty_GetShareOption(properties));
+    OH_UdmfData_Destroy(data);
+    OH_UdmfProperty_Destroy(properties);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesShareOption002
+ * @tc.desc: set properties CROSS_APP
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesShareOption002, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    int result = OH_UdmfProperty_SetShareOption(properties, Udmf_ShareOption::SHARE_OPTIONS_CROSS_APP);
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ(Udmf_ShareOption::SHARE_OPTIONS_CROSS_APP, OH_UdmfProperty_GetShareOption(properties));
+    OH_UdmfData_Destroy(data);
+    OH_UdmfProperty_Destroy(properties);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesShareOption003
+ * @tc.desc: set invalid properties
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesShareOption003, TestSize.Level1)
+{
+    OH_UdmfProperty *property = nullptr;
+    EXPECT_EQ(Udmf_ShareOption::SHARE_OPTIONS_INVALID, OH_UdmfProperty_GetShareOption(property));
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesExtrasIntParam001
+ * @tc.desc: Normal testcase of OH_UdmfProperty_SetExtrasIntParam
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesExtrasIntParam001, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    int result = OH_UdmfProperty_SetExtrasIntParam(properties, "keyInt", 0);
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ(0, OH_UdmfProperty_GetExtrasIntParam(properties, "keyInt", -1));
+    OH_UdmfData_Destroy(data);
+    OH_UdmfProperty_Destroy(properties);
+}
+
+/**
+ * @tc.name: OH_Udmf_SetPropertiesExtrasStringParam001
+ * @tc.desc: Normal testcase of OH_UdmfProperty_SetExtrasStringParam
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_SetPropertiesExtrasStringParam001, TestSize.Level1)
+{
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfProperty *properties = OH_UdmfProperty_Create(data);
+    std::string str("str");
+    int result = OH_UdmfProperty_SetExtrasStringParam(properties, "keyStr", str.c_str());
+    EXPECT_EQ(UDMF_E_OK, result);
+    std::string actualStr(OH_UdmfProperty_GetExtrasStringParam(properties, "keyStr"));
+    EXPECT_EQ(str, actualStr);
+    OH_UdmfData_Destroy(data);
+    OH_UdmfProperty_Destroy(properties);
+}
+
+/**
+ * @tc.name: OH_Udmf_MultiStyleRecord001
+ * @tc.desc: Normal testcase of OH_UdmfProperty_SetExtrasStringParam
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_MultiStyleRecord001, TestSize.Level1)
+{
+    OH_UdsPlainText* plainText = OH_UdsPlainText_Create();
+    char plainTextContent[] = "plain text";
+    OH_UdsPlainText_SetContent(plainText, plainTextContent);
+
+    OH_UdsHyperlink* hyperlink = OH_UdsHyperlink_Create();
+    char url[] = "hyper link";
+    OH_UdsHyperlink_SetUrl(hyperlink, url);
+
+    OH_UdsHtml* html = OH_UdsHtml_Create();
+    char htmlContent[] = "html";
+    OH_UdsHtml_SetContent(html, htmlContent);
+
+    OH_UdsAppItem* appItem = OH_UdsAppItem_Create();
+    char name[] = "appItem";
+    OH_UdsAppItem_SetName(appItem, name);
+
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfRecord_AddHyperlink(record, hyperlink);
+    OH_UdmfRecord_AddHtml(record, html);
+    OH_UdmfRecord_AddAppItem(record, appItem);
+
+    unsigned int count = 0;
+    char** types = OH_UdmfRecord_GetTypes(record, &count);
+    EXPECT_NE(types, nullptr);
+    EXPECT_EQ(count, 4);
+
+    OH_UdsPlainText *getPlainText = OH_UdsPlainText_Create();
+    OH_UdmfRecord_GetPlainText(record, getPlainText);
+    const char *getPlainTextContent = OH_UdsPlainText_GetContent(getPlainText);
+    EXPECT_EQ(strcmp(getPlainTextContent, plainTextContent), 0);
+
+    OH_UdsHyperlink *getHyperLink = OH_UdsHyperlink_Create();
+    OH_UdmfRecord_GetHyperlink(record, getHyperLink);
+    const char *getUrl = OH_UdsHyperlink_GetUrl(getHyperLink);
+    EXPECT_EQ(strcmp(getUrl, url), 0);
+
+    OH_UdsHtml *getHtml = OH_UdsHtml_Create();
+    OH_UdmfRecord_GetHtml(record, getHtml);
+    const char *getHtmlContent = OH_UdsHtml_GetContent(getHtml);
+    EXPECT_EQ(strcmp(getHtmlContent, htmlContent), 0);
+
+    OH_UdsAppItem *getAppItem = OH_UdsAppItem_Create();
+    OH_UdmfRecord_GetAppItem(record, getAppItem);
+    const char *getName = OH_UdsAppItem_GetName(getAppItem);
+    EXPECT_EQ(strcmp(getName, name), 0);
+
+    OH_UdmfData* data = OH_UdmfData_Create();
+    OH_UdmfData_AddRecord(data, record);
+
+    unsigned int count2 = 0;
+    char** types2 = OH_UdmfData_GetTypes(data, &count2);
+    EXPECT_NE(types2, nullptr);
+    EXPECT_EQ(count2, 4);
+
+    char plianTextType[] = "general.plain-text";
+    char hyperLinkType[] = "general.hyperlink";
+    char htmlType[] = "general.html";
+    char appItemType[] = "openharmony.app-item";
+
+    EXPECT_TRUE(OH_UdmfData_HasType(data, plianTextType));
+    EXPECT_TRUE(OH_UdmfData_HasType(data, hyperLinkType));
+    EXPECT_TRUE(OH_UdmfData_HasType(data, htmlType));
+    EXPECT_TRUE(OH_UdmfData_HasType(data, appItemType));
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdsPlainText_Destroy(getPlainText);
+    OH_UdsHyperlink_Destroy(hyperlink);
+    OH_UdsHyperlink_Destroy(getHyperLink);
+    OH_UdsHtml_Destroy(html);
+    OH_UdsHtml_Destroy(getHtml);
+    OH_UdsAppItem_Destroy(appItem);
+    OH_UdsAppItem_Destroy(getAppItem);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(data);
+}
+
+/**
+ * @tc.name: OH_UdmfRecordProvider_Create001
+ * @tc.desc: Normal testcase of OH_UdmfRecordProvider_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecordProvider_Create001, TestSize.Level1)
+{
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    OH_UdmfRecordProvider_Destroy(provider);
+}
+
+/**
+ * @tc.name: OH_UdmfRecordProvider_Destroy001
+ * @tc.desc: Normal testcase of OH_UdmfRecordProvider_Destroy
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecordProvider_Destroy001, TestSize.Level1)
+{
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, FinalizeFunc);
+    int res1 = OH_UdmfRecordProvider_Destroy(provider);
+    EXPECT_EQ(res1, UDMF_E_OK);
+}
+
+/**
+ * @tc.name: OH_UdmfRecordProvider_Destroy002
+ * @tc.desc: invalid parameters testcase of OH_UdmfRecordProvider_Destroy
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecordProvider_Destroy002, TestSize.Level1)
+{
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, nullptr);
+    int res1 = OH_UdmfRecordProvider_Destroy(provider);
+    EXPECT_EQ(res1, UDMF_E_OK);
+}
+
+/**
+ * @tc.name: OH_UdmfRecordProvider_SetData001
+ * @tc.desc: Normal testcase of OH_UdmfRecordProvider_SetData
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecordProvider_SetData001, TestSize.Level1)
+{
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    int res = OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, FinalizeFunc);
+    EXPECT_NE(provider->context, nullptr);
+    EXPECT_NE(provider->callback, nullptr);
+    EXPECT_NE(provider->finalize, nullptr);
+    EXPECT_EQ(res, UDMF_E_OK);
+    OH_UdmfRecordProvider_Destroy(provider);
+}
+
+/**
+ * @tc.name: OH_UdmfRecordProvider_SetData002
+ * @tc.desc: invalid parameters testcase of OH_UdmfRecordProvider_SetData
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecordProvider_SetData002, TestSize.Level1)
+{
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    int res1 = OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, nullptr);
+    EXPECT_EQ(provider->context, nullptr);
+    EXPECT_EQ(provider->finalize, nullptr);
+    EXPECT_EQ(res1, UDMF_E_INVALID_PARAM);
+
+    int res2 = OH_UdmfRecordProvider_SetData(nullptr, context, GetDataCallbackFunc, nullptr);
+    EXPECT_EQ(res2, UDMF_E_INVALID_PARAM);
+
+    int res3 = OH_UdmfRecordProvider_SetData(provider, context, nullptr, nullptr);
+    EXPECT_EQ(res3, UDMF_E_INVALID_PARAM);
+    OH_UdmfRecordProvider_Destroy(provider);
+}
+
+/**
+ * @tc.name: OH_UdmfRecord_SetProvider001
+ * @tc.desc: Normal testcase of OH_UdmfRecord_SetProvider
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecord_SetProvider001, TestSize.Level1)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    char content[] = "hello world";
+    OH_UdsPlainText_SetContent(plainText, content);
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, FinalizeFunc);
+    const char* types[3] = { "general.plain-text", "general.hyperlink", "general.html" };
+
+    int res = OH_UdmfRecord_SetProvider(record, types, 3, provider);
+    EXPECT_EQ(res, UDMF_E_OK);
+    OH_UdmfRecordProvider_Destroy(provider);
+}
+
+/**
+ * @tc.name: OH_UdmfRecord_SetProvider002
+ * @tc.desc: invalid parameters testcase of OH_UdmfRecord_SetProvider
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfRecord_SetProvider002, TestSize.Level1)
+{
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    char content[] = "hello world";
+    OH_UdsPlainText_SetContent(plainText, content);
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfRecordProvider* provider = OH_UdmfRecordProvider_Create();
+    EXPECT_NE(provider, nullptr);
+    int num = 1;
+    void* context = &num;
+    OH_UdmfRecordProvider_SetData(provider, context, GetDataCallbackFunc, FinalizeFunc);
+    const char* types[3] = { "general.plain-text", "general.hyperlink", "general.html" };
+
+    int res = OH_UdmfRecord_SetProvider(record, types, 3, provider);
+    EXPECT_EQ(res, UDMF_E_OK);
+    OH_UdmfRecordProvider_Destroy(provider);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByOpenHarmonyArrayBuffer001
+ * @tc.desc: test OH_UdmfRecord_AddArrayBuffer with invalid param
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByOpenHarmonyArrayBuffer001, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_AddArrayBuffer(nullptr, nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_AddArrayBuffer(&record1, nullptr, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_AddArrayBuffer(record2, nullptr, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsArrayBuffer buffer;
+    int buildRes4 = OH_UdmfRecord_AddArrayBuffer(record2, nullptr, &buffer);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdsArrayBuffer *buffer2 = OH_UdsArrayBuffer_Create();
+    int buildRes5 = OH_UdmfRecord_AddArrayBuffer(record2, nullptr, buffer2);
+    EXPECT_EQ(buildRes5, UDMF_E_INVALID_PARAM);
+
+    char type[] = "general.plain-text";
+    int buildRes6 = OH_UdmfRecord_AddArrayBuffer(record2, type, buffer2);
+    EXPECT_EQ(buildRes6, UDMF_E_INVALID_PARAM);
+
+    char type2[] = "ApplicationDefined-myType1";
+    int buildRes7 = OH_UdmfRecord_AddArrayBuffer(record2, type2, buffer2);
+    EXPECT_EQ(buildRes7, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdsArrayBuffer_Destroy(buffer2);
+}
+
+/**
+ * @tc.name: OH_Udmf_BuildRecordByOpenHarmonyArrayBuffer002
+ * @tc.desc: test OH_UdmfRecord_AddArrayBuffer with invalid param
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_BuildRecordByOpenHarmonyArrayBuffer002, TestSize.Level0)
+{
+    int buildRes1 = OH_UdmfRecord_GetArrayBuffer(nullptr, nullptr, nullptr);
+    EXPECT_EQ(buildRes1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord record1;
+    int buildRes2 = OH_UdmfRecord_GetArrayBuffer(&record1, nullptr, nullptr);
+    EXPECT_EQ(buildRes2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    int buildRes3 = OH_UdmfRecord_GetArrayBuffer(record2, nullptr, nullptr);
+    EXPECT_EQ(buildRes3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsArrayBuffer buffer;
+    int buildRes4 = OH_UdmfRecord_GetArrayBuffer(record2, nullptr, &buffer);
+    EXPECT_EQ(buildRes4, UDMF_E_INVALID_PARAM);
+
+    OH_UdsArrayBuffer *buffer2 = OH_UdsArrayBuffer_Create();
+    int buildRes5 = OH_UdmfRecord_GetArrayBuffer(record2, nullptr, buffer2);
+    EXPECT_EQ(buildRes5, UDMF_E_INVALID_PARAM);
+
+    char type[] = "general.plain-text";
+    int buildRes6 = OH_UdmfRecord_GetArrayBuffer(record2, type, buffer2);
+    EXPECT_EQ(buildRes6, UDMF_E_INVALID_PARAM);
+
+    char type2[] = "ApplicationDefined-myType1";
+    int buildRes7 = OH_UdmfRecord_GetArrayBuffer(record2, type2, buffer2);
+    EXPECT_EQ(buildRes7, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdsArrayBuffer_Destroy(buffer2);
+}
+
+/**
+ * @tc.name: OH_Udmf_GetArrayBufferFromRecord001
+ * @tc.desc: test OH_UdmfRecord_AddArrayBuffer with invalid param
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_Udmf_GetArrayBufferFromRecord001, TestSize.Level0)
+{
+    unsigned char data1[] = "Hello world";
+    unsigned int len1 = sizeof(data1);
+    OH_UdsArrayBuffer *buffer1 = OH_UdsArrayBuffer_Create();
+    OH_UdsArrayBuffer_SetData(buffer1, data1, len1);
+
+    char type1[] = "ApplicationDefined-myType1";
+    OH_UdmfRecord *record1 = OH_UdmfRecord_Create();
+    int buildRes = OH_UdmfRecord_AddArrayBuffer(record1, type1, buffer1);
+    ASSERT_EQ(buildRes, UDMF_E_OK);
+
+    char type2[] = "ApplicationDefined-myType2";
+    OH_UdsArrayBuffer *buffer2 = OH_UdsArrayBuffer_Create();
+    int getRes = OH_UdmfRecord_GetArrayBuffer(record1, type2, buffer2);
+    EXPECT_EQ(getRes, UDMF_E_INVALID_PARAM);
+
+    int getRes2 = OH_UdmfRecord_GetArrayBuffer(record1, type1, buffer2);
+    ASSERT_EQ(getRes2, UDMF_E_OK);
+
+    unsigned int getLen = 0;
+    unsigned char *getData;
+    int getRes3 = OH_UdsArrayBuffer_GetData(buffer2, &getData, &getLen);
+    ASSERT_EQ(getRes3, UDMF_E_OK);
+    ASSERT_EQ(len1, getLen);
+    ASSERT_TRUE(CheckUnsignedChar(data1, getData, getLen));
+
+    OH_UdmfRecord_Destroy(record1);
+    OH_UdsArrayBuffer_Destroy(buffer1);
+    OH_UdsArrayBuffer_Destroy(buffer2);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryPlainText001
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryPlainText
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryPlainText001, TestSize.Level1)
+{
+    int result = OH_UdmfData_GetPrimaryPlainText(nullptr, nullptr);
+    EXPECT_EQ(result, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData data;
+    int result2 = OH_UdmfData_GetPrimaryPlainText(&data, nullptr);
+    EXPECT_EQ(result2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    int result3 = OH_UdmfData_GetPrimaryPlainText(data2, nullptr);
+    EXPECT_EQ(result3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsPlainText plainText;
+    int result4 = OH_UdmfData_GetPrimaryPlainText(data2, &plainText);
+    EXPECT_EQ(result4, UDMF_E_INVALID_PARAM);
+
+    OH_UdsPlainText *plainText2 = OH_UdsPlainText_Create();
+    int result5 = OH_UdmfData_GetPrimaryPlainText(data2, plainText2);
+    EXPECT_EQ(result5, UDMF_ERR);
+
+    OH_UdsPlainText_Destroy(plainText2);
+    OH_UdmfData_Destroy(data2);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryPlainText002
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryPlainText
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryPlainText002, TestSize.Level1)
+{
+    const char *helloWorld = "Hello world";
+
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdsPlainText *plainTextOutput = OH_UdsPlainText_Create();
+    int result = OH_UdmfData_GetPrimaryPlainText(data, plainTextOutput);
+    EXPECT_EQ(result, UDMF_ERR);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    OH_UdsHtml *html = OH_UdsHtml_Create();
+    OH_UdsHtml_SetContent(html, "<p>Hello world</p>");
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddHtml(record, html);
+    OH_UdmfData_AddRecord(data2, record);
+    int result2 = OH_UdmfData_GetPrimaryPlainText(data2, plainTextOutput);
+    EXPECT_EQ(result2, UDMF_ERR);
+
+    OH_UdmfData *data3 = OH_UdmfData_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText, helloWorld);
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record2, plainText);
+    OH_UdmfData_AddRecord(data3, record);
+    OH_UdmfData_AddRecord(data3, record2);
+    int result3 = OH_UdmfData_GetPrimaryPlainText(data3, plainTextOutput);
+    ASSERT_EQ(result3, UDMF_E_OK);
+    auto *content = OH_UdsPlainText_GetContent(plainTextOutput);
+    EXPECT_EQ(strcmp(content, helloWorld), 0);
+
+    OH_UdsHtml_Destroy(html);
+    OH_UdsPlainText_Destroy(plainTextOutput);
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfData_Destroy(data);
+    OH_UdmfData_Destroy(data2);
+    OH_UdmfData_Destroy(data3);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryPlainText003
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryPlainText
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryPlainText003, TestSize.Level1)
+{
+    const char *helloWorld = "Hello world";
+    const char *helloWorld2 = "Hello world2";
+
+    OH_UdsHtml *html = OH_UdsHtml_Create();
+    OH_UdsHtml_SetContent(html, "<p>Hello world</p>");
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddHtml(record, html);
+
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText, helloWorld);
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record2, plainText);
+
+
+    OH_UdsPlainText *plainText2 = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText2, helloWorld2);
+    OH_UdmfRecord* record3 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record3, plainText2);
+
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfData_AddRecord(data, record3);
+    OH_UdmfData_AddRecord(data, record2);
+    OH_UdmfData_AddRecord(data, record);
+    OH_UdsPlainText *plainTextOutput = OH_UdsPlainText_Create();
+    int result4 = OH_UdmfData_GetPrimaryPlainText(data, plainTextOutput);
+    ASSERT_EQ(result4, UDMF_E_OK);
+    auto *content2 = OH_UdsPlainText_GetContent(plainTextOutput);
+    EXPECT_EQ(strcmp(content2, helloWorld2), 0);
+
+    OH_UdsHtml_Destroy(html);
+    OH_UdsPlainText_Destroy(plainTextOutput);
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdsPlainText_Destroy(plainText2);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfRecord_Destroy(record3);
+    OH_UdmfData_Destroy(data);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryHtml001
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryHtml
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryHtml001, TestSize.Level1)
+{
+    int result1 = OH_UdmfData_GetPrimaryHtml(nullptr, nullptr);
+    EXPECT_EQ(result1, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData data;
+    int result2 = OH_UdmfData_GetPrimaryHtml(&data, nullptr);
+    EXPECT_EQ(result2, UDMF_E_INVALID_PARAM);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    int result3 = OH_UdmfData_GetPrimaryHtml(data2, nullptr);
+    EXPECT_EQ(result3, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHtml html;
+    int result4 = OH_UdmfData_GetPrimaryHtml(data2, &html);
+    EXPECT_EQ(result4, UDMF_E_INVALID_PARAM);
+
+    OH_UdsHtml *html2 = OH_UdsHtml_Create();
+    int result5 = OH_UdmfData_GetPrimaryHtml(data2, html2);
+    EXPECT_EQ(result5, UDMF_ERR);
+
+    OH_UdsHtml_Destroy(html2);
+    OH_UdmfData_Destroy(data2);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryHtml002
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryHtml
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryHtml002, TestSize.Level1)
+{
+    const char *helloWorld = "<p>Hello world</p>";
+
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdsHtml *htmlOutput = OH_UdsHtml_Create();
+    int result = OH_UdmfData_GetPrimaryHtml(data, htmlOutput);
+    EXPECT_EQ(result, UDMF_ERR);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText, "Hello world");
+    OH_UdmfRecord* record = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(data2, record);
+    int result2 = OH_UdmfData_GetPrimaryHtml(data2, htmlOutput);
+    EXPECT_EQ(result2, UDMF_ERR);
+
+    OH_UdmfData *data3 = OH_UdmfData_Create();
+    OH_UdsHtml *html = OH_UdsHtml_Create();
+    OH_UdsHtml_SetContent(html, helloWorld);
+    OH_UdmfRecord* record2 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddHtml(record2, html);
+    OH_UdmfData_AddRecord(data3, record);
+    OH_UdmfData_AddRecord(data3, record2);
+    int result3 = OH_UdmfData_GetPrimaryHtml(data3, htmlOutput);
+    ASSERT_EQ(result3, UDMF_E_OK);
+    auto content = OH_UdsHtml_GetContent(htmlOutput);
+    EXPECT_EQ(strcmp(content, helloWorld), 0);
+
+    OH_UdsHtml_Destroy(html);
+    OH_UdsHtml_Destroy(htmlOutput);
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfData_Destroy(data);
+    OH_UdmfData_Destroy(data2);
+    OH_UdmfData_Destroy(data3);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetPrimaryHtml003
+ * @tc.desc: Normal testcase of OH_UdmfData_GetPrimaryHtml
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetPrimaryHtml003, TestSize.Level1)
+{
+    const char *helloWorld = "<p>Hello world</p>";
+    const char *helloWorld2 = "<p>Hello world2</p>";
+
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText, "Hello world");
+    OH_UdmfRecord* record = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+
+    OH_UdsHtml *html = OH_UdsHtml_Create();
+    OH_UdsHtml_SetContent(html, helloWorld);
+    OH_UdmfRecord* record2 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddHtml(record2, html);
+
+    OH_UdsHtml *html2 = OH_UdsHtml_Create();
+    OH_UdsHtml_SetContent(html2, helloWorld2);
+    OH_UdmfRecord* record3 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddHtml(record3, html2);
+
+    OH_UdmfData *data = OH_UdmfData_Create();
+    OH_UdmfData_AddRecord(data, record3);
+    OH_UdmfData_AddRecord(data, record2);
+    OH_UdmfData_AddRecord(data, record);
+    OH_UdsHtml *htmlOutput = OH_UdsHtml_Create();
+    int result4 = OH_UdmfData_GetPrimaryHtml(data, htmlOutput);
+    ASSERT_EQ(result4, UDMF_E_OK);
+    auto content2 = OH_UdsHtml_GetContent(htmlOutput);
+    EXPECT_EQ(strcmp(content2, helloWorld2), 0);
+
+    OH_UdsHtml_Destroy(html);
+    OH_UdsHtml_Destroy(html2);
+    OH_UdsHtml_Destroy(htmlOutput);
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfRecord_Destroy(record3);
+    OH_UdmfData_Destroy(data);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetRecordCount001
+ * @tc.desc: Normal testcase of OH_UdmfData_GetRecordCount
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetRecordCount001, TestSize.Level1)
+{
+    int result = OH_UdmfData_GetRecordCount(nullptr);
+    EXPECT_EQ(result, 0);
+
+    OH_UdmfData data;
+    int result2 = OH_UdmfData_GetRecordCount(&data);
+    EXPECT_EQ(result2, 0);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    int result3 = OH_UdmfData_GetRecordCount(data2);
+    EXPECT_EQ(result3, 0);
+
+    OH_UdmfData *data3 = OH_UdmfData_Create();
+    OH_UdmfRecord *record = OH_UdmfRecord_Create();
+    OH_UdmfData_AddRecord(data3, record);
+    int result4 = OH_UdmfData_GetRecordCount(data3);
+    EXPECT_EQ(result4, 1);
+
+    OH_UdmfData *data4 = OH_UdmfData_Create();
+    OH_UdmfRecord *record2 = OH_UdmfRecord_Create();
+    OH_UdmfData_AddRecord(data4, record);
+    OH_UdmfData_AddRecord(data4, record2);
+    int result5 = OH_UdmfData_GetRecordCount(data4);
+    EXPECT_EQ(result5, 2);
+
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfData_Destroy(data2);
+    OH_UdmfData_Destroy(data3);
+    OH_UdmfData_Destroy(data4);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetRecord001
+ * @tc.desc: Normal testcase of OH_UdmfData_GetRecord
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetRecord001, TestSize.Level1)
+{
+    OH_UdmfRecord *result = OH_UdmfData_GetRecord(nullptr, -1);
+    EXPECT_EQ(result, nullptr);
+
+    OH_UdmfData data;
+    OH_UdmfRecord *result2 = OH_UdmfData_GetRecord(&data, -1);
+    EXPECT_EQ(result2, nullptr);
+
+    OH_UdmfRecord *result3 = OH_UdmfData_GetRecord(&data, 0);
+    EXPECT_EQ(result3, nullptr);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    OH_UdmfRecord *result4 = OH_UdmfData_GetRecord(data2, -1);
+    EXPECT_EQ(result4, nullptr);
+
+    OH_UdmfRecord *result5 = OH_UdmfData_GetRecord(data2, 0);
+    EXPECT_EQ(result5, nullptr);
+
+    OH_UdmfRecord *result6 = OH_UdmfData_GetRecord(data2, 1);
+    EXPECT_EQ(result6, nullptr);
+
+    OH_UdmfData *data3 = OH_UdmfData_Create();
+    OH_UdmfRecord* record = OH_UdmfRecord_Create();
+    OH_UdmfData_AddRecord(data3, record);
+    EXPECT_EQ(OH_UdmfData_GetRecordCount(data3), 1);
+    OH_UdmfRecord *result7 = OH_UdmfData_GetRecord(data3, -1);
+    EXPECT_EQ(result7, nullptr);
+    OH_UdmfRecord *result8 = OH_UdmfData_GetRecord(data3, 1);
+    EXPECT_EQ(result8, nullptr);
+    OH_UdmfRecord *result9 = OH_UdmfData_GetRecord(data3, 0);
+    EXPECT_NE(result9, nullptr);
+
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfData_Destroy(data2);
+    OH_UdmfData_Destroy(data3);
+}
+
+/**
+ * @tc.name: OH_UdmfData_GetRecord002
+ * @tc.desc: Normal testcase of OH_UdmfData_GetRecord
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_GetRecord002, TestSize.Level1)
+{
+    const char *helloWorld = "Hello world";
+    const char *helloWorld2 = "Hello world2";
+
+    OH_UdmfData *data3 = OH_UdmfData_Create();
+    OH_UdsPlainText *plainText = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText, helloWorld);
+    OH_UdmfRecord* record = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record, plainText);
+    OH_UdmfData_AddRecord(data3, record);
+    OH_UdmfRecord *result9 = OH_UdmfData_GetRecord(data3, 0);
+    EXPECT_NE(result9, nullptr);
+    OH_UdsPlainText *plainText2 = OH_UdsPlainText_Create();
+    OH_UdmfRecord_GetPlainText(result9, plainText2);
+    auto content = OH_UdsPlainText_GetContent(plainText2);
+    EXPECT_EQ(strcmp(content, helloWorld), 0);
+
+    OH_UdmfData *data4 = OH_UdmfData_Create();
+    OH_UdsPlainText *plainText3 = OH_UdsPlainText_Create();
+    OH_UdsPlainText_SetContent(plainText3, helloWorld2);
+    OH_UdmfRecord* record2 = OH_UdmfRecord_Create();
+    OH_UdmfRecord_AddPlainText(record2, plainText3);
+    OH_UdmfData_AddRecord(data4, record);
+    OH_UdmfData_AddRecord(data4, record2);
+    OH_UdmfRecord *result10 = OH_UdmfData_GetRecord(data4, -1);
+    EXPECT_EQ(result10, nullptr);
+    OH_UdmfRecord *result11 = OH_UdmfData_GetRecord(data4, 2);
+    EXPECT_EQ(result11, nullptr);
+    OH_UdmfRecord *result12 = OH_UdmfData_GetRecord(data4, 0);
+    ASSERT_NE(result12, nullptr);
+    OH_UdsPlainText *plainText4 = OH_UdsPlainText_Create();
+    OH_UdmfRecord_GetPlainText(result12, plainText4);
+    auto content2 = OH_UdsPlainText_GetContent(plainText4);
+    EXPECT_EQ(strcmp(content2, helloWorld), 0);
+    OH_UdmfRecord *result13 = OH_UdmfData_GetRecord(data4, 1);
+    ASSERT_NE(result13, nullptr);
+    OH_UdsPlainText *plainText5 = OH_UdsPlainText_Create();
+    OH_UdmfRecord_GetPlainText(result13, plainText5);
+    auto content3 = OH_UdsPlainText_GetContent(plainText5);
+    EXPECT_EQ(strcmp(content3, helloWorld2), 0);
+
+    OH_UdsPlainText_Destroy(plainText);
+    OH_UdsPlainText_Destroy(plainText2);
+    OH_UdmfRecord_Destroy(record);
+    OH_UdmfRecord_Destroy(record2);
+    OH_UdmfData_Destroy(data3);
+    OH_UdmfData_Destroy(data4);
+}
+
+/**
+ * @tc.name: OH_UdmfData_IsLocal001
+ * @tc.desc: Normal testcase of OH_UdmfData_IsLocal
+ * @tc.type: FUNC
+ */
+HWTEST_F(UDMFTest, OH_UdmfData_IsLocal001, TestSize.Level1)
+{
+    bool result = OH_UdmfData_IsLocal(nullptr);
+    EXPECT_EQ(result, true);
+
+    OH_UdmfData data;
+    bool result2 = OH_UdmfData_IsLocal(&data);
+    EXPECT_EQ(result2, true);
+
+    OH_UdmfData *data2 = OH_UdmfData_Create();
+    bool result3 = OH_UdmfData_IsLocal(data2);
+    EXPECT_EQ(result3, true);
+
+    OH_UdmfData_Destroy(data2);
+}
+}
diff --git a/udmf/framework/ndkimpl/unittest/uds_test.cpp b/udmf/framework/ndkimpl/unittest/uds_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ae4007e938c955baa64add376f3d82360d9502f
--- /dev/null
+++ b/udmf/framework/ndkimpl/unittest/uds_test.cpp
@@ -0,0 +1,1084 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "UdsTest"
+
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "token_setproc.h"
+#include "accesstoken_kit.h"
+#include "nativetoken_kit.h"
+#include "logger.h"
+#include "pixelmap_native_impl.h"
+#include "uds.h"
+#include "udmf_capi_common.h"
+#include "udmf_meta.h"
+#include "udmf_err_code.h"
+
+using namespace testing::ext;
+using namespace OHOS::Security::AccessToken;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+
+namespace OHOS::Test {
+class UdsTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static bool CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size);
+};
+
+void UdsTest::SetUpTestCase(void) {}
+
+void UdsTest::TearDownTestCase(void) {}
+
+void UdsTest::SetUp(void) {}
+
+void UdsTest::TearDown(void) {}
+
+bool UdsTest::CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size)
+{
+    EXPECT_NE(dst, nullptr);
+    EXPECT_NE(src, nullptr);
+    for (int i = 0; i < size; ++i) {
+        if (dst[i] != src[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_Create_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_Create_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    EXPECT_EQ(UDMF_META_PLAIN_TEXT, *(std::get_if<std::string>(&(plainText->obj->value_[UNIFORM_DATA_TYPE]))));
+    OH_UdsPlainText_Destroy(plainText);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_GetType_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetType_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    EXPECT_EQ(UDMF_META_PLAIN_TEXT, std::string(OH_UdsPlainText_GetType(plainText)));
+    OH_UdsPlainText_Destroy(plainText);
+
+    OH_UdsPlainText* plainTextNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetType(plainTextNullptr));
+
+    plainTextNullptr = new OH_UdsPlainText;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetType(plainTextNullptr));
+    OH_UdsPlainText_Destroy(plainTextNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetType_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_GetContent_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_GetContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_GetContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetContent_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    plainText->obj->value_[CONTENT] = "doing something";
+    EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetContent(plainText)));
+    OH_UdsPlainText_Destroy(plainText);
+
+    OH_UdsPlainText* plainTextNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetContent(plainTextNullptr));
+
+    plainTextNullptr = new OH_UdsPlainText;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetContent(plainTextNullptr));
+    OH_UdsPlainText_Destroy(plainTextNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_GetAbstract_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_GetAbstract
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_GetAbstract_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetAbstract_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    plainText->obj->value_[ABSTRACT] = "doing something";
+    EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetAbstract(plainText)));
+    OH_UdsPlainText_Destroy(plainText);
+
+    OH_UdsPlainText* plainTextNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetAbstract(plainTextNullptr));
+
+    plainTextNullptr = new OH_UdsPlainText;
+    EXPECT_EQ(nullptr, OH_UdsPlainText_GetAbstract(plainTextNullptr));
+    OH_UdsPlainText_Destroy(plainTextNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetAbstract_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_SetContent_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_SetContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_SetContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetContent_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    int result = OH_UdsPlainText_SetContent(plainText, "doing something");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetContent(plainText)));
+
+    result = OH_UdsPlainText_SetContent(nullptr, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsPlainText_SetContent(plainText, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    plainText->obj = nullptr;
+    result = OH_UdsPlainText_SetContent(plainText, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsPlainText_Destroy(plainText);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsPlainText_SetAbstract_001
+ * @tc.desc: Normal testcase of OH_UdsPlainText_SetAbstract
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPlainText_SetAbstract_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetAbstract_001 begin.");
+    auto plainText = OH_UdsPlainText_Create();
+    int result = OH_UdsPlainText_SetAbstract(plainText, "doing something");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetAbstract(plainText)));
+
+    result = OH_UdsPlainText_SetAbstract(nullptr, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsPlainText_SetAbstract(plainText, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    plainText->obj = nullptr;
+    result = OH_UdsPlainText_SetAbstract(plainText, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsPlainText_Destroy(plainText);
+    LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetAbstract_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_Create_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_Create_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    EXPECT_EQ(UDMF_META_HYPERLINK, *(std::get_if<std::string>(&(hyperlink->obj)->value_[UNIFORM_DATA_TYPE])));
+    OH_UdsHyperlink_Destroy(hyperlink);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_GetType_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetType_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    EXPECT_EQ(UDMF_META_HYPERLINK, std::string(OH_UdsHyperlink_GetType(hyperlink)));
+    OH_UdsHyperlink_Destroy(hyperlink);
+
+    OH_UdsHyperlink* hyperlinkNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetType(hyperlinkNullptr));
+
+    hyperlinkNullptr = new OH_UdsHyperlink;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetType(hyperlinkNullptr));
+    OH_UdsHyperlink_Destroy(hyperlinkNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetType_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_GetUrl_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_GetUrl
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_GetUrl_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetUrl_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    hyperlink->obj->value_[URL] = "www.xxx.com";
+    EXPECT_EQ("www.xxx.com", std::string(OH_UdsHyperlink_GetUrl(hyperlink)));
+    OH_UdsHyperlink_Destroy(hyperlink);
+
+    OH_UdsHyperlink* hyperlinkNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetUrl(hyperlinkNullptr));
+
+    hyperlinkNullptr = new OH_UdsHyperlink;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetUrl(hyperlinkNullptr));
+    OH_UdsHyperlink_Destroy(hyperlinkNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetUrl_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_GetDescription_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_GetDescription
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_GetDescription_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetDescription_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    hyperlink->obj->value_[DESCRIPTION] = "do something";
+    EXPECT_EQ("do something", std::string(OH_UdsHyperlink_GetDescription(hyperlink)));
+    OH_UdsHyperlink_Destroy(hyperlink);
+
+    OH_UdsHyperlink* hyperlinkNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetDescription(hyperlinkNullptr));
+
+    hyperlinkNullptr = new OH_UdsHyperlink;
+    EXPECT_EQ(nullptr, OH_UdsHyperlink_GetDescription(hyperlinkNullptr));
+    OH_UdsHyperlink_Destroy(hyperlinkNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetDescription_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_SetUrl_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_SetUrl
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_SetUrl_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetUrl_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    int result = OH_UdsHyperlink_SetUrl(hyperlink, "www.xxx.com");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("www.xxx.com", std::string(OH_UdsHyperlink_GetUrl(hyperlink)));
+
+    result = OH_UdsHyperlink_SetUrl(nullptr, "www.xxx.com");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsHyperlink_SetUrl(hyperlink, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    hyperlink->obj = nullptr;
+    result = OH_UdsHyperlink_SetUrl(hyperlink, "www.xxx.com");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsHyperlink_Destroy(hyperlink);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetUrl_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHyperlink_SetDescription_001
+ * @tc.desc: Normal testcase of OH_UdsHyperlink_SetDescription
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHyperlink_SetDescription_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetDescription_001 begin.");
+    auto hyperlink = OH_UdsHyperlink_Create();
+    int result = OH_UdsHyperlink_SetDescription(hyperlink, "doing something");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("doing something", std::string(OH_UdsHyperlink_GetDescription(hyperlink)));
+
+    result = OH_UdsHyperlink_SetDescription(nullptr, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsHyperlink_SetDescription(hyperlink, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    hyperlink->obj = nullptr;
+    result = OH_UdsHyperlink_SetDescription(hyperlink, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsHyperlink_Destroy(hyperlink);
+    LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetDescription_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_Create_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_Create_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    EXPECT_EQ(UDMF_META_HTML, *(std::get_if<std::string>(&(html->obj)->value_[UNIFORM_DATA_TYPE])));
+    OH_UdsHtml_Destroy(html);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_GetType_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetType_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    EXPECT_EQ(UDMF_META_HTML, std::string(OH_UdsHtml_GetType(html)));
+    OH_UdsHtml_Destroy(html);
+
+    OH_UdsHtml* htmlNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetType(htmlNullptr));
+
+    htmlNullptr = new OH_UdsHtml;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetType(htmlNullptr));
+    OH_UdsHtml_Destroy(htmlNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetType_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_GetContent_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_GetContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_GetContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetContent_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    html->obj->value_[HTML_CONTENT] = "htmlxxxxx";
+    EXPECT_EQ("htmlxxxxx", std::string(OH_UdsHtml_GetContent(html)));
+    OH_UdsHtml_Destroy(html);
+
+    OH_UdsHtml* htmlNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetContent(htmlNullptr));
+
+    htmlNullptr = new OH_UdsHtml;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetContent(htmlNullptr));
+    OH_UdsHtml_Destroy(htmlNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_GetPlainContent_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_GetPlainContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_GetPlainContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetPlainContent_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    html->obj->value_[PLAIN_CONTENT] = "do something";
+    EXPECT_EQ("do something", std::string(OH_UdsHtml_GetPlainContent(html)));
+    OH_UdsHtml_Destroy(html);
+
+    OH_UdsHtml* htmlNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetPlainContent(htmlNullptr));
+
+    htmlNullptr = new OH_UdsHtml;
+    EXPECT_EQ(nullptr, OH_UdsHtml_GetPlainContent(htmlNullptr));
+    OH_UdsHtml_Destroy(htmlNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetPlainContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_SetContent_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_SetContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_SetContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetContent_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    int result = OH_UdsHtml_SetContent(html, "htmlxxx");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("htmlxxx", std::string(OH_UdsHtml_GetContent(html)));
+
+    result = OH_UdsHtml_SetContent(nullptr, "htmlxxx");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsHtml_SetContent(html, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    html->obj = nullptr;
+    result = OH_UdsHtml_SetContent(html, "htmlxxx");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsHtml_Destroy(html);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsHtml_SetPlainContent_001
+ * @tc.desc: Normal testcase of OH_UdsHtml_SetPlainContent
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsHtml_SetPlainContent_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetPlainContent_001 begin.");
+    auto html = OH_UdsHtml_Create();
+    int result = OH_UdsHtml_SetPlainContent(html, "doing something");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("doing something", std::string(OH_UdsHtml_GetPlainContent(html)));
+
+    result = OH_UdsHtml_SetPlainContent(nullptr, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsHtml_SetPlainContent(html, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    html->obj = nullptr;
+    result = OH_UdsHtml_SetPlainContent(html, "doing something");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsHtml_Destroy(html);
+    LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetPlainContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_Create_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_Create_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    EXPECT_EQ(UDMF_META_OPENHARMONY_APP_ITEM, *(std::get_if<std::string>(&(appItem->obj)->value_[UNIFORM_DATA_TYPE])));
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetType_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetType_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    EXPECT_EQ(UDMF_META_OPENHARMONY_APP_ITEM, std::string(OH_UdsAppItem_GetType(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetType(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetType(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetType_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[APP_ID] = "com.xxx";
+    EXPECT_EQ("com.xxx", std::string(OH_UdsAppItem_GetId(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetId(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetId(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[APP_NAME] = "OH";
+    EXPECT_EQ("OH", std::string(OH_UdsAppItem_GetName(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetName(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetName(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetIconId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetIconId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetIconId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetIconId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[APP_ICON_ID] = "icon";
+    EXPECT_EQ("icon", std::string(OH_UdsAppItem_GetIconId(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetIconId(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetIconId(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetIconId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetLabelId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetLabelId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetLabelId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetLabelId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[APP_LABEL_ID] = "label";
+    EXPECT_EQ("label", std::string(OH_UdsAppItem_GetLabelId(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetLabelId(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetLabelId(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetLabelId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetBundleName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetBundleName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetBundleName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[BUNDLE_NAME] = "bundle";
+    EXPECT_EQ("bundle", std::string(OH_UdsAppItem_GetBundleName(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetBundleName(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetBundleName(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetBundleName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_GetAbilityName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_GetAbilityName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_GetAbilityName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetAbilityName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    appItem->obj->value_[ABILITY_NAME] = "ability";
+    EXPECT_EQ("ability", std::string(OH_UdsAppItem_GetAbilityName(appItem)));
+    OH_UdsAppItem_Destroy(appItem);
+
+    OH_UdsAppItem* appItemNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetAbilityName(appItemNullptr));
+
+    appItemNullptr = new OH_UdsAppItem;
+    EXPECT_EQ(nullptr, OH_UdsAppItem_GetAbilityName(appItemNullptr));
+    OH_UdsAppItem_Destroy(appItemNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetAbilityName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetId(appItem, "com.xxx");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("com.xxx", std::string(OH_UdsAppItem_GetId(appItem)));
+
+    result = OH_UdsAppItem_SetId(nullptr, "com.xxx");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetId(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetId(appItem, "com.xxx");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetName(appItem, "OH");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("OH", std::string(OH_UdsAppItem_GetName(appItem)));
+
+    result = OH_UdsAppItem_SetName(nullptr, "OH");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetName(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetName(appItem, "OH");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetIconId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetIconId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetIconId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetIconId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetIconId(appItem, "icon");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("icon", std::string(OH_UdsAppItem_GetIconId(appItem)));
+
+    result = OH_UdsAppItem_SetIconId(nullptr, "icon");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetIconId(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetIconId(appItem, "icon");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetIconId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetLabelId_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetLabelId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetLabelId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetLabelId_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetLabelId(appItem, "label");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("label", std::string(OH_UdsAppItem_GetLabelId(appItem)));
+
+    result = OH_UdsAppItem_SetLabelId(nullptr, "label");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetLabelId(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetLabelId(appItem, "label");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetLabelId_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetBundleName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetBundleName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetBundleName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetBundleName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetBundleName(appItem, "bundle");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("bundle", std::string(OH_UdsAppItem_GetBundleName(appItem)));
+
+    result = OH_UdsAppItem_SetBundleName(nullptr, "bundle");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetBundleName(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetBundleName(appItem, "bundle");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetBundleName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsAppItem_SetAbilityName_001
+ * @tc.desc: Normal testcase of OH_UdsAppItem_SetAbilityName
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsAppItem_SetAbilityName_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetAbilityName_001 begin.");
+    auto appItem = OH_UdsAppItem_Create();
+    int result = OH_UdsAppItem_SetAbilityName(appItem, "ability");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("ability", std::string(OH_UdsAppItem_GetAbilityName(appItem)));
+
+    result = OH_UdsAppItem_SetAbilityName(nullptr, "ability");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsAppItem_SetAbilityName(appItem, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    appItem->obj = nullptr;
+    result = OH_UdsAppItem_SetAbilityName(appItem, "ability");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsAppItem_Destroy(appItem);
+    LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetAbilityName_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_Create_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_Create_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    EXPECT_EQ(UDMF_META_GENERAL_FILE_URI, *(std::get_if<std::string>(&(fileUri->obj)->value_[UNIFORM_DATA_TYPE])));
+    OH_UdsFileUri_Destroy(fileUri);
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_GetType_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    EXPECT_EQ(UDMF_META_GENERAL_FILE_URI, std::string(OH_UdsFileUri_GetType(fileUri)));
+    OH_UdsFileUri_Destroy(fileUri);
+
+    OH_UdsFileUri* fileUriNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetType(fileUriNullptr));
+
+    fileUriNullptr = new OH_UdsFileUri;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetType(fileUriNullptr));
+    OH_UdsFileUri_Destroy(fileUriNullptr);
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_GetFileUri_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_GetFileUri
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_GetFileUri_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    fileUri->obj->value_[FILE_URI_PARAM] = "fileUri";
+    EXPECT_EQ("fileUri", std::string(OH_UdsFileUri_GetFileUri(fileUri)));
+    OH_UdsFileUri_Destroy(fileUri);
+
+    OH_UdsFileUri* fileUriNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileUri(fileUriNullptr));
+
+    fileUriNullptr = new OH_UdsFileUri;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileUri(fileUriNullptr));
+    OH_UdsFileUri_Destroy(fileUriNullptr);
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_GetFileType_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_GetFileType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_GetFileType_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    fileUri->obj->value_[FILE_TYPE] = "fileType";
+    EXPECT_EQ("fileType", std::string(OH_UdsFileUri_GetFileType(fileUri)));
+    OH_UdsFileUri_Destroy(fileUri);
+
+    OH_UdsFileUri* fileUriNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileType(fileUriNullptr));
+
+    fileUriNullptr = new OH_UdsFileUri;
+    EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileType(fileUriNullptr));
+    OH_UdsFileUri_Destroy(fileUriNullptr);
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_SetFileUri_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_SetFileUri
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_SetFileUri_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    int result = OH_UdsFileUri_SetFileUri(fileUri, "file uri");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("file uri", std::string(OH_UdsFileUri_GetFileUri(fileUri)));
+
+    result = OH_UdsFileUri_SetFileUri(nullptr, "file uri");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsFileUri_SetFileUri(fileUri, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    fileUri->obj = nullptr;
+    result = OH_UdsFileUri_SetFileUri(fileUri, "file uri");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsFileUri_Destroy(fileUri);
+}
+
+/**
+ * @tc.name: OH_UdsFileUri_SetFileUri_001
+ * @tc.desc: Normal testcase of OH_UdsFileUri_SetFileUri
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsFileUri_SetFileType_001, TestSize.Level1)
+{
+    auto fileUri = OH_UdsFileUri_Create();
+    int result = OH_UdsFileUri_SetFileType(fileUri, "file type");
+    EXPECT_EQ(UDMF_E_OK, result);
+    EXPECT_EQ("file type", std::string(OH_UdsFileUri_GetFileType(fileUri)));
+
+    result = OH_UdsFileUri_SetFileType(nullptr, "file type");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsFileUri_SetFileType(fileUri, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    fileUri->obj = nullptr;
+    result = OH_UdsFileUri_SetFileType(fileUri, "file type");
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    OH_UdsFileUri_Destroy(fileUri);
+}
+
+/**
+ * @tc.name: OH_UdsPixelMap_Create_001
+ * @tc.desc: Normal testcase of OH_UdsPixelMap_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPixelMap_Create_001, TestSize.Level1)
+{
+    auto pixelMap = OH_UdsPixelMap_Create();
+    EXPECT_EQ(UDMF_META_OPENHARMONY_PIXEL_MAP,
+        *(std::get_if<std::string>(&(pixelMap->obj)->value_[UNIFORM_DATA_TYPE])));
+    OH_UdsPixelMap_Destroy(pixelMap);
+}
+
+/**
+ * @tc.name: OH_UdsPixelMap_GetType_001
+ * @tc.desc: Normal testcase of OH_UdsPixelMap_GetType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPixelMap_GetType_001, TestSize.Level1)
+{
+    auto pixelMap = OH_UdsPixelMap_Create();
+    EXPECT_EQ(UDMF_META_OPENHARMONY_PIXEL_MAP, std::string(OH_UdsPixelMap_GetType(pixelMap)));
+    OH_UdsPixelMap_Destroy(pixelMap);
+
+    OH_UdsPixelMap* pixelMapNullptr = nullptr;
+    EXPECT_EQ(nullptr, OH_UdsPixelMap_GetType(pixelMapNullptr));
+
+    pixelMapNullptr = new OH_UdsPixelMap;
+    EXPECT_EQ(nullptr, OH_UdsPixelMap_GetType(pixelMapNullptr));
+    OH_UdsPixelMap_Destroy(pixelMapNullptr);
+}
+
+/**
+ * @tc.name: OH_UdsPixelMap_GetPixelMap_001
+ * @tc.desc: Normal testcase of OH_UdsPixelMap_GetPixelMap
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPixelMap_GetPixelMap_001, TestSize.Level1)
+{
+    auto pixelMap = OH_UdsPixelMap_Create();
+    std::shared_ptr<OHOS::Media::PixelMap> pixelMapPtr = std::make_shared<OHOS::Media::PixelMap>();
+    pixelMapPtr->SetTransformered(true);
+    pixelMap->obj->value_[PIXEL_MAP] = pixelMapPtr;
+    OH_PixelmapNative* pixelMapResult = new OH_PixelmapNative(nullptr);
+    OH_UdsPixelMap_GetPixelMap(pixelMap, pixelMapResult);
+    auto innerPixelMap = pixelMapResult->GetInnerPixelmap();
+    EXPECT_NE(nullptr, innerPixelMap);
+    EXPECT_TRUE(innerPixelMap->IsTransformered());
+    OH_UdsPixelMap_Destroy(pixelMap);
+    delete pixelMapResult;
+
+    OH_PixelmapNative* ohPixelMapNull = new OH_PixelmapNative(nullptr);
+    OH_UdsPixelMap* pixelMapNullptr = nullptr;
+    OH_UdsPixelMap_GetPixelMap(pixelMapNullptr, ohPixelMapNull);
+    EXPECT_EQ(nullptr, ohPixelMapNull->GetInnerPixelmap());
+    delete pixelMapNullptr;
+
+    pixelMapNullptr = new OH_UdsPixelMap;
+    OH_UdsPixelMap_GetPixelMap(pixelMapNullptr, ohPixelMapNull);
+    EXPECT_EQ(nullptr, ohPixelMapNull->GetInnerPixelmap());
+    delete ohPixelMapNull;
+    OH_UdsPixelMap_Destroy(pixelMapNullptr);
+}
+
+/**
+ * @tc.name: OH_UdsPixelMap_SetPixelMap_001
+ * @tc.desc: Normal testcase of OH_UdsPixelMap_SetPixelMap
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsPixelMap_SetPixelMap_001, TestSize.Level1)
+{
+    auto pixelMap = OH_UdsPixelMap_Create();
+    std::shared_ptr<OHOS::Media::PixelMap> pixelMapPtr = std::make_shared<OHOS::Media::PixelMap>();
+    pixelMapPtr->SetTransformered(true);
+    OH_PixelmapNative* ohPixelmapNative = new OH_PixelmapNative(pixelMapPtr);
+    int result = OH_UdsPixelMap_SetPixelMap(pixelMap, ohPixelmapNative);
+    EXPECT_EQ(UDMF_E_OK, result);
+    OH_PixelmapNative* pixelMapResult = new OH_PixelmapNative(nullptr);
+    OH_UdsPixelMap_GetPixelMap(pixelMap, pixelMapResult);
+    auto innerPixelMap = pixelMapResult->GetInnerPixelmap();
+    EXPECT_NE(nullptr, innerPixelMap);
+    EXPECT_TRUE(innerPixelMap->IsTransformered());
+
+    result = OH_UdsPixelMap_SetPixelMap(nullptr, ohPixelmapNative);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsPixelMap_SetPixelMap(pixelMap, nullptr);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    pixelMap->obj = nullptr;
+    result = OH_UdsPixelMap_SetPixelMap(pixelMap, ohPixelmapNative);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+    delete pixelMapResult;
+    delete ohPixelmapNative;
+    OH_UdsPixelMap_Destroy(pixelMap);
+}
+/**
+ * @tc.name: OH_UdsArrayBuffer_Create_001
+ * @tc.desc: Normal testcase of OH_UdsArrayBuffer_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsArrayBuffer_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_Create_001 begin.");
+    auto buffer = OH_UdsArrayBuffer_Create();
+    EXPECT_NE(buffer, nullptr);
+    int ret = OH_UdsArrayBuffer_Destroy(buffer);
+    EXPECT_EQ(UDMF_E_OK, ret);
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsArrayBuffer_GetData_001
+ * @tc.desc: Normal testcase of OH_UdsArrayBuffer_GetData
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsArrayBuffer_GetData_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_GetData_001 begin.");
+    auto buffer = OH_UdsArrayBuffer_Create();
+
+    unsigned char data[] = "doing something";
+    int len = sizeof(data);
+
+    std::vector<uint8_t> bufferData(data, data + len);
+    buffer->obj->value_[ARRAY_BUFFER] = bufferData;
+    buffer->obj->value_[ARRAY_BUFFER_LENGTH] = len;
+
+    unsigned char *getData;
+    unsigned int getLen;
+    int ret = OH_UdsArrayBuffer_GetData(buffer, &getData, &getLen);
+    ASSERT_EQ(UDMF_E_OK, ret);
+    ASSERT_EQ(len, getLen);
+    ASSERT_TRUE(CheckUnsignedChar(data, getData, getLen));
+    OH_UdsArrayBuffer_Destroy(buffer);
+
+    OH_UdsArrayBuffer* bufferNullptr = nullptr;
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, OH_UdsArrayBuffer_GetData(bufferNullptr, &getData, &getLen));
+    delete bufferNullptr;
+
+    bufferNullptr = new OH_UdsArrayBuffer;
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, OH_UdsArrayBuffer_GetData(bufferNullptr, &getData, &getLen));
+    OH_UdsArrayBuffer_Destroy(bufferNullptr);
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_GetContent_001 end.");
+}
+
+/**
+ * @tc.name: OH_UdsArrayBuffer_SetData_001
+ * @tc.desc: Normal testcase of OH_UdsArrayBuffer_SetData
+ * @tc.type: FUNC
+ */
+HWTEST_F(UdsTest, OH_UdsArrayBuffer_SetData_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_SetData_001 begin.");
+    int result = OH_UdsArrayBuffer_SetData(nullptr, nullptr, 0);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    auto buffer = OH_UdsArrayBuffer_Create();
+    result = OH_UdsArrayBuffer_SetData(buffer, nullptr, 0);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    unsigned char data[] = "doing something";
+    unsigned int len = sizeof(data);
+    result = OH_UdsArrayBuffer_SetData(buffer, data, 0);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsArrayBuffer_SetData(buffer, data, 128 * 1024 * 1024 + 1);
+    EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
+
+    result = OH_UdsArrayBuffer_SetData(buffer, data, len);
+    EXPECT_EQ(UDMF_E_OK, result);
+
+    unsigned char *getData;
+    unsigned int getLen;
+    int ret = OH_UdsArrayBuffer_GetData(buffer, &getData, &getLen);
+    ASSERT_EQ(UDMF_E_OK, ret);
+    ASSERT_EQ(len, getLen);
+    ASSERT_TRUE(CheckUnsignedChar(data, getData, getLen));
+
+    OH_UdsArrayBuffer_Destroy(buffer);
+    LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_SetData_001 end.");
+}
+
+}
diff --git a/udmf/framework/ndkimpl/unittest/utd_test.cpp b/udmf/framework/ndkimpl/unittest/utd_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c723018537c364ffa9491360aba3fde692116c5e
--- /dev/null
+++ b/udmf/framework/ndkimpl/unittest/utd_test.cpp
@@ -0,0 +1,588 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "UtdTest"
+
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include <map>
+
+#include "token_setproc.h"
+#include "accesstoken_kit.h"
+#include "nativetoken_kit.h"
+
+#include "logger.h"
+#include "utd.h"
+#include "udmf_capi_common.h"
+#include "udmf_meta.h"
+
+using namespace testing::ext;
+using namespace OHOS::Security::AccessToken;
+using namespace OHOS::UDMF;
+using namespace OHOS;
+
+constexpr const char *REFERENCE_URL = "https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/"\
+                                      "apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype";
+
+namespace OHOS::Test {
+
+OH_Utd* utd = nullptr;
+
+class UtdTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void UtdTest::SetUpTestCase(void) {}
+
+void UtdTest::TearDownTestCase(void) {}
+
+void UtdTest::SetUp(void)
+{
+    LOG_INFO(UDMF_TEST, "test case will be start");
+    utd = OH_Utd_Create(UDMF_META_PLAIN_TEXT);
+}
+
+void UtdTest::TearDown(void)
+{
+    OH_Utd_Destroy(utd);
+    utd = nullptr;
+    LOG_INFO(UDMF_TEST, "test case is complete");
+}
+
+/**
+ * @tc.name: OH_Utd_Create_001
+ * @tc.desc: Normal testcase of OH_Utd_Create
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_Create_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_Create_001 begin.");
+    EXPECT_EQ(utd->typeId, UDMF_META_PLAIN_TEXT);
+    EXPECT_EQ(utd->belongingToTypesCount, 1);
+    std::string belongingToType((utd->belongingToTypes)[0]);
+    EXPECT_EQ(belongingToType, UDMF_META_TEXT);
+    EXPECT_EQ(utd->description, "Text of unspecified encoding, with no markup.");
+
+    char* typeId = nullptr;
+    OH_Utd* utdNullptr = OH_Utd_Create(typeId);
+    EXPECT_EQ(nullptr, utdNullptr);
+    LOG_INFO(UDMF_TEST, "OH_Utd_Create_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetTypeId_001
+ * @tc.desc: Normal testcase of OH_Utd_GetTypeId
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetTypeId_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypeId_001 begin.");
+    std::string actualTypeId(OH_Utd_GetTypeId(utd));
+    EXPECT_EQ(UDMF_META_PLAIN_TEXT, actualTypeId);
+
+    OH_Utd* utdNullptr = nullptr;
+    const char* typeIdNullptr = OH_Utd_GetTypeId(utdNullptr);
+    EXPECT_EQ(nullptr, typeIdNullptr);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypeId_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetDescription_001
+ * @tc.desc: Normal testcase of OH_Utd_GetDescription
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetDescription_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetDescription_001 begin.");
+    std::string description(OH_Utd_GetDescription(utd));
+    EXPECT_EQ("Text of unspecified encoding, with no markup.", description);
+
+    OH_Utd* utdNullptr = nullptr;
+    const char* descriptionNullptr = OH_Utd_GetDescription(utdNullptr);
+    EXPECT_EQ(nullptr, descriptionNullptr);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetDescription_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetReferenceUrl_001
+ * @tc.desc: Normal testcase of OH_Utd_GetReferenceUrl
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetReferenceUrl_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetReferenceUrl_001 begin.");
+    std::string url(OH_Utd_GetReferenceUrl(utd));
+    EXPECT_EQ(REFERENCE_URL, url);
+
+    OH_Utd* utdNullptr = nullptr;
+    const char* urlNullptr = OH_Utd_GetReferenceUrl(utdNullptr);
+    EXPECT_EQ(nullptr, urlNullptr);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetReferenceUrl_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetIconFile_001
+ * @tc.desc: Normal testcase of OH_Utd_GetIconFile
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetIconFile_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetIconFile_001 begin.");
+    std::string iconFile(OH_Utd_GetIconFile(utd));
+    EXPECT_EQ("sys.media.ohos_ic_normal_white_grid_txt", iconFile);
+
+    OH_Utd* utdNullptr = nullptr;
+    const char* iconFileNullptr = OH_Utd_GetIconFile(utdNullptr);
+    EXPECT_EQ(nullptr, iconFileNullptr);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetIconFile_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetBelongingToTypes_001
+ * @tc.desc: Normal testcase of OH_Utd_GetBelongingToTypes
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetBelongingToTypes_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetBelongingToTypes_001 begin.");
+    unsigned int count = 0;
+    auto belongingToTypes = OH_Utd_GetBelongingToTypes(utd, &count);
+    std::string belongingToType(belongingToTypes[0]);
+    EXPECT_EQ(UDMF_META_TEXT, belongingToType);
+    EXPECT_EQ(1, count);
+
+    OH_Utd* utdNullptr = nullptr;
+    auto belongingToTypeNullptr = OH_Utd_GetBelongingToTypes(utdNullptr, &count);
+    EXPECT_EQ(nullptr, belongingToTypeNullptr);
+
+    unsigned int* countNullptr = nullptr;
+    auto belongingToTypeNullptr2 = OH_Utd_GetBelongingToTypes(utd, countNullptr);
+    EXPECT_EQ(nullptr, belongingToTypeNullptr2);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetBelongingToTypes_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetFilenameExtensions_001
+ * @tc.desc: Normal testcase of OH_Utd_GetFilenameExtensions
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetFilenameExtensions_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetFilenameExtensions_001 begin.");
+    unsigned int count = 0;
+    auto filenameExtensions = OH_Utd_GetFilenameExtensions(utd, &count);
+    std::string filenameExtension(filenameExtensions[0]);
+    EXPECT_EQ(".txt", filenameExtension);
+    EXPECT_EQ(2, count);
+
+    OH_Utd* utdNullptr = nullptr;
+    auto filenameExtensionsNullptr = OH_Utd_GetFilenameExtensions(utdNullptr, &count);
+    EXPECT_EQ(nullptr, filenameExtensionsNullptr);
+
+    unsigned int* countNullptr = nullptr;
+    auto filenameExtensionsNullptr2 = OH_Utd_GetFilenameExtensions(utd, countNullptr);
+    EXPECT_EQ(nullptr, filenameExtensionsNullptr2);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetFilenameExtensions_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetMimeTypes_001
+ * @tc.desc: Normal testcase of OH_Utd_GetMimeTypes
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetMimeTypes_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetMimeTypes_001 begin.");
+    unsigned int count = 0;
+    auto mimeTypes = OH_Utd_GetMimeTypes(utd, &count);
+    std::string mimeType(mimeTypes[0]);
+    EXPECT_EQ("text/plain", mimeType);
+    EXPECT_EQ(1, count);
+
+    OH_Utd* utdNullptr = nullptr;
+    auto mimeTypeNullptr = OH_Utd_GetMimeTypes(utdNullptr, &count);
+    EXPECT_EQ(nullptr, mimeTypeNullptr);
+
+    unsigned int* countNullptr = nullptr;
+    auto mimeTypeNullptr2 = OH_Utd_GetMimeTypes(utd, countNullptr);
+    EXPECT_EQ(nullptr, mimeTypeNullptr2);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetMimeTypes_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetTypesByFilenameExtension_001
+ * @tc.desc: Normal testcase of OH_Utd_GetTypesByFilenameExtension
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetTypesByFilenameExtension_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByFilenameExtension_001 begin.");
+    unsigned int count = 0;
+    auto typeIds = OH_Utd_GetTypesByFilenameExtension(".txt", &count);
+    std::string typeId(typeIds[0]);
+    EXPECT_EQ(UDMF_META_PLAIN_TEXT, typeId);
+    EXPECT_EQ(1, count);
+    OH_Utd_DestroyStringList(typeIds, count);
+
+    const char* extensionNullptr = nullptr;
+    auto typeIdsNullptr = OH_Utd_GetTypesByFilenameExtension(extensionNullptr, &count);
+    EXPECT_EQ(nullptr, typeIdsNullptr);
+
+    unsigned int* countNullptr = nullptr;
+    typeIds = OH_Utd_GetTypesByFilenameExtension(".txt", countNullptr);
+    EXPECT_EQ(nullptr, typeIds);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByFilenameExtension_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_GetTypesByMimeType_001
+ * @tc.desc: Normal testcase of OH_Utd_GetTypesByMimeType
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_GetTypesByMimeType_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByMimeType_001 begin.");
+    unsigned int count = 0;
+    auto typeIds = OH_Utd_GetTypesByMimeType("text/plain", &count);
+    std::string typeId(typeIds[0]);
+    EXPECT_EQ(UDMF_META_PLAIN_TEXT, typeId);
+    EXPECT_EQ(1, count);
+    OH_Utd_DestroyStringList(typeIds, count);
+
+    const char* extensionNullptr = nullptr;
+    auto typeIdsNullptr = OH_Utd_GetTypesByMimeType(extensionNullptr, &count);
+    EXPECT_EQ(nullptr, typeIdsNullptr);
+
+    unsigned int* countNullptr = nullptr;
+    auto typeIdsNullptr2 = OH_Utd_GetTypesByMimeType("text/plain", countNullptr);
+    EXPECT_EQ(nullptr, typeIdsNullptr2);
+    LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByMimeType_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_BelongsTo_001
+ * @tc.desc: test typeId1 belong to typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_BelongsTo_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_001 begin.");
+    EXPECT_TRUE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, UDMF_META_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_BelongsTo_002
+ * @tc.desc: test typeId1 don't belong to typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_BelongsTo_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_002 begin.");
+    EXPECT_FALSE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, UDMF_META_HTML));
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_002 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_BelongsTo_003
+ * @tc.desc: test param is nullptr
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_BelongsTo_003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_003 begin.");
+    EXPECT_FALSE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, nullptr));
+    EXPECT_FALSE(OH_Utd_BelongsTo(nullptr, UDMF_META_PLAIN_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_003 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsLower_001
+ * @tc.desc: test typeId1 is lower level of typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsLower_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_001 begin.");
+    EXPECT_TRUE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, UDMF_META_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsLower_002
+ * @tc.desc: test typeId1 isn't lower level of typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsLower_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_002 begin.");
+    EXPECT_FALSE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, UDMF_META_HTML));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_002 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsLower_003
+ * @tc.desc: test param is nullptr
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsLower_003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_003 begin.");
+    EXPECT_FALSE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, nullptr));
+    EXPECT_FALSE(OH_Utd_IsLower(nullptr, UDMF_META_PLAIN_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_003 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsHigher_001
+ * @tc.desc: test typeId1 is higher level of typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsHigher_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_001 begin.");
+    EXPECT_TRUE(OH_Utd_IsHigher(UDMF_META_TEXT, UDMF_META_PLAIN_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsHigher_002
+ * @tc.desc: test typeId1 isn't higher level of typeId2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsHigher_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_002 begin.");
+    EXPECT_FALSE(OH_Utd_IsHigher(UDMF_META_PLAIN_TEXT, UDMF_META_HTML));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_002 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_IsHigher_003
+ * @tc.desc: test param is nullptr
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_IsHigher_003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_003 begin.");
+    EXPECT_FALSE(OH_Utd_IsHigher(UDMF_META_PLAIN_TEXT, nullptr));
+    EXPECT_FALSE(OH_Utd_IsHigher(nullptr, UDMF_META_PLAIN_TEXT));
+    LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_003 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_Equals_001
+ * @tc.desc: test case1 is equals case2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_Equals_001, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_001 begin.");
+    auto utd2 = OH_Utd_Create(UDMF_META_PLAIN_TEXT);
+    EXPECT_TRUE(OH_Utd_Equals(utd, utd2));
+    OH_Utd_Destroy(utd2);
+    utd2 = nullptr;
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_001 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_Equals_002
+ * @tc.desc: test case1 is not equals case2
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_Equals_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_002 begin.");
+    auto utd2 = OH_Utd_Create(UDMF_META_TEXT);
+    EXPECT_FALSE(OH_Utd_Equals(utd, utd2));
+    OH_Utd_Destroy(utd2);
+    utd2 = nullptr;
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_002 end.");
+}
+
+/**
+ * @tc.name: OH_Utd_Equals_003
+ * @tc.desc: test param is nullptr
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_Equals_003, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_003 begin.");
+    EXPECT_FALSE(OH_Utd_Equals(utd, nullptr));
+    EXPECT_FALSE(OH_Utd_Equals(nullptr, utd));
+    LOG_INFO(UDMF_TEST, "OH_Utd_Equals_003 end.");
+}
+
+std::map<std::string, std::string> typeIdMap = {
+    {UDMF_META_ENTITY, "general.entity"},
+    {UDMF_META_OBJECT, "general.object"},
+    {UDMF_META_COMPOSITE_OBJECT, "general.composite-object"},
+    {UDMF_META_TEXT, "general.text"},
+    {UDMF_META_PLAIN_TEXT, "general.plain-text"},
+    {UDMF_META_HTML, "general.html"},
+    {UDMF_META_HYPERLINK, "general.hyperlink"},
+    {UDMF_META_XML, "general.xml"},
+    {UDMF_META_SOURCE_CODE, "general.source-code"},
+    {UDMF_META_SCRIPT, "general.script"},
+    {UDMF_META_SHELL_SCRIPT, "general.shell-script"},
+    {UDMF_META_CSH_SCRIPT, "general.csh-script"},
+    {UDMF_META_PERL_SCRIPT, "general.perl-script"},
+    {UDMF_META_PHP_SCRIPT, "general.php-script"},
+    {UDMF_META_PYTHON_SCRIPT, "general.python-script"},
+    {UDMF_META_RUBY_SCRIPT, "general.ruby-script"},
+    {UDMF_META_TYPE_SCRIPT, "general.type-script"},
+    {UDMF_META_JAVA_SCRIPT, "general.java-script"},
+    {UDMF_META_C_HEADER, "general.c-header"},
+    {UDMF_META_C_SOURCE, "general.c-source"},
+    {UDMF_META_C_PLUS_PLUS_HEADER, "general.c-plus-plus-header"},
+    {UDMF_META_C_PLUS_PLUS_SOURCE, "general.c-plus-plus-source"},
+    {UDMF_META_JAVA_SOURCE, "general.java-source"},
+    {UDMF_META_EBOOK, "general.ebook"},
+    {UDMF_META_EPUB, "general.epub"},
+    {UDMF_META_AZW, "com.amazon.azw"},
+    {UDMF_META_AZW3, "com.amazon.azw3"},
+    {UDMF_META_KFX, "com.amazon.kfx"},
+    {UDMF_META_MOBI, "com.amazon.mobi"},
+    {UDMF_META_MEDIA, "general.media"},
+    {UDMF_META_IMAGE, "general.image"},
+    {UDMF_META_JPEG, "general.jpeg"},
+    {UDMF_META_PNG, "general.png"},
+    {UDMF_META_RAW_IMAGE, "general.raw-image"},
+    {UDMF_META_TIFF, "general.tiff"},
+    {UDMF_META_BMP, "com.microsoft.bmp"},
+    {UDMF_META_ICO, "com.microsoft.ico"},
+    {UDMF_META_PHOTOSHOP_IMAGE, "com.adobe.photoshop-image"},
+    {UDMF_META_AI_IMAGE, "com.adobe.illustrator.ai-image"},
+    {UDMF_META_WORD_DOC, "com.microsoft.word.doc"},
+    {UDMF_META_EXCEL, "com.microsoft.excel.xls"},
+    {UDMF_META_PPT, "com.microsoft.powerpoint.ppt"},
+    {UDMF_META_PDF, "com.adobe.pdf"},
+    {UDMF_META_POSTSCRIPT, "com.adobe.postscript"},
+    {UDMF_META_ENCAPSULATED_POSTSCRIPT, "com.adobe.encapsulated-postscript"},
+    {UDMF_META_VIDEO, "general.video"},
+    {UDMF_META_AVI, "general.avi"},
+    {UDMF_META_MPEG, "general.mpeg"},
+    {UDMF_META_MPEG4, "general.mpeg-4"},
+    {UDMF_META_VIDEO_3GPP, "general.3gpp"},
+    {UDMF_META_VIDEO_3GPP2, "general.3gpp2"},
+    {UDMF_META_WINDOWS_MEDIA_WM, "com.microsoft.windows-media-wm"},
+    {UDMF_META_WINDOWS_MEDIA_WMV, "com.microsoft.windows-media-wmv"},
+    {UDMF_META_WINDOWS_MEDIA_WMP, "com.microsoft.windows-media-wmp"},
+    {UDMF_META_AUDIO, "general.audio"},
+    {UDMF_META_AAC, "general.aac"},
+    {UDMF_META_AIFF, "general.aiff"},
+    {UDMF_META_ALAC, "general.alac"},
+    {UDMF_META_FLAC, "general.flac"},
+    {UDMF_META_MP3, "general.mp3"},
+    {UDMF_META_OGG, "general.ogg"},
+    {UDMF_META_PCM, "general.pcm"},
+    {UDMF_META_WINDOWS_MEDIA_WMA, "com.microsoft.windows-media-wma"},
+    {UDMF_META_WAVEFORM_AUDIO, "com.microsoft.waveform-audio"},
+    {UDMF_META_WINDOWS_MEDIA_WMX, "com.microsoft.windows-media-wmx"},
+    {UDMF_META_WINDOWS_MEDIA_WVX, "com.microsoft.windows-media-wvx"},
+    {UDMF_META_WINDOWS_MEDIA_WAX, "com.microsoft.windows-media-wax"},
+    {UDMF_META_GENERAL_FILE, "general.file"},
+    {UDMF_META_DIRECTORY, "general.directory"},
+    {UDMF_META_FOLDER, "general.folder"},
+    {UDMF_META_SYMLINK, "general.symlink"},
+    {UDMF_META_ARCHIVE, "general.archive"},
+    {UDMF_META_BZ2_ARCHIVE, "general.bz2-archive"},
+    {UDMF_META_DISK_IMAGE, "general.disk-image"},
+    {UDMF_META_TAR_ARCHIVE, "general.tar-archive"},
+    {UDMF_META_ZIP_ARCHIVE, "general.zip-archive"},
+    {UDMF_META_JAVA_ARCHIVE, "com.sun.java-archive"},
+    {UDMF_META_GNU_TAR_ARCHIVE, "org.gnu.gnu-tar-archive"},
+    {UDMF_META_GNU_ZIP_ARCHIVE, "org.gnu.gnu-zip-archive"},
+    {UDMF_META_GNU_ZIP_TAR_ARCHIVE, "org.gnu.gnu-zip-tar-archive"},
+    {UDMF_META_CALENDAR, "general.calendar"},
+    {UDMF_META_CONTACT, "general.contact"},
+    {UDMF_META_DATABASE, "general.database"},
+    {UDMF_META_MESSAGE, "general.message"},
+    {UDMF_META_VCARD, "general.vcard"},
+    {UDMF_META_NAVIGATION, "general.navigation"},
+    {UDMF_META_LOCATION, "general.location"},
+    {UDMF_META_OPENHARMONY_FORM, "openharmony.form"},
+    {UDMF_META_OPENHARMONY_APP_ITEM, "openharmony.app-item"},
+    {UDMF_META_OPENHARMONY_PIXEL_MAP, "openharmony.pixel-map"},
+    {UDMF_META_OPENHARMONY_ATOMIC_SERVICE, "openharmony.atomic-service"},
+    {UDMF_META_OPENHARMONY_PACKAGE, "openharmony.package"},
+    {UDMF_META_OPENHARMONY_HAP, "openharmony.hap"},
+    {UDMF_META_SMIL, "com.real.smil"},
+    {UDMF_META_MARKDOWN, "general.markdown"},
+    {UDMF_META_FAX, "general.fax"},
+    {UDMF_META_JFX_FAX, "com.j2.jfx-fax"},
+    {UDMF_META_EFX_FAX, "com.js.efx-fax"},
+    {UDMF_META_XBITMAP_IMAGE, "general.xbitmap-image"},
+    {UDMF_META_TGA_IMAGE, "com.truevision.tga-image"},
+    {UDMF_META_SGI_IMAGE, "com.sgi.sgi-image"},
+    {UDMF_META_OPENEXR_IMAGE, "com.ilm.openexr-image"},
+    {UDMF_META_FLASHPIX_IMAGE, "com.kodak.flashpix.image"},
+    {UDMF_META_REALMEDIA, "com.real.realmedia"},
+    {UDMF_META_AU_AUDIO, "general.au-audio"},
+    {UDMF_META_AIFC_AUDIO, "general.aifc-audio"},
+    {UDMF_META_SD2_AUDIO, "com.digidesign.sd2-audio"},
+    {UDMF_META_REALAUDIO, "com.real.realaudio"},
+    {UDMF_META_OPENXML, "org.openxmlformats.openxml"},
+    {UDMF_META_WORDPROCESSINGML_DOCUMENT, "org.openxmlformats.wordprocessingml.document"},
+    {UDMF_META_SPREADSHEETML_SHEET, "org.openxmlformats.spreadsheetml.sheet"},
+    {UDMF_META_PRESENTATIONML_PRESENTATION, "org.openxmlformats.presentationml.presentation"},
+    {UDMF_META_OPENDOCUMENT, "org.oasis.opendocument"},
+    {UDMF_META_OPENDOCUMENT_TEXT, "org.oasis.opendocument.text"},
+    {UDMF_META_OPENDOCUMENT_SPREADSHEET, "org.oasis.opendocument.spreadsheet"},
+    {UDMF_META_OPENDOCUMENT_PRESENTATION, "org.oasis.opendocument.presentation"},
+    {UDMF_META_OPENDOCUMENT_GRAPHICS, "org.oasis.opendocument.graphics"},
+    {UDMF_META_OPENDOCUMENT_FORMULA, "org.oasis.opendocument.formula"},
+    {UDMF_META_STUFFIT_ARCHIVE, "com.allume.stuffit-archive"},
+    {UDMF_META_VCS, "general.vcs"},
+    {UDMF_META_ICS, "general.ics"},
+    {UDMF_META_EXECUTABLE, "general.executable"},
+    {UDMF_META_PORTABLE_EXECUTABLE, "com.microsoft.portable-executable"},
+    {UDMF_META_SUN_JAVA_CLASS, "com.sun.java-class"},
+    {UDMF_META_FONT, "general.font"},
+    {UDMF_META_TRUETYPE_FONT, "general.truetype-font"},
+    {UDMF_META_TRUETYPE_COLLECTION_FONT, "general.truetype-collection-font"},
+    {UDMF_META_OPENTYPE_FONT, "general.opentype-font"},
+    {UDMF_META_POSTSCRIPT_FONT, "com.adobe.postscript-font"},
+    {UDMF_META_POSTSCRIPT_PFB_FONT, "com.adobe.postscript-pfb-font"},
+    {UDMF_META_POSTSCRIPT_PFA_FONT, "com.adobe.postscript-pfa-font"},
+    {UDMF_META_OPENHARMONY_HDOC, "openharmony.hdoc"},
+    {UDMF_META_OPENHARMONY_HINOTE, "openharmony.hinote"},
+    {UDMF_META_OPENHARMONY_STYLED_STRING, "openharmony.styled-string"},
+    {UDMF_META_OPENHARMONY_WANT, "openharmony.want"}
+};
+
+/**
+ * @tc.name: OH_Utd_Create_002
+ * @tc.desc: traverse enum for UTD
+ * @tc.type: FUNC
+ */
+HWTEST_F(UtdTest, OH_Utd_Create_002, TestSize.Level1)
+{
+    LOG_INFO(UDMF_TEST, "OH_Utd_Create_002 begin.");
+    OH_Utd* utd1;
+    for (const auto& pair : typeIdMap) {
+        utd1 = OH_Utd_Create(pair.first.c_str());
+        std::string typeId(OH_Utd_GetTypeId(utd1));
+        EXPECT_EQ(pair.second, typeId);
+        OH_Utd_Destroy(utd1);
+    }
+    LOG_INFO(UDMF_TEST, "OH_Utd_Create_002 end.");
+}
+
+}
diff --git a/udmf/interfaces/innerkits/BUILD.gn b/udmf/interfaces/innerkits/BUILD.gn
index 182d20c3090f06c6f09a168dbe974f9127304c42..fba7873d763104996a7a0e8244525094f6fa0bde 100644
--- a/udmf/interfaces/innerkits/BUILD.gn
+++ b/udmf/interfaces/innerkits/BUILD.gn
@@ -18,9 +18,14 @@ config("udmf_client_config") {
     "${udmf_interfaces_path}/innerkits/client",
     "${udmf_interfaces_path}/innerkits/common",
     "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_interfaces_path}/innerkits/convert",
+    "${udmf_interfaces_path}/ndk/data",
     "${udmf_framework_path}/common",
+    "${udmf_framework_path}/innerkitsimpl/client",
     "${udmf_framework_path}/innerkitsimpl/data",
     "${udmf_framework_path}/innerkitsimpl/service",
+    "${udmf_framework_path}/innerkitsimpl/convert",
+    "${udmf_framework_path}/ndkimpl/data",
     "${kv_store_path}/frameworks/common",
     "//third_party/libuv/include",
     "//third_party/node/src",
@@ -43,36 +48,31 @@ ohos_shared_library("udmf_client") {
     debug = false
   }
   sources = [
-    "${udmf_framework_path}/common/base32_utils.cpp",
-    "${udmf_framework_path}/common/custom_utd_json_parser.cpp",
-    "${udmf_framework_path}/common/custom_utd_store.cpp",
-    "${udmf_framework_path}/common/graph.cpp",
+    "${udmf_framework_path}/common/endian_converter.cpp",
     "${udmf_framework_path}/common/tlv_object.cpp",
     "${udmf_framework_path}/common/tlv_util.cpp",
+    "${udmf_framework_path}/common/udmf_radar_reporter.cpp",
     "${udmf_framework_path}/common/udmf_types_util.cpp",
     "${udmf_framework_path}/common/udmf_utils.cpp",
-    "${udmf_framework_path}/common/utd_cfgs_checker.cpp",
-    "${udmf_framework_path}/common/utd_graph.cpp",
+    "${udmf_framework_path}/innerkitsimpl/client/async_obtain_data.cpp",
+    "${udmf_framework_path}/innerkitsimpl/client/getter_system.cpp",
     "${udmf_framework_path}/innerkitsimpl/client/udmf_client.cpp",
-    "${udmf_framework_path}/innerkitsimpl/client/utd_client.cpp",
     "${udmf_framework_path}/innerkitsimpl/common/unified_key.cpp",
     "${udmf_framework_path}/innerkitsimpl/common/unified_meta.cpp",
+    "${udmf_framework_path}/innerkitsimpl/convert/ndk_data_conversion.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/application_defined_record.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/audio.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/file.cpp",
-    "${udmf_framework_path}/innerkitsimpl/data/flexible_type.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/folder.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/html.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/image.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/link.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/plain_text.cpp",
-    "${udmf_framework_path}/innerkitsimpl/data/preset_type_descriptors.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/system_defined_appitem.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/system_defined_form.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/system_defined_pixelmap.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/system_defined_record.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/text.cpp",
-    "${udmf_framework_path}/innerkitsimpl/data/type_descriptor.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/unified_data.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/unified_data_helper.cpp",
     "${udmf_framework_path}/innerkitsimpl/data/unified_record.cpp",
@@ -84,7 +84,6 @@ ohos_shared_library("udmf_client") {
   public_configs = [ ":udmf_client_config" ]
 
   external_deps = [
-    "ability_base:want",
     "ability_base:zuri",
     "access_token:libaccesstoken_sdk",
     "app_file_service:fileuri_native",
@@ -95,14 +94,18 @@ ohos_shared_library("udmf_client") {
     "hisysevent:libhisysevent",
     "hitrace:hitrace_meter",
     "hitrace:libhitracechain",
-    "image_framework:image",
+    "image_framework:image_native",
     "ipc:ipc_core",
     "kv_store:distributeddata_inner",
     "kv_store:distributeddata_mgr",
     "samgr:samgr_proxy",
   ]
 
-  public_external_deps = [ "cJSON:cjson" ]
+  public_external_deps = [
+    "ability_base:want",
+    "cJSON:cjson",
+    "image_framework:image",
+  ]
 
   innerapi_tags = [ "platformsdk" ]
   subsystem_name = "distributeddatamgr"
@@ -110,10 +113,6 @@ ohos_shared_library("udmf_client") {
   part_name = "udmf"
   use_exceptions = true
   cflags_cc = [ "-fvisibility=hidden" ]
-  if (build_selinux) {
-    cflags = [ "-DWITH_SELINUX" ]
-    external_deps += [ "selinux_adapter:librestorecon" ]
-  }
 }
 
 config("utd_client_config") {
@@ -134,13 +133,6 @@ ohos_shared_library("utd_client") {
     cfi_cross_dso = true
     debug = false
   }
-  include_dirs = [
-    "${udmf_interfaces_path}/innerkits/client",
-    "${udmf_interfaces_path}/innerkits/common",
-    "${udmf_interfaces_path}/innerkits/data",
-    "${udmf_framework_path}/common",
-    "${udmf_framework_path}/innerkitsimpl/data",
-  ]
 
   sources = [
     "${udmf_framework_path}/common/base32_utils.cpp",
@@ -159,9 +151,13 @@ ohos_shared_library("utd_client") {
   public_configs = [ ":utd_client_config" ]
 
   external_deps = [
+    "access_token:libaccesstoken_sdk",
     "cJSON:cjson",
     "c_utils:utils",
+    "common_event_service:cesfwk_innerkits",
     "hilog:libhilog",
+    "ipc:ipc_core",
+    "os_account:os_account_innerkits",
   ]
 
   public_external_deps = [ "cJSON:cjson" ]
@@ -171,4 +167,8 @@ ohos_shared_library("utd_client") {
 
   part_name = "udmf"
   cflags_cc = [ "-fvisibility=hidden" ]
+  if (build_selinux) {
+    cflags = [ "-DWITH_SELINUX" ]
+    external_deps += [ "selinux_adapter:librestorecon" ]
+  }
 }
diff --git a/udmf/interfaces/innerkits/client/entry_getter.h b/udmf/interfaces/innerkits/client/entry_getter.h
new file mode 100644
index 0000000000000000000000000000000000000000..d68456b482a1a442d9b6614fa02b8d93973fb320
--- /dev/null
+++ b/udmf/interfaces/innerkits/client/entry_getter.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_ENTRY_GETTER_H
+#define UDMF_ENTRY_GETTER_H
+
+#include "unified_meta.h"
+
+namespace OHOS {
+namespace UDMF {
+class EntryGetter {
+public:
+    EntryGetter() = default;
+    virtual ~EntryGetter() = default;
+
+    virtual ValueType GetValueByType(const std::string &utdId) = 0;
+};
+} // namespace UDMF
+} // namespace OHOS
+#endif // UDMF_ENTRY_GETTER_H
\ No newline at end of file
diff --git a/udmf/interfaces/innerkits/client/getter_system.h b/udmf/interfaces/innerkits/client/getter_system.h
new file mode 100644
index 0000000000000000000000000000000000000000..41b674a030bee3c0c2ab44746c698df6599a0f58
--- /dev/null
+++ b/udmf/interfaces/innerkits/client/getter_system.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_GETTER_SYSTEM_H
+#define UDMF_GETTER_SYSTEM_H
+
+#include "concurrent_map.h"
+#include "unified_meta.h"
+#include "visibility.h"
+
+namespace OHOS {
+namespace UDMF {
+class API_EXPORT GetterSystem {
+public:
+    class API_EXPORT GeneralGetter {
+    public:
+        virtual ~GeneralGetter();
+        virtual ValueType GetValueByType(uint32_t dataId, uint32_t recordId, const std::string &utdId);
+    };
+    using Creator = std::function<std::shared_ptr<GeneralGetter>()>;
+    using Getter = std::shared_ptr<GeneralGetter>;
+    static GetterSystem &GetInstance();
+    void RegisterCreator(const std::string& name, Creator creator);
+    Getter GetGetter(const std::string& name);
+private:
+    GetterSystem() = default;
+    GetterSystem(const GetterSystem &) = delete;
+    GetterSystem(GetterSystem &&) noexcept = delete;
+    GetterSystem &operator=(const GetterSystem &) = delete;
+    GetterSystem &operator=(GetterSystem &&) = delete;
+    ConcurrentMap<std::string, Creator> creators_;
+};
+} // namespace UDMF
+} // namespace OHOS
+#endif // UDMF_GETTER_SYSTEM_H
\ No newline at end of file
diff --git a/udmf/interfaces/innerkits/client/udmf_client.h b/udmf/interfaces/innerkits/client/udmf_client.h
index a865169cf5e8d19cd0fdad5d569b4f4ec7e1832d..1d2608cc82ac05f0c485624de99739e5e24754bc 100644
--- a/udmf/interfaces/innerkits/client/udmf_client.h
+++ b/udmf/interfaces/innerkits/client/udmf_client.h
@@ -28,6 +28,7 @@
 #include "unified_meta.h"
 #include "unified_types.h"
 #include "visibility.h"
+#include "async_obtain_data.h"
 namespace OHOS {
 namespace UDMF {
 class API_EXPORT UdmfClient {
@@ -36,6 +37,7 @@ public:
 
     Status SetData(CustomOption &option, UnifiedData &unifiedData, std::string &key);
     Status GetData(const QueryOption &query, UnifiedData &unifiedData);
+    Status GetDataAsync(const QueryOption &query, ObtainDataCallback callback);
     Status GetBatchData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet);
     Status UpdateData(const QueryOption &query, UnifiedData &unifiedData);
     Status DeleteData(const QueryOption &query, std::vector<UnifiedData> &unifiedDataSet);
@@ -55,6 +57,7 @@ private:
     std::string GetSelfBundleName();
 
     ConcurrentMap<std::string, UnifiedData> dataCache_;
+    AsyncObtainData asyncObtainData_;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/client/utd_client.h b/udmf/interfaces/innerkits/client/utd_client.h
index 2b97902524f6d6c355dfb098ed8354a6f8ce0a22..4a0115b1c9fdedca67822c237829a40d4ae75bc4 100644
--- a/udmf/interfaces/innerkits/client/utd_client.h
+++ b/udmf/interfaces/innerkits/client/utd_client.h
@@ -16,6 +16,7 @@
 #ifndef UTD_CLIENT_H
 #define UTD_CLIENT_H
 
+#include <shared_mutex>
 #include <string>
 #include <vector>
 #include <map>
@@ -29,14 +30,19 @@
 namespace OHOS {
 namespace UDMF {
 class TypeDescriptor;
+class UtdChangeSubscriber;
 class API_EXPORT UtdClient {
 public:
     static UtdClient &GetInstance();
     Status GetTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor);
     Status GetUniformDataTypeByFilenameExtension(const std::string &fileExtension, std::string &typeId,
                                                  std::string belongsTo = DEFAULT_TYPE_ID);
+    Status GetUniformDataTypesByFilenameExtension(const std::string &fileExtension,
+                    std::vector<std::string> &typeIds, const std::string &belongsTo = DEFAULT_TYPE_ID);
     Status GetUniformDataTypeByMIMEType(const std::string &mimeType, std::string &typeId,
                                         std::string belongsTo = DEFAULT_TYPE_ID);
+    Status GetUniformDataTypesByMIMEType(const std::string &mimeType, std::vector<std::string> &typeIds,
+                                        const std::string &belongsTo = DEFAULT_TYPE_ID);
     Status IsUtd(std::string typeId, bool &result);
 
 private:
@@ -45,10 +51,19 @@ private:
     UtdClient(const UtdClient &obj) = delete;
     UtdClient &operator=(const UtdClient &obj) = delete;
     void Init();
+    bool IsHapTokenType();
+    std::string GetCustomUtdPath();
+    Status GetCurrentActiveUserId(int32_t& userId);
     bool IsValidFileExtension(const std::string &fileExtension);
     bool IsValidMimeType(const std::string &mimeType);
     Status GetFlexibleTypeDescriptor(const std::string &typeId, std::shared_ptr<TypeDescriptor> &descriptor);
+    std::string GetTypeIdFromCfg(const std::string &mimeType);
+    std::vector<std::string> GetTypeIdsFromCfg(const std::string &mimeType);
+    void SubscribeUtdChange();
+
     std::vector<TypeDescriptorCfg> descriptorCfgs_;
+    std::shared_ptr<UtdChangeSubscriber> subscriber_;
+    std::shared_mutex utdMutex_;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/common/error_code.h b/udmf/interfaces/innerkits/common/error_code.h
index 22929142a7db95b52da3ee1f8332ae29a8d38917..6fdc06ef11ecfe1f09fe12fdb85474c5fd0be065 100644
--- a/udmf/interfaces/innerkits/common/error_code.h
+++ b/udmf/interfaces/innerkits/common/error_code.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -18,8 +18,9 @@
 
 #include <cstdint>
 #include <errors.h>
-#include <unordered_map>
+#include <map>
 #include <string>
+#include <unordered_map>
 
 namespace OHOS {
 namespace UDMF {
diff --git a/udmf/interfaces/innerkits/common/unified_meta.h b/udmf/interfaces/innerkits/common/unified_meta.h
index 07825b2fc2ee25bca8a59cd25726174e99a535b1..1a3fc65ec07d0612011178aa602c5793adcee12d 100644
--- a/udmf/interfaces/innerkits/common/unified_meta.h
+++ b/udmf/interfaces/innerkits/common/unified_meta.h
@@ -25,10 +25,33 @@
 #include <variant>
 #include <vector>
 #include "visibility.h"
+#include "pixel_map.h"
 #include "string_ex.h"
+#include "want.h"
 
 namespace OHOS {
 namespace UDMF {
+constexpr const char* UNIFORM_DATA_TYPE = "uniformDataType";
+constexpr const char* CONTENT = "content";
+constexpr const char* ABSTRACT = "abstract";
+constexpr const char* URL = "url";
+constexpr const char* DESCRIPTION = "description";
+constexpr const char* HTML_CONTENT = "htmlContent";
+constexpr const char* PLAIN_CONTENT = "plainContent";
+constexpr const char* APP_ID = "appId";
+constexpr const char* APP_NAME = "appName";
+constexpr const char* APP_ICON_ID = "appIconId";
+constexpr const char* APP_LABEL_ID = "appLabelId";
+constexpr const char* BUNDLE_NAME = "bundleName";
+constexpr const char* ABILITY_NAME = "abilityName";
+constexpr const char* FILE_URI_PARAM = "fileUri";
+constexpr const char* FILE_TYPE = "fileType";
+constexpr const char* PIXEL_MAP = "pixelMap";
+constexpr const char* APPLICATION_DEFINED_TYPE = "ApplicationDefined";
+constexpr const char* ARRAY_BUFFER = "arrayBuffer";
+constexpr const char* ARRAY_BUFFER_LENGTH = "arrayBufferLen";
+
+
 enum UDType : int32_t {
     ENTITY = 0,
     OBJECT,
@@ -408,13 +431,47 @@ enum UDType : int32_t {
     MICROSOFT_EMAIL,
     MICROSOFT_MESSAGE,
     MICROSOFT_PST,
-    KINSOFT_OFFICE,
-    KINSOFT_WRITER_WPS,
-    KINSOFT_WRITER_WPT,
-    KINSOFT_PRESENTATION_DPS,
-    KINSOFT_PRESENTATION_TEMPLATE,
-    KINSOFT_SPREADSHEETS_ET,
-    KINSOFT_SPREADSHEETS_TEMPLATE,
+    KINGSOFT_OFFICE,
+    KINGSOFT_WRITER_WPS,
+    KINGSOFT_WRITER_WPT,
+    KINGSOFT_PRESENTATION_DPS,
+    KINGSOFT_PRESENTATION_TEMPLATE,
+    KINGSOFT_SPREADSHEETS_ET,
+    KINGSOFT_SPREADSHEETS_TEMPLATE,
+    MICROSOFT_INI,
+    JSON,
+    YAML,
+    LOG,
+    URI,
+    FILE_URI,
+    TEXT_LST,
+    ANDROID_APK,
+    BZ_ARCHIVE,
+    TBZ_ARCHIVE,
+    TBZ2_ARCHIVE,
+    XZ_ARCHIVE,
+    TXZ_ARCHIVE,
+    XAR_ARCHIVE,
+    CAB_ARCHIVE,
+    RPM_ARCHIVE,
+    TPZ_ARCHIVE,
+    LZA_ARCHIVE,
+    ARJ_ARCHIVE,
+    ZIPX_ARCHIVE,
+    LZMA_ARCHIVE,
+    LZMA86_ARCHIVE,
+    XPI_ARCHIVE,
+    HFS_DISK_IMAGE,
+    IMG_DISK_IMAGE,
+    ISZ_DISK_IMAGE,
+    WIM_DISK_IMAGE,
+    SWM_DISK_IMAGE,
+    KINGSOFT_SPREADSHEETS_ETX,
+    KINGSOFT_SPREADSHEETS_ETTX,
+    EXCEL_DIF,
+    OPENHARMONY_APP,
+    HMOS_WIFI,
+    TEL,
     UD_BUTT
 };
 
@@ -488,6 +545,38 @@ public:
     static Intention GetIntentionByString(const std::string &intention);
     static bool IsValidOptions(const std::string &key, std::string &intention);
 };
+
+struct Object;
+using ValueType = std::variant<std::monostate, int32_t, int64_t, double, bool, std::string, std::vector<uint8_t>,
+    std::shared_ptr<OHOS::AAFwk::Want>, std::shared_ptr<OHOS::Media::PixelMap>, std::shared_ptr<Object>, nullptr_t>;
+
+struct API_EXPORT Object {
+    bool GetValue(const std::string &key, std::string &value);
+    bool GetValue(const std::string &key, std::shared_ptr<Object> &value);
+
+    std::map<std::string, ValueType> value_;
+};
+
+namespace ObjectUtils {
+    std::shared_ptr<Object> ConvertToObject(UDDetails &details);
+    UDDetails ConvertToUDDetails(std::shared_ptr<Object> object);
+
+    template<typename T, typename... Types>
+    bool ConvertVariant(T &&input, std::variant<Types...> &output)
+    {
+        bool converted = false;
+        std::visit(
+            [&output, &converted](auto &&val) {
+              using BasicType = std::decay_t<decltype(val)>;
+              if constexpr ((std::is_same_v<BasicType, Types> || ...)) {
+                output = std::variant<Types...>(std::move(val));
+                converted = true;
+              }
+            },
+            input);
+        return converted;
+    }
+} // namespace ObjectUtils
 } // namespace UDMF
 } // namespace OHOS
 #endif // UNIFIED_META_H
diff --git a/udmf/interfaces/innerkits/common/unified_types.h b/udmf/interfaces/innerkits/common/unified_types.h
index 397872e6bd3c5d651d088ece761204105c3b6041..c01cf89dad6bca9f9f6a90a2f3485e0258b57a26 100644
--- a/udmf/interfaces/innerkits/common/unified_types.h
+++ b/udmf/interfaces/innerkits/common/unified_types.h
@@ -80,6 +80,30 @@ struct QueryOption {
     Intention intention {};
     uint32_t  tokenId {};
 };
+
+enum AsyncTaskStatus : uint32_t {
+    ASYNC_IDLE = 0,
+    ASYNC_RUNNING,
+    ASYNC_SUCCESS,
+    ASYNC_FAILURE,
+};
+
+struct AsyncProcessInfo {
+    AsyncTaskStatus syncStatus;
+    AsyncTaskStatus permStatus;
+    std::string srcDevName;
+    uint32_t syncFinished;
+    uint32_t syncTotal;
+    uint32_t syncId;
+    uint32_t permFnished;
+    uint32_t permTotal;
+};
+
+struct ProgressInfo {
+    std::string srcDevName;
+    AsyncTaskStatus status;
+    uint32_t progress;
+};
 } // namespace UDMF
 } // namespace OHOS
 #endif // UDMF_UNIFIED_TYPES_H
\ No newline at end of file
diff --git a/udmf/interfaces/innerkits/convert/ndk_data_conversion.h b/udmf/interfaces/innerkits/convert/ndk_data_conversion.h
new file mode 100644
index 0000000000000000000000000000000000000000..28fadf7d7a090a3331b3222e776eed1470a44ca9
--- /dev/null
+++ b/udmf/interfaces/innerkits/convert/ndk_data_conversion.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UDMF_DATA_CONVERSION_H
+#define UDMF_DATA_CONVERSION_H
+
+#include "unified_data.h"
+#include "error_code.h"
+
+struct OH_UdmfData;
+namespace OHOS::UDMF {
+class API_EXPORT NdkDataConversion {
+public:
+    static Status GetNativeUnifiedData(OH_UdmfData* ndkData, std::shared_ptr<UnifiedData>& data);
+    static Status GetNdkUnifiedData(std::shared_ptr<UnifiedData> data, OH_UdmfData* ndkData);
+};
+}
+
+#endif // UDMF_DATA_CONVERSION_H
\ No newline at end of file
diff --git a/udmf/interfaces/innerkits/data/flexible_type.h b/udmf/interfaces/innerkits/data/flexible_type.h
index bebbd09f729a47dccdab42f35f67616ba63c683f..50db59057a2cbcc9f1d0fb01eaca66d54a5f804a 100644
--- a/udmf/interfaces/innerkits/data/flexible_type.h
+++ b/udmf/interfaces/innerkits/data/flexible_type.h
@@ -35,6 +35,8 @@ public:
     static bool ParseFlexibleUtd(const std::string &typeId, TypeDescriptorCfg &flexibleTypeDescriptorCfg);
     static std::string GenFlexibleUtd(const std::string &mimeType, const std::string &fileExtension,
                                      const std::string &belongsTo);
+    static constexpr size_t MAX_TYPE_SIZE = 128;
+    static constexpr size_t ATTRIBUTE_PAIR_SIZE = 2;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/data/html.h b/udmf/interfaces/innerkits/data/html.h
index 5eada1490c4cfd5a02a0a4db6c962e7ea0e6edfb..e6d242789413afd60e64f8d0f63fe5b9b26031b7 100644
--- a/udmf/interfaces/innerkits/data/html.h
+++ b/udmf/interfaces/innerkits/data/html.h
@@ -33,8 +33,13 @@ public:
     void SetHtmlContent(const std::string &htmlContent);
     std::string GetPlainContent() const;
     void SetPlainContent(const std::string &htmlContent);
+    ValueType GetValue() override;
 
+    static bool CheckValue(const ValueType &value);
 private:
+    void InitObject();
+    constexpr static const char *HTML_CONTENT = "htmlContent";
+    constexpr static const char *PLAINT_CONTENT = "plainContent";
     std::string htmlContent_;
     std::string plainContent_;
 };
diff --git a/udmf/interfaces/innerkits/data/link.h b/udmf/interfaces/innerkits/data/link.h
index 5b600a78963c939dbabc1ff8637da125ae7aeb07..75825b46c89c6a315d958e40c105850273db4763 100644
--- a/udmf/interfaces/innerkits/data/link.h
+++ b/udmf/interfaces/innerkits/data/link.h
@@ -34,8 +34,14 @@ public:
     void SetUrl(const std::string &url);
     std::string GetDescription() const;
     void SetDescription(const std::string &description);
+    ValueType GetValue() override;
 
+    static bool CheckValue(const ValueType &value);
 private:
+    void InitObject();
+
+    constexpr static const char *URL = "url";
+    constexpr static const char *DESCRIPTION = "description";
     std::string url_;
     std::string description_;
 };
diff --git a/udmf/interfaces/innerkits/data/plain_text.h b/udmf/interfaces/innerkits/data/plain_text.h
index 274c295e32fbe59e85d67eade2a5b849a275f0de..712cba059eb8341183e52137407e6b60fa05f9a9 100644
--- a/udmf/interfaces/innerkits/data/plain_text.h
+++ b/udmf/interfaces/innerkits/data/plain_text.h
@@ -32,8 +32,13 @@ public:
     void SetContent(const std::string &content);
     std::string GetAbstract() const;
     void SetAbstract(const std::string &abstract);
+    ValueType GetValue() override;
 
+    static bool CheckValue(const ValueType &value);
 private:
+    void InitObject();
+    constexpr static const char *TEXT_CONTENT = "textContent";
+    constexpr static const char *ABSTRACT = "abstract";
     std::string content_;
     std::string abstract_;
 };
diff --git a/udmf/interfaces/innerkits/data/system_defined_appitem.h b/udmf/interfaces/innerkits/data/system_defined_appitem.h
index 3e1f66c07de98657a5b576b46200e540620c8946..fad6498935b81ba299b30876f8755c0f233906d2 100644
--- a/udmf/interfaces/innerkits/data/system_defined_appitem.h
+++ b/udmf/interfaces/innerkits/data/system_defined_appitem.h
@@ -42,8 +42,11 @@ public:
     void SetAbilityName(const std::string &abilityName);
     void SetItems(UDDetails &details);
     UDDetails GetItems();
+    ValueType GetValue() override;
 
+    static bool CheckValue(const ValueType &value);
 private:
+    void InitObject();
     constexpr static const char *APPID = "appId";
     constexpr static const char *APPNAME = "appName";
     constexpr static const char *APPICONID = "appIconId";
diff --git a/udmf/interfaces/innerkits/data/system_defined_pixelmap.h b/udmf/interfaces/innerkits/data/system_defined_pixelmap.h
index 8120c9437807c2192675f616f73c592881df34dc..f505f48aab561a404df01e705576e4d13dd68afe 100644
--- a/udmf/interfaces/innerkits/data/system_defined_pixelmap.h
+++ b/udmf/interfaces/innerkits/data/system_defined_pixelmap.h
@@ -30,8 +30,12 @@ public:
 
     std::vector<uint8_t> GetRawData() const;
     void SetRawData(const std::vector<uint8_t> &rawData);
+
+    ValueType GetValue() override;
 private:
+    void InitObject();
     std::vector<uint8_t> rawData_;
+    bool updateObjectFlag_ = true;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/data/system_defined_record.h b/udmf/interfaces/innerkits/data/system_defined_record.h
index bc0af32623a7cbf028d0844da28b13d35cae423f..7fda2e518d07243ab54e65e9fe971c6001a5a4ee 100644
--- a/udmf/interfaces/innerkits/data/system_defined_record.h
+++ b/udmf/interfaces/innerkits/data/system_defined_record.h
@@ -34,6 +34,8 @@ public:
 
 protected:
     UDDetails details_;
+private:
+    void InitObject();
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/data/text.h b/udmf/interfaces/innerkits/data/text.h
index b7bd9446ab2bb192875f6e48ca6ec11604d1fb6c..3f0854ba9e6ffaa7d7b481f52487d0131a309d1f 100644
--- a/udmf/interfaces/innerkits/data/text.h
+++ b/udmf/interfaces/innerkits/data/text.h
@@ -34,6 +34,8 @@ public:
 
 protected:
     UDDetails details_;
+private:
+    void InitObject();
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/data/unified_data.h b/udmf/interfaces/innerkits/data/unified_data.h
index ad8cf2bd949ddb99a5fbce6915b5729b58729d5f..eb7a31f834137d98952ece9804940558819da7c0 100644
--- a/udmf/interfaces/innerkits/data/unified_data.h
+++ b/udmf/interfaces/innerkits/data/unified_data.h
@@ -38,10 +38,11 @@ public:
     void SetRecords(std::vector<std::shared_ptr<UnifiedRecord>> records);
     std::vector<std::shared_ptr<UnifiedRecord>> GetRecords() const;
 
-    std::vector<UDType> GetUDTypes() const;
     std::string GetTypes();
     std::vector<std::string> GetTypesLabels() const;
     bool HasType(const std::string &type) const;
+    std::vector<std::string> GetEntriesTypes() const;
+    bool HasTypeInEntries(const std::string &type) const;
 
     bool IsEmpty() const;
     bool IsValid();
@@ -50,9 +51,16 @@ public:
     void SetProperties(std::shared_ptr<UnifiedDataProperties> properties);
     std::shared_ptr<UnifiedDataProperties> GetProperties() const;
 
+    void SetDataId(uint32_t dataId);
+    uint32_t GetDataId() const;
+    void SetChannelName(const std::string &name);
+
     static constexpr int64_t MAX_DATA_SIZE = 200 * 1024 * 1024;
 
 private:
+    uint32_t dataId_ = 0;
+    uint32_t recordId_ = 0;
+    std::string channelName_;
     std::shared_ptr<Runtime> runtime_;
     std::vector<std::shared_ptr<UnifiedRecord>> records_;
     std::shared_ptr<UnifiedDataProperties> properties_;
diff --git a/udmf/interfaces/innerkits/data/unified_data_properties.h b/udmf/interfaces/innerkits/data/unified_data_properties.h
index 2cfad4fb0636a050c40084f16c9419150bd9ea36..93e7dc5ca41ca630f84692e81307bfa35f64fe36 100644
--- a/udmf/interfaces/innerkits/data/unified_data_properties.h
+++ b/udmf/interfaces/innerkits/data/unified_data_properties.h
@@ -26,6 +26,7 @@ public:
     AAFwk::WantParams extras;
     ShareOptions shareOptions = CROSS_APP;
     std::int64_t timestamp;
+    bool isRemote;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/innerkits/data/unified_record.h b/udmf/interfaces/innerkits/data/unified_record.h
index 706a77cc1632e9532c11465fd88e0bde65264ed3..78387e5f8ee49e691eea64ecce434d37f678b61b 100644
--- a/udmf/interfaces/innerkits/data/unified_record.h
+++ b/udmf/interfaces/innerkits/data/unified_record.h
@@ -18,17 +18,13 @@
 
 #include <memory>
 #include <string>
-#include <variant>
 #include <vector>
+#include "entry_getter.h"
 #include "visibility.h"
-#include "pixel_map.h"
 #include "unified_types.h"
-#include "want.h"
 
 namespace OHOS {
 namespace UDMF {
-using ValueType = std::variant<int32_t, int64_t, double, bool, std::string, std::vector<uint8_t>,
-    std::shared_ptr<OHOS::AAFwk::Want>, std::shared_ptr<OHOS::Media::PixelMap>>;
 class API_EXPORT UnifiedRecord {
 public:
     UnifiedRecord();
@@ -42,13 +38,39 @@ public:
 
     std::string GetUid() const;
     void SetUid(const std::string &id);
-    ValueType GetValue();
+    virtual ValueType GetValue();
+    void SetValue(const ValueType &value);
+    ValueType GetOriginValue();
 
+    void SetUtdId(const std::string &utdId);
+    std::set<std::string> GetUtdIds() const;
+    std::string GetUtdId() const;
+
+    bool HasType(const std::string &utdId) const;
+    void AddEntry(const std::string &utdId, ValueType &&value);
+    ValueType GetEntry(const std::string &utdId);
+    std::shared_ptr<std::map<std::string, ValueType>> GetEntries() const;
+	
+    void SetEntryGetter(const std::set<std::string> &utdIds, const std::shared_ptr<EntryGetter> entryGetter);
+    std::shared_ptr<EntryGetter> GetEntryGetter();
+    void SetDataId(uint32_t dataId);
+    uint32_t GetDataId() const;
+    void SetRecordId(uint32_t recordId);
+    uint32_t GetRecordId() const;
+    void SetChannelName(const std::string &channelName);
 protected:
+    static constexpr const char *UNIFORM_DATA_TYPE = "uniformDataType";
+    static constexpr const char *DETAILS = "details";
     UDType dataType_;
     ValueType value_;
 private:
     std::string uid_; // unique identifier
+    std::string utdId_;
+    std::shared_ptr<std::map<std::string, ValueType>> entries_ = std::make_shared<std::map<std::string, ValueType>>();
+    uint32_t dataId_ = 0;
+    uint32_t recordId_ = 0;
+    std::string channelName_;
+    std::shared_ptr<EntryGetter> entryGetter_;
 };
 } // namespace UDMF
 } // namespace OHOS
diff --git a/udmf/interfaces/jskits/BUILD.gn b/udmf/interfaces/jskits/BUILD.gn
index c40294576065147179ba2f63668009edf6b306b0..433e68e8c2807ff536a10e98bec8bf0021c2131e 100644
--- a/udmf/interfaces/jskits/BUILD.gn
+++ b/udmf/interfaces/jskits/BUILD.gn
@@ -118,6 +118,7 @@ ohos_shared_library("uniformtypedescriptor_napi") {
   deps = [
     "${third_party_path}/bounds_checking_function:libsec_shared",
     "../innerkits:udmf_client",
+    "../innerkits:utd_client",
     "../jskits:udmf_js_common",
   ]
 
diff --git a/udmf/interfaces/jskits/common/napi_data_utils.h b/udmf/interfaces/jskits/common/napi_data_utils.h
index db354fab016cabd01760943fdb9582a5cc7a2413..aa9f701853cfe3a3b8bb016ba7305f395055b8a1 100644
--- a/udmf/interfaces/jskits/common/napi_data_utils.h
+++ b/udmf/interfaces/jskits/common/napi_data_utils.h
@@ -89,12 +89,26 @@ public:
 
     static napi_status GetValue(napi_env env, napi_value in, std::shared_ptr<TypeDescriptor> &descriptor);
 
+    /* napi_value <-> PixelMap */
     static napi_status GetValue(napi_env env, napi_value in, std::shared_ptr<OHOS::Media::PixelMap> &pixelMap);
     static napi_status SetValue(napi_env env, const std::shared_ptr<OHOS::Media::PixelMap> &in, napi_value &out);
 
+    /* napi_value <-> Want */
     static napi_status GetValue(napi_env env, napi_value in, std::shared_ptr<OHOS::AAFwk::Want> &wantPtr);
     static napi_status SetValue(napi_env env, const std::shared_ptr<OHOS::AAFwk::Want> &in, napi_value &out);
 
+    /* napi_value <-> Object */
+    static napi_status GetValue(napi_env env, napi_value in, std::shared_ptr<Object> &object);
+    static napi_status SetValue(napi_env env, const std::shared_ptr<Object> &object, napi_value &out);
+
+    /* napi_value <-> monostate */
+    static napi_status GetValue(napi_env env, napi_value in, std::monostate &out);
+    static napi_status SetValue(napi_env env, const std::monostate &in, napi_value &out);
+
+    /* napi_value <-> null */
+    static napi_status GetValue(napi_env env, napi_value in, nullptr_t &out);
+    static napi_status SetValue(napi_env env, const nullptr_t &in, napi_value &out);
+
     static bool IsTypeForNapiValue(napi_env env, napi_value param, napi_valuetype expectType);
 
     static bool IsNull(napi_env env, napi_value value);
@@ -109,6 +123,7 @@ private:
         TUPLE_VALUE,
         TUPLE_SIZE
     };
+    static constexpr int32_t STR_MAX_SIZE = 256;
 };
 
 #define LOG_ERROR_RETURN(condition, message, retVal)                             \
diff --git a/udmf/interfaces/jskits/data/uniform_type_descriptor_napi.h b/udmf/interfaces/jskits/data/uniform_type_descriptor_napi.h
index 338c845f4932f8b6b0f4d024ea4d5ebdf56a94a6..5b3c73d8902a39ac4d60abb49f04c2d8eef05e62 100644
--- a/udmf/interfaces/jskits/data/uniform_type_descriptor_napi.h
+++ b/udmf/interfaces/jskits/data/uniform_type_descriptor_napi.h
@@ -29,6 +29,8 @@ public:
     static napi_value GetTypeDescriptor(napi_env env, napi_callback_info info);
     static napi_value GetUniformDataTypeByFilenameExtension(napi_env env, napi_callback_info info);
     static napi_value GetUniformDataTypeByMIMEType(napi_env env, napi_callback_info info);
+    static napi_value GetMultiUniformDataTypesByFilenameExtension(napi_env env, napi_callback_info info);
+    static napi_value GetMultiUniformDataTypesByMIMEType(napi_env env, napi_callback_info info);
 
 private:
     static napi_value CreateUniformDataType(napi_env env);
diff --git a/udmf/interfaces/jskits/module/unified_data_channel_napi_module.cpp b/udmf/interfaces/jskits/module/unified_data_channel_napi_module.cpp
index 6511e4ecb1136f9012280b03f8f33b868e0ba230..ddb45610ff5054631b6223836bf58ab91efacadb 100644
--- a/udmf/interfaces/jskits/module/unified_data_channel_napi_module.cpp
+++ b/udmf/interfaces/jskits/module/unified_data_channel_napi_module.cpp
@@ -20,7 +20,6 @@
 #include "html_napi.h"
 #include "image_napi.h"
 #include "link_napi.h"
-#include "logger.h"
 #include "plain_text_napi.h"
 #include "unified_data_channel_napi.h"
 #include "summary_napi.h"
diff --git a/udmf/interfaces/jskits/module/uniform_type_descriptor_napi_module.cpp b/udmf/interfaces/jskits/module/uniform_type_descriptor_napi_module.cpp
index bc4b70636ac7d3868d94968ccd4e990d202b9c1c..484e103fc3d60c1b3db318a1825ab26351d96269 100644
--- a/udmf/interfaces/jskits/module/uniform_type_descriptor_napi_module.cpp
+++ b/udmf/interfaces/jskits/module/uniform_type_descriptor_napi_module.cpp
@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 #define LOG_TAG "UDMFUniformTypModule"
-#include "logger.h"
 #include "uniform_type_descriptor_napi.h"
 #include "type_descriptor_napi.h"
 
diff --git a/udmf/interfaces/ndk/BUILD.gn b/udmf/interfaces/ndk/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..2db39f273db6cc86523f9ac6ab23f061df624956
--- /dev/null
+++ b/udmf/interfaces/ndk/BUILD.gn
@@ -0,0 +1,61 @@
+# Copyright (c) 2024 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import("//build/ohos.gni")
+import("//foundation/distributeddatamgr/udmf/udmf.gni")
+
+ohos_shared_library("libudmf") {
+  branch_protector_ret = "pac_ret"
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
+  include_dirs = [
+    "${udmf_interfaces_path}/ndk/data",
+    "${udmf_interfaces_path}/innerkits/client",
+    "${udmf_interfaces_path}/innerkits/common",
+    "${udmf_interfaces_path}/innerkits/data",
+    "${udmf_framework_path}/common",
+  ]
+  sources = [
+    "${udmf_framework_path}/innerkitsimpl/common/unified_meta.cpp",
+    "${udmf_framework_path}/ndkimpl/data/data_provider_impl.cpp",
+    "${udmf_framework_path}/ndkimpl/data/udmf.cpp",
+    "${udmf_framework_path}/ndkimpl/data/uds.cpp",
+    "${udmf_framework_path}/ndkimpl/data/utd.cpp",
+  ]
+
+  defines = [ "API_EXPORT=__attribute__((visibility (\"default\")))" ]
+
+  deps = [
+    "${udmf_interfaces_path}/innerkits:udmf_client",
+    "${udmf_interfaces_path}/innerkits:utd_client",
+  ]
+
+  external_deps = [
+    "ability_base:base",
+    "ability_base:want",
+    "c_utils:utils",
+    "hilog:libhilog",
+    "image_framework:image",
+    "image_framework:image_native",
+    "image_framework:pixelmap",
+  ]
+
+  relative_install_dir = "ndk"
+  part_name = "udmf"
+  subsystem_name = "distributeddatamgr"
+  output_name = "udmf"
+  output_extension = "so"
+}
diff --git a/udmf/interfaces/ndk/data/data_provider_impl.h b/udmf/interfaces/ndk/data/data_provider_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..d3830dc4d764fd94fd0753180078ddcbdbbea2ad
--- /dev/null
+++ b/udmf/interfaces/ndk/data/data_provider_impl.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DATA_PROVIDER_IMPL_H
+#define DATA_PROVIDER_IMPL_H
+
+#include "entry_getter.h"
+#include "udmf.h"
+
+struct OH_UdmfRecordProvider {
+    OH_UdmfRecordProvider_GetData callback { nullptr };
+    void* context { nullptr };
+    UdmfData_Finalize finalize { nullptr };
+};
+
+namespace OHOS {
+namespace UDMF {
+class DataProviderImpl : public EntryGetter {
+public:
+    void SetInnerProvider(OH_UdmfRecordProvider* provider);
+    OH_UdmfRecordProvider* GetInnerProvider();
+    ValueType GetValueByType(const std::string &utdId) override;
+private:
+    OH_UdmfRecordProvider* innerProvider_;
+};
+
+} // namespace UDMF
+} // namespace OHOS
+
+#endif /* DATA_PROVIDER_IMPL_H */
\ No newline at end of file
diff --git a/udmf/interfaces/ndk/data/udmf.h b/udmf/interfaces/ndk/data/udmf.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d03a6e60ccad4d81ebe65c2639eb8dbf64789cf
--- /dev/null
+++ b/udmf/interfaces/ndk/data/udmf.h
@@ -0,0 +1,731 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup UDMF
+ * @{
+ *
+ * @brief The Unified Data Management Framework(UDMF) aims to define various standards
+ * for data across applications, devices, and platforms, providing a unified OpenHarmony
+ * data language and standardized data access and reading paths.
+ *
+ * @since 12
+ */
+
+/**
+ * @file udmf.h
+ *
+ * @brief Provides unified data management framework related functions and enumerations.
+ *
+ * @kit ArkData
+ * @library libudmf.so
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+#ifndef UDMF_H
+#define UDMF_H
+
+#include <inttypes.h>
+#include <stdbool.h>
+#include "uds.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief The key minimum memory space size of Unified Data.
+ *
+ * @since 12
+ */
+#define UDMF_KEY_BUFFER_LEN (512)
+
+/**
+ * @brief Describe the intention type of the udmf.
+ *
+ * @since 12
+ */
+typedef enum Udmf_Intention {
+    /**
+     * @brief The intention is drag.
+     */
+    UDMF_INTENTION_DRAG,
+    /**
+     * @brief The intention is pasteboard.
+     */
+    UDMF_INTENTION_PASTEBOARD,
+} Udmf_Intention;
+
+/**
+ * @brief Describe intra-device usage range type enumeration.
+ *
+ * @since 12
+ */
+typedef enum Udmf_ShareOption {
+    /**
+     * @brief Invalid share option.
+     */
+    SHARE_OPTIONS_INVALID,
+    /**
+     * @brief Allowed to be used in the same application on this device.
+     */
+    SHARE_OPTIONS_IN_APP,
+    /**
+     * @brief Allowed to be used in the cross application on this device.
+     */
+    SHARE_OPTIONS_CROSS_APP
+} Udmf_ShareOption;
+
+/**
+ * @brief Describes the unified data type.
+ *
+ * @since 12
+ */
+typedef struct OH_UdmfData OH_UdmfData;
+
+/**
+ * @brief Describes the record type in the unified data.
+ *
+ * @since 12
+ */
+typedef struct OH_UdmfRecord OH_UdmfRecord;
+
+/**
+ * @brief Defines the data provider.
+ *
+ * @since 13
+ */
+typedef struct OH_UdmfRecordProvider OH_UdmfRecordProvider;
+
+/**
+ * @brief Describes some property parameters of unified data.
+ *
+ * @since 12
+ */
+typedef struct OH_UdmfProperty OH_UdmfProperty;
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdmfData}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdmfData}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdmfData.
+ * @since 12
+ */
+OH_UdmfData* OH_UdmfData_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdmfData} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @see OH_UdmfData.
+ * @since 12
+ */
+void OH_UdmfData_Destroy(OH_UdmfData* pThis);
+
+/**
+ * @brief Add one {OH_UdmfRecord} record to the {@link OH_UdmfData} data.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param record Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfData Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfData_AddRecord(OH_UdmfData* pThis, OH_UdmfRecord* record);
+
+/**
+ * @brief Check whether the type exists in the {@link OH_UdmfData} data.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param type Represents a string pointer of the type.
+ * @return Returns the status of finding type.
+ *         {@code false} is not existed.
+ *         {@code true} is existed.
+ * @see OH_UdmfData.
+ * @since 12
+ */
+bool OH_UdmfData_HasType(OH_UdmfData* pThis, const char* type);
+
+/**
+ * @brief Get all types in the {@link OH_UdmfData} data.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param count Represents the types count that is a output param.
+ * @return Returns string array that in {@link OH_UdmfData} when input parameters valid,
+ * otherwise return nullptr.
+ * @see OH_UdmfData.
+ * @since 12
+ */
+char** OH_UdmfData_GetTypes(OH_UdmfData* pThis, unsigned int* count);
+
+/**
+ * @brief Get all records in the {@link OH_UdmfData} data.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param count Represents the records count that is a output param.
+ * @return Returns {@link OH_UdmfRecord} pointer array when input parameters valid, otherwise return nullptr.
+ * @see OH_UdmfData OH_UdmfRecord.
+ * @since 12
+ */
+OH_UdmfRecord** OH_UdmfData_GetRecords(OH_UdmfData* pThis, unsigned int* count);
+
+/**
+ * @brief Defines the callback function used free the context.
+ * @param context Pointer to the context which is to be free.
+ * @since 13
+ */
+typedef void (*UdmfData_Finalize)(void* context);
+
+/**
+ * @brief Creates an {@link OH_UdmfRecordProvider} instance.
+ *
+ * @return Returns the pointer to the {@link OH_UdmfRecordProvider} instance created if the operation is successful.
+ * Returns nullptr if the memory is not enough.
+ * @see OH_UdmfRecordProvider.
+ * @since 13
+ */
+OH_UdmfRecordProvider* OH_UdmfRecordProvider_Create();
+
+/**
+ * @brief Destroy an {@link OH_UdmfRecordProvider} instance.
+ *
+ * @param subscriber Pointer to the {@link OH_UdmfRecordProvider} instance to destroy.
+ * @return Returns the status code of the execution. For details, see {@link Udmf_ErrCode}.
+ *         Returns {@link UDMF_E_OK} if the operation is successful.
+ *         Returns {@link UDMF_E_INVALID_PARAM} if invalid args are detected.
+ * @see OH_UdmfRecordProvider Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecordProvider_Destroy(OH_UdmfRecordProvider* provider);
+
+/**
+ * @brief Defines a callback function used to obtain data by type.
+ *
+ * @param context Pointer to the context set by {@link OH_UdmfRecordProvider_SetData}.
+ * @param type Pointer to the type of data to obtain. For details, see {@link udmf_meta.h}.
+ * @return Returns the data content.
+ * @since 13
+ */
+typedef void* (*OH_UdmfRecordProvider_GetData)(void* context, const char* type);
+
+/**
+ * @brief Sets a callback function to obtain data.
+ *
+ * @param provider Pointer to the {@link OH_UdmfRecordProvider} instance.
+ * @param context Pointer to the context set, which is the first parameter in OH_UdmfRecordProvider_GetData.
+ * @param callback Callback to set. For details, see {@link OH_UdmfRecordProvider_GetData}.
+ * @param finalize Optional callback that can free context when destroy provider.
+ *         For details, see {@link UdmfData_Finalize}.
+ * @return Returns the status code of the execution. For details, see {@link Udmf_ErrCode}.
+ *         Returns {@link UDMF_E_OK} if the operation is successful.
+ *         Returns {@link UDMF_E_INVALID_PARAM} if invalid args are detected.
+ * @see OH_UdmfRecordProvider OH_UdmfRecordProvider_GetData UdmfData_Finalize Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecordProvider_SetData(OH_UdmfRecordProvider* provider, void* context,
+    const OH_UdmfRecordProvider_GetData callback, const UdmfData_Finalize finalize);
+
+/**
+ * @brief Get primary {@link OH_UdsPlainText} data from the {@link OH_UdmfData}.
+ *
+ * @param data Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param plainText Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfData OH_UdsPlainText Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfData_GetPrimaryPlainText(OH_UdmfData* data, OH_UdsPlainText* plainText);
+
+/**
+ * @brief Get one {@link OH_UdsHtml} data from the {@link OH_UdmfData}.
+ *
+ * @param data Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param html Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfData OH_UdsHtml Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfData_GetPrimaryHtml(OH_UdmfData* data, OH_UdsHtml* html);
+
+/**
+ * @brief Get the count of {@link OH_UdmfRecord} in the {@link OH_UdmfData}.
+ *
+ * @param data Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @return Returns the count of {@link OH_UdmfRecord}
+ * @see OH_UdmfData.
+ * @since 13
+ */
+int OH_UdmfData_GetRecordCount(OH_UdmfData* data);
+
+/**
+ * @brief Get the record of the specified index from the {@link OH_UdmfData}.
+ *
+ * @param data Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param index Represents the index of {@link OH_UdmfRecord} in the {@link OH_UdmfData}.
+ * @return Returns the count of {@link OH_UdmfRecord}
+ * @see OH_UdmfData.
+ * @since 13
+ */
+OH_UdmfRecord* OH_UdmfData_GetRecord(OH_UdmfData* data, unsigned int index);
+
+/**
+ * @brief Checks whether the UDMF data is from a local device.
+ *
+ * @param data Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @return Returns the count of {@link OH_UdmfRecord}
+ * @see OH_UdmfData.
+ * @since 13
+ */
+bool OH_UdmfData_IsLocal(OH_UdmfData* data);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdmfRecord}, it's relate with UDS data.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdmfRecord}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdmfRecord.
+ * @since 12
+ */
+OH_UdmfRecord* OH_UdmfRecord_Create();
+
+/**
+ * @brief Destroy a pointer that points to an instance of {@link OH_UdmfRecord}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @see OH_UdmfRecord.
+ * @since 12
+ */
+void OH_UdmfRecord_Destroy(OH_UdmfRecord* pThis);
+
+/**
+ * @brief Add one custom data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param typeId Represents record type, reference udmf_meta.h.
+ * @param entry Represents custom data.
+ * @param count Represents the size of data param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_AddGeneralEntry(OH_UdmfRecord* record, const char* typeId,
+                                  const unsigned char* entry, unsigned int count);
+
+/**
+ * @brief Add one {OH_UdsPlainText} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param plainText Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsPlainText Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_AddPlainText(OH_UdmfRecord* pThis, OH_UdsPlainText* plainText);
+
+/**
+ * @brief Add one {OH_UdsHyperlink} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param hyperlink Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsHyperlink Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_AddHyperlink(OH_UdmfRecord* pThis, OH_UdsHyperlink* hyperlink);
+
+/**
+ * @brief Add one {OH_UdsHtml} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param html Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsHtml Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_AddHtml(OH_UdmfRecord* pThis, OH_UdsHtml* html);
+
+/**
+ * @brief Add one {OH_UdsAppItem} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param appItem Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsAppItem Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_AddAppItem(OH_UdmfRecord* pThis, OH_UdsAppItem* appItem);
+
+/**
+ * @brief Add one {OH_UdsFileUri} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param fileUri Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsFileUri Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_AddFileUri(OH_UdmfRecord* pThis, OH_UdsFileUri* fileUri);
+
+/**
+ * @brief Add one {OH_UdsPixelMap} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param pixelMap Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsPixelMap Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_AddPixelMap(OH_UdmfRecord* pThis, OH_UdsPixelMap* pixelMap);
+
+/**
+ * @brief Add one {@link OH_UdsArrayBuffer} data to the {@link OH_UdmfRecord} record.
+ *
+ * @param record Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param type Represents record type, reference udmf_meta.h.
+ * @param buffer Represents a pointer to an instance of {@link OH_UdsArrayBuffer}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsArrayBuffer Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_AddArrayBuffer(OH_UdmfRecord* record, const char* type, OH_UdsArrayBuffer* buffer);
+
+/**
+ * @brief Get all types in the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param count Represents the types count that is a output param.
+ * @return Returns string array that in {@link OH_UdmfRecord} when input parameters valid,
+ * otherwise return nullptr.
+ * @see OH_UdmfRecord.
+ * @since 12
+ */
+char** OH_UdmfRecord_GetTypes(OH_UdmfRecord* pThis, unsigned int* count);
+
+/**
+ * @brief Get one entry data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param typeId Represents record type, reference udmf_meta.h.
+ * @param entry Represents a pointer to entry data that is a output param.
+ * @param count Represents the entry data length that is a output param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_GetGeneralEntry(OH_UdmfRecord* pThis, const char* typeId,
+    unsigned char** entry, unsigned int* count);
+
+/**
+ * @brief Get one {OH_UdsPlainText} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param plainText Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsPlainText Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_GetPlainText(OH_UdmfRecord* pThis, OH_UdsPlainText* plainText);
+
+/**
+ * @brief Get one {OH_UdsHyperlink} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param hyperlink Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsHyperlink Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_GetHyperlink(OH_UdmfRecord* pThis, OH_UdsHyperlink* hyperlink);
+
+/**
+ * @brief Get one {OH_UdsHtml} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param html Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsHtml Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_GetHtml(OH_UdmfRecord* pThis, OH_UdsHtml* html);
+
+/**
+ * @brief Get one {OH_UdsAppItem} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param appItem Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsAppItem Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfRecord_GetAppItem(OH_UdmfRecord* pThis, OH_UdsAppItem* appItem);
+
+/**
+ * @brief Get one {OH_UdsFileUri} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param fileUri Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsFileUri Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_GetFileUri(OH_UdmfRecord* pThis, OH_UdsFileUri* fileUri);
+
+/**
+ * @brief Get one {OH_UdsPixelMap} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param pixelMap Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsPixelMap Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_GetPixelMap(OH_UdmfRecord* pThis, OH_UdsPixelMap* pixelMap);
+
+/**
+ * @brief Set the data provider of the types.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param types Represents a pointer to a group of data types;
+ * @param count Represents the number of data types;
+ * @param provider Represents a pointer an instance of {@link OH_UdmfRecordProvider}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdmfRecordProvider Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_SetProvider(OH_UdmfRecord* pThis, const char* const* types, unsigned int count,
+    OH_UdmfRecordProvider* provider);
+
+/**
+ * @brief Get one {@link OH_UdsArrayBuffer} data from the {@link OH_UdmfRecord} record.
+ *
+ * @param record Represents a pointer to an instance of {@link OH_UdmfRecord}.
+ * @param type Represents record type, reference udmf_meta.h.
+ * @param buffer Represents a pointer to an instance of {@link OH_UdsArrayBuffer}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfRecord OH_UdsArrayBuffer Udmf_ErrCode.
+ * @since 13
+ */
+int OH_UdmfRecord_GetArrayBuffer(OH_UdmfRecord* record, const char* type, OH_UdsArrayBuffer* buffer);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdmfProperty}
+ * from a {@link OH_UdmfData} data.
+ *
+ * @param unifiedData Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdmfProperty}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdmfData OH_UdmfProperty.
+ * @since 12
+ */
+OH_UdmfProperty* OH_UdmfProperty_Create(OH_UdmfData* unifiedData);
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdmfProperty} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @see OH_UdmfProperty.
+ * @since 12
+ */
+void OH_UdmfProperty_Destroy(OH_UdmfProperty* pThis);
+
+/**
+ * @brief Get tag value from the {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @return Returns a pointer of the tag value string when input parameters valid, otherwise return nullptr.
+ * @see OH_UdmfProperty.
+ * @since 12
+ */
+const char* OH_UdmfProperty_GetTag(OH_UdmfProperty* pThis);
+
+/**
+ * @brief Get timestamp value from the {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @return Returns timestamp value.
+ * @see OH_UdmfProperty
+ * @since 12
+ */
+int64_t OH_UdmfProperty_GetTimestamp(OH_UdmfProperty* pThis);
+
+/**
+ * @brief Get share option value from the {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @return Returns {@link Udmf_ShareOption} value.
+ * @see OH_UdmfProperty Udmf_ShareOption
+ * @since 12
+ */
+Udmf_ShareOption OH_UdmfProperty_GetShareOption(OH_UdmfProperty* pThis);
+
+/**
+ * @brief Get integer value by key from the {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param key Represents key-value pair's key
+ * @param defaultValue Represents when get value failure.
+ * @return Returns value associated with the key in successfully, otherwise return defaultValue.
+ * @see OH_UdmfProperty.
+ * @since 12
+ */
+int OH_UdmfProperty_GetExtrasIntParam(OH_UdmfProperty* pThis,
+    const char* key, int defaultValue);
+
+/**
+ * @brief Get tag value from the {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param key Represents key-value pair's key.
+ * @return Returns a pointer of the key value string when input parameters valid, otherwise return nullptr.
+ * @see OH_UdmfProperty
+ * @since 12
+ */
+const char* OH_UdmfProperty_GetExtrasStringParam(OH_UdmfProperty* pThis, const char* key);
+
+/**
+ * @brief Set tag value to {@link OH_UdmfProperty} .
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param tag Represents new tag param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfProperty_SetTag(OH_UdmfProperty* pThis, const char* tag);
+
+/**
+ * @brief Set Udmf_ShareOption value to {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param option Represents new {@link Udmf_ShareOption} param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_ShareOption Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfProperty_SetShareOption(OH_UdmfProperty* pThis, Udmf_ShareOption option);
+
+/**
+ * @brief Set extras param to {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param key Represents extras param's key value.
+ * @param param Represents value of k-v pairs.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfProperty_SetExtrasIntParam(OH_UdmfProperty* pThis, const char* key, int param);
+
+/**
+ * @brief Set extras param to {@link OH_UdmfProperty}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdmfProperty}.
+ * @param key Represents extras param's key value.
+ * @param param Represents value of k-v pairs.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_ErrCode.
+ * @since 12
+ */
+int OH_UdmfProperty_SetExtrasStringParam(OH_UdmfProperty* pThis,
+    const char* key, const char* param);
+
+/**
+ * @brief Get {@link OH_UdmfData} data from udmf database.
+ *
+ * @param key Represents database store's key value.
+ * @param intention Represents data type {@link Udmf_Intention}
+ * @param unifiedData Represents output params of {@link OH_UdmfData};
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_Intention Udmf_ErrCode.
+ * @since 12
+ */
+int OH_Udmf_GetUnifiedData(const char* key, Udmf_Intention intention, OH_UdmfData* unifiedData);
+
+/**
+ * @brief Set {@link OH_UdmfData} data to database.
+ *
+ * @param intention Represents data type {@link Udmf_Intention}.
+ * @param unifiedData Represents a pointer to an instance of {@link OH_UdmfData}.
+ * @param key Represents return value after set data to database successfully,
+ * it's memory size not less than {@link UDMF_KEY_BUFFER_LEN}.
+ * @param keyLen Represents size of key param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdmfProperty Udmf_Intention Udmf_ErrCode.
+ * @since 12
+ */
+int OH_Udmf_SetUnifiedData(Udmf_Intention intention, OH_UdmfData* unifiedData,
+    char* key, unsigned int keyLen);
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif
\ No newline at end of file
diff --git a/udmf/interfaces/ndk/data/udmf_err_code.h b/udmf/interfaces/ndk/data/udmf_err_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..105191c7c040db176267497551b13ee668468dd6
--- /dev/null
+++ b/udmf/interfaces/ndk/data/udmf_err_code.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup UDMF
+ * @{
+ *
+ * @brief The Unified Data Management Framework(UDMF) aims to define various standards
+ * for data across applications, devices, and platforms, providing a unified OpenHarmony
+ * data language and standardized data access and reading paths.
+ *
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+/**
+ * @file udmf_err_code.h
+ *
+ * @brief Declaration error code information.
+ *
+ * @kit ArkData
+ * @library libudmf.so
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+
+#ifndef UDMF_ERR_CODE_H
+#define UDMF_ERR_CODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Indicates the error code information.
+ *
+ * @since 12
+ */
+typedef enum Udmf_ErrCode {
+    /**
+     * The error code in the correct case.
+     */
+    UDMF_E_OK = 0,
+    /**
+     * @brief The error code for common exceptions.
+     */
+    UDMF_ERR = 20400000,
+    /**
+     * @brief The error code for common invalid args.
+     */
+    UDMF_E_INVALID_PARAM = (UDMF_ERR + 1),
+} Udmf_ErrCode;
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif
diff --git a/udmf/interfaces/ndk/data/udmf_meta.h b/udmf/interfaces/ndk/data/udmf_meta.h
new file mode 100644
index 0000000000000000000000000000000000000000..e9c3914ed3e9c6c884e28a85c488f946b4fd1cf5
--- /dev/null
+++ b/udmf/interfaces/ndk/data/udmf_meta.h
@@ -0,0 +1,1005 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup UDMF
+ * @{
+ *
+ * @brief The Unified Data Management Framework(UDMF) aims to define various standards
+ * for data across applications, devices, and platforms, providing a unified OpenHarmony
+ * data language and standardized data access and reading paths.
+ *
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+/**
+ * @file udmf_meta.h
+ *
+ * @brief Declaration the uniform data type information.
+ *
+ * @kit ArkData
+ * @library libudmf.so
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+#ifndef UDMF_META_H
+#define UDMF_META_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ENTITY "general.entity"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OBJECT "general.object"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_COMPOSITE_OBJECT "general.composite-object"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TEXT "general.text"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PLAIN_TEXT "general.plain-text"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_HTML "general.html"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_HYPERLINK "general.hyperlink"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_XML "general.xml"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SOURCE_CODE "general.source-code"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SCRIPT "general.script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SHELL_SCRIPT "general.shell-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_CSH_SCRIPT "general.csh-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PERL_SCRIPT "general.perl-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PHP_SCRIPT "general.php-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PYTHON_SCRIPT "general.python-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_RUBY_SCRIPT "general.ruby-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TYPE_SCRIPT "general.type-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_JAVA_SCRIPT "general.java-script"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_C_HEADER "general.c-header"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_C_SOURCE "general.c-source"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_C_PLUS_PLUS_HEADER "general.c-plus-plus-header"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_C_PLUS_PLUS_SOURCE "general.c-plus-plus-source"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_JAVA_SOURCE "general.java-source"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_EBOOK "general.ebook"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_EPUB "general.epub"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AZW "com.amazon.azw"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AZW3 "com.amazon.azw3"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_KFX "com.amazon.kfx"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MOBI "com.amazon.mobi"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MEDIA "general.media"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_IMAGE "general.image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_JPEG "general.jpeg"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PNG "general.png"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_RAW_IMAGE "general.raw-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TIFF "general.tiff"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_BMP "com.microsoft.bmp"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ICO "com.microsoft.ico"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PHOTOSHOP_IMAGE "com.adobe.photoshop-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AI_IMAGE "com.adobe.illustrator.ai-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WORD_DOC "com.microsoft.word.doc"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_EXCEL "com.microsoft.excel.xls"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PPT "com.microsoft.powerpoint.ppt"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PDF "com.adobe.pdf"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_POSTSCRIPT "com.adobe.postscript"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ENCAPSULATED_POSTSCRIPT "com.adobe.encapsulated-postscript"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_VIDEO "general.video"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AVI "general.avi"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MPEG "general.mpeg"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MPEG4 "general.mpeg-4"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_VIDEO_3GPP "general.3gpp"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_VIDEO_3GPP2 "general.3gpp2"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WM "com.microsoft.windows-media-wm"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WMV "com.microsoft.windows-media-wmv"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WMP "com.microsoft.windows-media-wmp"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AUDIO "general.audio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AAC "general.aac"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AIFF "general.aiff"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ALAC "general.alac"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_FLAC "general.flac"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MP3 "general.mp3"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OGG "general.ogg"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PCM "general.pcm"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WMA "com.microsoft.windows-media-wma"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WAVEFORM_AUDIO "com.microsoft.waveform-audio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WMX "com.microsoft.windows-media-wmx"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WVX "com.microsoft.windows-media-wvx"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WINDOWS_MEDIA_WAX "com.microsoft.windows-media-wax"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_GENERAL_FILE "general.file"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_DIRECTORY "general.directory"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_FOLDER "general.folder"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SYMLINK "general.symlink"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ARCHIVE "general.archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_BZ2_ARCHIVE "general.bz2-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_DISK_IMAGE "general.disk-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TAR_ARCHIVE "general.tar-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ZIP_ARCHIVE "general.zip-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_JAVA_ARCHIVE "com.sun.java-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_GNU_TAR_ARCHIVE "org.gnu.gnu-tar-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_GNU_ZIP_ARCHIVE "org.gnu.gnu-zip-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_GNU_ZIP_TAR_ARCHIVE "org.gnu.gnu-zip-tar-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_CALENDAR "general.calendar"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_CONTACT "general.contact"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_DATABASE "general.database"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MESSAGE "general.message"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_VCARD "general.vcard"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_NAVIGATION "general.navigation"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_LOCATION "general.location"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_FORM "openharmony.form"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_APP_ITEM "openharmony.app-item"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_PIXEL_MAP "openharmony.pixel-map"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_ATOMIC_SERVICE "openharmony.atomic-service"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_PACKAGE "openharmony.package"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_HAP "openharmony.hap"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SMIL "com.real.smil"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_MARKDOWN "general.markdown"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_FAX "general.fax"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_JFX_FAX "com.j2.jfx-fax"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_EFX_FAX "com.js.efx-fax"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_XBITMAP_IMAGE "general.xbitmap-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TGA_IMAGE "com.truevision.tga-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SGI_IMAGE "com.sgi.sgi-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENEXR_IMAGE "com.ilm.openexr-image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_FLASHPIX_IMAGE "com.kodak.flashpix.image"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_REALMEDIA "com.real.realmedia"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AU_AUDIO "general.au-audio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_AIFC_AUDIO "general.aifc-audio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SD2_AUDIO "com.digidesign.sd2-audio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_REALAUDIO "com.real.realaudio"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENXML "org.openxmlformats.openxml"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_WORDPROCESSINGML_DOCUMENT "org.openxmlformats.wordprocessingml.document"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SPREADSHEETML_SHEET "org.openxmlformats.spreadsheetml.sheet"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PRESENTATIONML_PRESENTATION "org.openxmlformats.presentationml.presentation"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT "org.oasis.opendocument"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT_TEXT "org.oasis.opendocument.text"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT_SPREADSHEET "org.oasis.opendocument.spreadsheet"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT_PRESENTATION "org.oasis.opendocument.presentation"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT_GRAPHICS "org.oasis.opendocument.graphics"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENDOCUMENT_FORMULA "org.oasis.opendocument.formula"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_STUFFIT_ARCHIVE "com.allume.stuffit-archive"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_VCS "general.vcs"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_ICS "general.ics"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_EXECUTABLE "general.executable"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_PORTABLE_EXECUTABLE "com.microsoft.portable-executable"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_SUN_JAVA_CLASS "com.sun.java-class"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_FONT "general.font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TRUETYPE_FONT "general.truetype-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_TRUETYPE_COLLECTION_FONT "general.truetype-collection-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENTYPE_FONT "general.opentype-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_POSTSCRIPT_FONT "com.adobe.postscript-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_POSTSCRIPT_PFB_FONT "com.adobe.postscript-pfb-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_POSTSCRIPT_PFA_FONT "com.adobe.postscript-pfa-font"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_HDOC "openharmony.hdoc"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_HINOTE "openharmony.hinote"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_STYLED_STRING "openharmony.styled-string"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 12
+ */
+#define UDMF_META_OPENHARMONY_WANT "openharmony.want"
+
+/**
+ * @brief A specific type of uniform data type.
+ *
+ * @since 13
+ */
+#define UDMF_META_GENERAL_FILE_URI "general.file-uri"
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif
diff --git a/udmf/interfaces/ndk/data/uds.h b/udmf/interfaces/ndk/data/uds.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c0083f78aae079ca5a8df33e1cebebd0824cf48
--- /dev/null
+++ b/udmf/interfaces/ndk/data/uds.h
@@ -0,0 +1,677 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup UDMF
+ * @{
+ *
+ * @brief The Unified Data Management Framework(UDMF) aims to define various standards
+ * for data across applications, devices, and platforms, providing a unified OpenHarmony
+ * data language and standardized data access and reading paths.
+ *
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ *
+ * @since 12
+ */
+
+/**
+ * @file uds.h
+ *
+ * @brief Provides uniform data struct(UDS).
+ *
+ * @kit ArkData
+ * @library libudmf.so
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ * @since 12
+ */
+
+#ifndef UDS_H
+#define UDS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Describes the unified data struct of plaintext.
+ *
+ * @since 12
+ */
+typedef struct OH_UdsPlainText OH_UdsPlainText;
+
+/**
+ * @brief Describes the unified data struct of hyperlink.
+ *
+ * @since 12
+ */
+typedef struct OH_UdsHyperlink OH_UdsHyperlink;
+
+/**
+ * @brief Describes the unified data struct of html.
+ *
+ * @since 12
+ */
+typedef struct OH_UdsHtml OH_UdsHtml;
+
+/**
+ * @brief Describes the unified data struct of open harmony application item.
+ *
+ * @since 12
+ */
+typedef struct OH_UdsAppItem OH_UdsAppItem;
+
+/**
+ * @brief Describes the unified data struct of file uri.
+ *
+ * @since 13
+ */
+typedef struct OH_UdsFileUri OH_UdsFileUri;
+
+/**
+ * @brief Describes the unified data struct of open harmony pixel map.
+ *
+ * @since 13
+ */
+typedef struct OH_UdsPixelMap OH_UdsPixelMap;
+
+/**
+ * @brief Describes the of pixel map native.
+ *
+ * @since 13
+ */
+struct OH_PixelmapNative;
+
+/**
+ * @brief Describes the unified data struct of array buffer.
+ *
+ * @since 13
+ */
+typedef struct OH_UdsArrayBuffer OH_UdsArrayBuffer;
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsPlainText}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsPlainText}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdsPlainText
+ * @since 12
+ */
+OH_UdsPlainText* OH_UdsPlainText_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsPlainText} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @see OH_UdsPlainText
+ * @since 12
+ */
+void OH_UdsPlainText_Destroy(OH_UdsPlainText* pThis);
+
+/**
+ * @brief Get type id from the {@link OH_UdsPlainText}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsPlainText
+ * @since 12
+ */
+const char* OH_UdsPlainText_GetType(OH_UdsPlainText* pThis);
+
+/**
+ * @brief Get content from the {@link OH_UdsPlainText}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsPlainText
+ * @since 12
+ */
+const char* OH_UdsPlainText_GetContent(OH_UdsPlainText* pThis);
+
+/**
+ * @brief Get abstract from the {@link OH_UdsPlainText}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsPlainText
+ * @since 12
+ */
+const char* OH_UdsPlainText_GetAbstract(OH_UdsPlainText* pThis);
+
+/**
+ * @brief Set content to the {@link OH_UdsPlainText}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @param content Represents a new content string.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsPlainText Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsPlainText_SetContent(OH_UdsPlainText* pThis, const char* content);
+
+/**
+ * @brief Set abstract to the {@link OH_UdsPlainText}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPlainText}.
+ * @param abstract Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsPlainText Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsPlainText_SetAbstract(OH_UdsPlainText* pThis, const char* abstract);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsHyperlink}.
+ *
+ * @return If the operation is successful, a pointer to the instance of {@link OH_UdsHyperlink}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdsHyperlink
+ * @since 12
+ */
+OH_UdsHyperlink* OH_UdsHyperlink_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsHyperlink} instance.
+ *
+ * @param pThis Represents a pointer to an  instance of {@link OH_UdsHyperlink}.
+ * @see OH_UdsHyperlink
+ * @since 12
+ */
+void OH_UdsHyperlink_Destroy(OH_UdsHyperlink* pThis);
+
+/**
+ * @brief Get type from the {@link OH_UdsHyperlink}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHyperlink
+ * @since 12
+ */
+const char* OH_UdsHyperlink_GetType(OH_UdsHyperlink* pThis);
+
+/**
+ * @brief Get url from the {@link OH_UdsHyperlink}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHyperlink
+ * @since 12
+ */
+const char* OH_UdsHyperlink_GetUrl(OH_UdsHyperlink* pThis);
+
+/**
+ * @brief Get description from the {@link OH_UdsHyperlink}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHyperlink
+ * @since 12
+ */
+const char* OH_UdsHyperlink_GetDescription(OH_UdsHyperlink* pThis);
+
+/**
+ * @brief Set url to the {@link OH_UdsHyperlink}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @param url Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsHyperlink Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsHyperlink_SetUrl(OH_UdsHyperlink* pThis, const char* url);
+
+/**
+ * @brief Set description to the {@link OH_UdsHyperlink}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHyperlink}.
+ * @param description Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsHyperlink Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsHyperlink_SetDescription(OH_UdsHyperlink* pThis, const char* description);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsHtml}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsHtml}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdsHtml
+ * @since 12
+ */
+OH_UdsHtml* OH_UdsHtml_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsHtml} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @see OH_UdsHtml
+ * @since 12
+ */
+void OH_UdsHtml_Destroy(OH_UdsHtml* pThis);
+
+/**
+ * @brief Get html from the {@link OH_UdsHtml}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHtml
+ * @since 12
+ */
+const char* OH_UdsHtml_GetType(OH_UdsHtml* pThis);
+
+/**
+ * @brief Get content from the {@link OH_UdsHtml}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHtml
+ * @since 12
+ */
+const char* OH_UdsHtml_GetContent(OH_UdsHtml* pThis);
+
+/**
+ * @brief Get plain content from the {@link OH_UdsHtml}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsHtml
+ * @since 12
+ */
+const char* OH_UdsHtml_GetPlainContent(OH_UdsHtml* pThis);
+
+/**
+ * @brief Set content to the {@link OH_UdsHtml}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @param content Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsHtml Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsHtml_SetContent(OH_UdsHtml* pThis, const char* content);
+
+/**
+ * @brief Set plain content to the {@link OH_UdsHtml}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsHtml}.
+ * @param plainContent Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsHtml Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsHtml_SetPlainContent(OH_UdsHtml* pThis, const char* plainContent);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsAppItem}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsAppItem}
+ * structure is returned. sIf the operation is failed, nullptr is returned.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+OH_UdsAppItem* OH_UdsAppItem_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsAppItem} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+void OH_UdsAppItem_Destroy(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get type from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetType(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get app id from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetId(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get app name from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetName(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get app icon id from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetIconId(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get app label id from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetLabelId(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get bundle name from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetBundleName(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Get ability name from the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance {@link OH_UdsAppItem}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsAppItem
+ * @since 12
+ */
+const char* OH_UdsAppItem_GetAbilityName(OH_UdsAppItem* pThis);
+
+/**
+ * @brief Set application id to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param appId Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetId(OH_UdsAppItem* pThis, const char* appId);
+
+/**
+ * @brief Set application name to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param appName Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetName(OH_UdsAppItem* pThis, const char* appName);
+
+/**
+ * @brief Set application icon id to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param appIconId Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetIconId(OH_UdsAppItem* pThis, const char* appIconId);
+
+/**
+ * @brief Set application label id to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param appLabelId Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetLabelId(OH_UdsAppItem* pThis, const char* appLabelId);
+
+/**
+ * @brief Set bundle name to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param bundleName Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetBundleName(OH_UdsAppItem* pThis, const char* bundleName);
+
+/**
+ * @brief Set ability name to the {@link OH_UdsAppItem}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsAppItem}.
+ * @param abilityName Represents a new string value.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsAppItem Udmf_ErrCode
+ * @since 12
+ */
+int OH_UdsAppItem_SetAbilityName(OH_UdsAppItem* pThis, const char* abilityName);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsFileUri}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsFileUri}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdsFileUri
+ * @since 13
+ */
+OH_UdsFileUri* OH_UdsFileUri_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsFileUri} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @see OH_UdsFileUri
+ * @since 13
+ */
+void OH_UdsFileUri_Destroy(OH_UdsFileUri* pThis);
+
+/**
+ * @brief Get type id from the {@link OH_UdsFileUri}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsFileUri
+ * @since 13
+ */
+const char* OH_UdsFileUri_GetType(OH_UdsFileUri* pThis);
+
+/**
+ * @brief Get file uri from the {@link OH_UdsFileUri}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsFileUri
+ * @since 13
+ */
+const char* OH_UdsFileUri_GetFileUri(OH_UdsFileUri* pThis);
+
+/**
+ * @brief Get file type from the {@link OH_UdsFileUri}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsFileUri
+ * @since 13
+ */
+const char* OH_UdsFileUri_GetFileType(OH_UdsFileUri* pThis);
+
+/**
+ * @brief Set file uri to the {@link OH_UdsFileUri}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @param fileUri Represents a new file uri string.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsFileUri Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsFileUri_SetFileUri(OH_UdsFileUri* pThis, const char* fileUri);
+
+/**
+ * @brief Set file type to the {@link OH_UdsFileUri}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsFileUri}.
+ * @param fileType Represents a new file type string.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsFileUri Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsFileUri_SetFileType(OH_UdsFileUri* pThis, const char* fileType);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsPixelMap}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsPixelMap}
+ * structure is returned. If the operation is failed, nullptr is returned.
+ * @see OH_UdsPixelMap
+ * @since 13
+ */
+OH_UdsPixelMap* OH_UdsPixelMap_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsPixelMap} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @see OH_UdsPixelMap
+ * @since 13
+ */
+void OH_UdsPixelMap_Destroy(OH_UdsPixelMap* pThis);
+
+/**
+ * @brief Get type id from the {@link OH_UdsPixelMap}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @return Returns a pointer of the value string when input args normally, otherwise return nullptr.
+ * @see OH_UdsPixelMap
+ * @since 13
+ */
+const char* OH_UdsPixelMap_GetType(OH_UdsPixelMap* pThis);
+
+/**
+ * @brief Get pixel map from the {@link OH_UdsPixelMap}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @param pixelmapNative Represents output params of {@link OH_PixelmapNative}.
+ * @see OH_UdsPixelMap
+ * @since 13
+ */
+void OH_UdsPixelMap_GetPixelMap(OH_UdsPixelMap* pThis, OH_PixelmapNative* pixelmapNative);
+
+/**
+ * @brief Set pixel map to the {@link OH_UdsPixelMap}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_UdsPixelMap}.
+ * @param pixelmapNative Represents a new {@link OH_PixelmapNative}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsPixelMap Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsPixelMap_SetPixelMap(OH_UdsPixelMap* pThis, OH_PixelmapNative* pixelmapNative);
+
+/**
+ * @brief Creation a pointer to the instance of the {@link OH_UdsArrayBuffer}.
+ *
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_UdsArrayBuffer}
+ * structure is returned. If the memory is not enough, nullptr is returned.
+ * @see OH_UdsArrayBuffer
+ * @since 13
+ */
+OH_UdsArrayBuffer* OH_UdsArrayBuffer_Create();
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_UdsArrayBuffer} instance.
+ *
+ * @param buffer Represents a pointer to an instance of {@link OH_UdsArrayBuffer}.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsArrayBuffer Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsArrayBuffer_Destroy(OH_UdsArrayBuffer* buffer);
+
+/**
+ * @brief Set array buffer data to the {@link OH_UdsArrayBuffer}.
+ *
+ * @param buffer Represents a pointer to an instance of {@link OH_UdsArrayBuffer}.
+ * @param data Represents the array buffer data.
+ * @param len Represents the length of data param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsArrayBuffer Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsArrayBuffer_SetData(OH_UdsArrayBuffer* buffer, unsigned char* data, unsigned int len);
+
+/**
+ * @brief Get array buffer data from the {@link OH_UdsArrayBuffer}.
+ *
+ * @param buffer Represents a pointer to an instance of {@link OH_UdsArrayBuffer}.
+ * @param data Represents a pointer to array buffer data that is a output param.
+ * @param len Represents the array buffer data length that is a output param.
+ * @return Returns the status code of the execution. See {@link Udmf_ErrCode}.
+ *         {@link UDMF_E_OK} success.
+ *         {@link UDMF_E_INVALID_PARAM} The error code for common invalid args.
+ * @see OH_UdsArrayBuffer Udmf_ErrCode
+ * @since 13
+ */
+int OH_UdsArrayBuffer_GetData(OH_UdsArrayBuffer* buffer, unsigned char** data, unsigned int* len);
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif
diff --git a/udmf/interfaces/ndk/data/utd.h b/udmf/interfaces/ndk/data/utd.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c85052bc2c7db57f7e492f34ca6cc7060b0a804
--- /dev/null
+++ b/udmf/interfaces/ndk/data/utd.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup UDMF
+ * @{
+ *
+ * @brief The Unified Data Management Framework(UDMF) aims to define various standards
+ * for data across applications, devices, and platforms, providing a unified OpenHarmony
+ * data language and standardized data access and reading paths.
+ *
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ * @since 12
+ */
+
+/**
+ * @file utd.h
+ *
+ * @brief Provides uniform type descriptor(UTD) related functions and struct.
+ *
+ * @kit ArkData
+ * @library libudmf.so
+ * @syscap SystemCapability.DistributedDataManager.UDMF.Core
+ * @since 12
+ */
+
+#ifndef UTD_H
+#define UTD_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Describes the unified data type descriptor.
+ *
+ * @since 12
+ */
+typedef struct OH_Utd OH_Utd;
+
+/**
+ * @brief Prouct a pointer to the instance of the {@link OH_Utd}.
+ *
+ * @param typeId Represents type of UTD, reference udmf_meta.h.
+ * @return If the operation is successful, a pointer to the instance of the {@link OH_Utd}
+ * structure is returned.If the operation is failed, nullptr is returned.
+ * Must be destroyed with {@link OH_Utd_DestroyTypeDescriptor} when not needed.
+ * @see OH_Utd.
+ * @since 12
+ */
+OH_Utd* OH_Utd_Create(const char* typeId);
+
+/**
+ * @brief Destroy a pointer that points to the {@link OH_Utd} instance.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @see OH_Utd.
+ * @since 12
+ */
+void OH_Utd_Destroy(OH_Utd* pThis);
+
+/**
+ * @brief Get type id from the {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @return Returns a string pointer when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char* OH_Utd_GetTypeId(OH_Utd* pThis);
+
+/**
+ * @brief Get description from the {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @return Returns a string pointer when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char* OH_Utd_GetDescription(OH_Utd* pThis);
+
+/**
+ * @brief Get url from the {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @return Returns a string pointer when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char* OH_Utd_GetReferenceUrl(OH_Utd* pThis);
+
+/**
+ * @brief Get icon file from the {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @return Returns a string pointer when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char* OH_Utd_GetIconFile(OH_Utd* pThis);
+
+/**
+ * @brief Get belong to type id of the current {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @param count Represents the return types count.
+ * @return Returns string array when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char** OH_Utd_GetBelongingToTypes(OH_Utd* pThis, unsigned int* count);
+
+/**
+ * @brief Get filename extensions of the current {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @param count Represents the return file extensions count.
+ * @return Returns string array when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char** OH_Utd_GetFilenameExtensions(OH_Utd* pThis, unsigned int* count);
+
+/**
+ * @brief Get mime types of the current {@link OH_Utd}.
+ *
+ * @param pThis Represents a pointer to an instance of {@link OH_Utd}.
+ * @param count Represents the mime types count.
+ * @return Returns string array when input args normally, otherwise return nullptr.
+ * @see OH_Utd.
+ * @since 12
+ */
+const char** OH_Utd_GetMimeTypes(OH_Utd* pThis, unsigned int* count);
+
+/**
+ * @brief Get type id by file name extension.
+ *
+ * @param extension Represents file name extension.
+ * @param count Represents the types count.
+ * @return Returns string list of types. Must be destroyed with {@link OH_Utd_DestroyStringList} when not needed.
+ * @since 12
+ */
+const char** OH_Utd_GetTypesByFilenameExtension(const char* extension, unsigned int* count);
+
+/**
+ * @brief Get type id by mime type.
+ *
+ * @param mimeType Represents mime type
+ * @param count Represents the types count.
+ * @return Returns string list of types. Must be destroyed with {@link OH_Utd_DestroyStringList} when not needed.
+ * @since 12
+ */
+const char** OH_Utd_GetTypesByMimeType(const char* mimeType, unsigned int* count);
+
+/**
+ * @brief Calculate relationships of two types.
+ *
+ * @param srcTypeId Represents source type id.
+ * @param destTypeId Represents target type id.
+ * @return Returns the status code of the execution.
+ *         {@code false} Represents srcTypeId not belongs to destTypeId.
+ *         {@code true} Represents srcTypeId belongs to destTypeId.
+ * @since 12
+ */
+bool OH_Utd_BelongsTo(const char* srcTypeId, const char* destTypeId);
+
+/**
+ * @brief Calculate relationships of two types.
+ *
+ * @param srcTypeId Represents source type id.
+ * @param destTypeId Represents target type id.
+ * @return Returns the status code of the execution.
+ *         {@code false} Represents srcTypeId not lower level to destTypeId.
+ *         {@code true} Represents srcTypeId lower level to destTypeId.
+ * @since 12
+ */
+bool OH_Utd_IsLower(const char* srcTypeId, const char* destTypeId);
+
+/**
+ * @brief Calculate relationships of two types.
+ *
+ * @param srcTypeId Represents source type id.
+ * @param destTypeId Represents target type id.
+ * @return Returns the status code of the execution.
+ *         {@code false} Represents srcTypeId not higher level to destTypeId.
+ *         {@code true} Represents srcTypeId higher level to destTypeId.
+ * @since 12
+ */
+bool OH_Utd_IsHigher(const char* srcTypeId, const char* destTypeId);
+
+/**
+ * @brief Calculate two {@link OH_Utd}s are equal.
+ *
+ * @param utd1 Represents a pointer to {@link OH_Utd} instance.
+ * @param utd2 Represents a pointer to {@link OH_Utd} instance.
+ * @return Returns the status code of the execution.
+ *         {@code false} Represents utd1 and utd2 are not equal.
+ *         {@code true} Represents utd1 and utd2 are equal.
+ * @since 12
+ */
+bool OH_Utd_Equals(OH_Utd* utd1, OH_Utd* utd2);
+
+/**
+ * @brief Destroy string list memory.
+ *
+ * @param list Represents a point to string list.
+ * @param count Represents string count in list.
+ * @since 12
+ */
+void OH_Utd_DestroyStringList(const char** list, unsigned int count);
+
+#ifdef __cplusplus
+};
+#endif
+
+/** @} */
+#endif
diff --git a/udmf/udmf.gni b/udmf/udmf.gni
index a38869fa42703459d47dd083bbd32641ebe97a21..3223d8663ece0c8a2a64bbcf774e08425eb36162 100644
--- a/udmf/udmf.gni
+++ b/udmf/udmf.gni
@@ -13,7 +13,11 @@
 
 third_party_path = "//third_party"
 
-aafwk_path = "//foundation/ability/ability_runtime"
+if (is_arkui_x) {
+  aafwk_path = "//foundation/appframework/ability/ability_runtime"
+} else {
+  aafwk_path = "//foundation/ability/ability_runtime"
+}
 
 aafwk_inner_api_path = "${aafwk_path}/interfaces/inner_api"